Annotation of rpl/src/transliteration.c, revision 1.1
1.1 ! bertrand 1: /*
! 2: ================================================================================
! 3: RPL/2 (R) version 4.0.9
! 4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
! 5:
! 6: This file is part of RPL/2.
! 7:
! 8: RPL/2 is free software; you can redistribute it and/or modify it
! 9: under the terms of the CeCILL V2 License as published by the french
! 10: CEA, CNRS and INRIA.
! 11:
! 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
! 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
! 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
! 15: for more details.
! 16:
! 17: You should have received a copy of the CeCILL License
! 18: along with RPL/2. If not, write to info@cecill.info.
! 19: ================================================================================
! 20: */
! 21:
! 22:
! 23: #include "rpl.conv.h"
! 24: #include <stdarg.h>
! 25: #undef fprintf
! 26: #undef printf
! 27:
! 28:
! 29: /*
! 30: ================================================================================
! 31: Fonction de translitération
! 32: ================================================================================
! 33: Entrées :
! 34: --------------------------------------------------------------------------------
! 35: Sorties :
! 36: --------------------------------------------------------------------------------
! 37: Effets de bord : néant
! 38: ================================================================================
! 39: */
! 40:
! 41: unsigned char *
! 42: transliteration(struct_processus *s_etat_processus,
! 43: unsigned char *chaine_entree,
! 44: unsigned char *codage_entree,
! 45: unsigned char *codage_sortie)
! 46: {
! 47: unsigned char *codage_sortie_transliteral;
! 48: unsigned char *tampon;
! 49:
! 50: if ((codage_sortie_transliteral = malloc((strlen(codage_sortie)
! 51: + strlen("//TRANSLIT") + 1) * sizeof(unsigned char))) == NULL)
! 52: {
! 53: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 54: return(NULL);
! 55: }
! 56:
! 57: sprintf(codage_sortie_transliteral, "%s//TRANSLIT", codage_sortie);
! 58:
! 59: tampon = reencodage(s_etat_processus, chaine_entree,
! 60: codage_entree, codage_sortie_transliteral);
! 61: free(codage_sortie_transliteral);
! 62:
! 63: return(tampon);
! 64: }
! 65:
! 66:
! 67: unsigned char *
! 68: reencodage(struct_processus *s_etat_processus,
! 69: unsigned char *chaine_entree,
! 70: unsigned char *codage_entree,
! 71: unsigned char *codage_sortie)
! 72: {
! 73: # define d_LONGUEUR 1024
! 74:
! 75: iconv_t transcodage;
! 76:
! 77: size_t ios;
! 78: size_t longueur_entree;
! 79: size_t longueur_sortie;
! 80:
! 81: unsigned char *buffer_entree;
! 82: unsigned char *buffer_sortie;
! 83: unsigned char *chaine_sortie;
! 84: unsigned char *pointeur;
! 85: unsigned char *tampon;
! 86:
! 87: if ((transcodage = iconv_open(codage_sortie, codage_entree)) ==
! 88: (iconv_t) -1)
! 89: {
! 90: (*s_etat_processus).erreur_execution = d_ex_erreur_transcodage;
! 91: return(NULL);
! 92: }
! 93:
! 94: buffer_entree = chaine_entree;
! 95: longueur_entree = strlen(chaine_entree);
! 96:
! 97: if ((chaine_sortie = malloc(sizeof(unsigned char))) == NULL)
! 98: {
! 99: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 100: return(NULL);
! 101: }
! 102:
! 103: chaine_sortie[0] = d_code_fin_chaine;
! 104:
! 105: if ((buffer_sortie = malloc((d_LONGUEUR + 1) * sizeof(char))) == NULL)
! 106: {
! 107: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 108: return(NULL);
! 109: }
! 110:
! 111: do
! 112: {
! 113: longueur_sortie = d_LONGUEUR;
! 114: pointeur = buffer_sortie;
! 115:
! 116: if ((ios = iconv(transcodage, (char **) &buffer_entree,
! 117: &longueur_entree, (char **) &pointeur, &longueur_sortie))
! 118: == (size_t) -1)
! 119: {
! 120: // On autorise les erreurs EINVAL et EILSEQ
! 121: if (errno == EILSEQ)
! 122: {
! 123: free(buffer_sortie);
! 124: (*s_etat_processus).erreur_execution = d_ex_erreur_transcodage;
! 125: return(NULL);
! 126: }
! 127: }
! 128:
! 129: tampon = (unsigned char *) chaine_sortie;
! 130: (*pointeur) = d_code_fin_chaine;
! 131:
! 132: if ((chaine_sortie = malloc((strlen(tampon) + strlen(buffer_sortie) + 1)
! 133: * sizeof(unsigned char))) == NULL)
! 134: {
! 135: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 136: return(NULL);
! 137: }
! 138:
! 139: sprintf(chaine_sortie, "%s%s", tampon, buffer_sortie);
! 140: free(tampon);
! 141: } while((*buffer_entree) != d_code_fin_chaine);
! 142:
! 143: free(buffer_sortie);
! 144: iconv_close(transcodage);
! 145:
! 146: return(chaine_sortie);
! 147: }
! 148:
! 149:
! 150: /*
! 151: ================================================================================
! 152: Fonctions spécifiques
! 153: ================================================================================
! 154: Entrées :
! 155: --------------------------------------------------------------------------------
! 156: Sorties :
! 157: --------------------------------------------------------------------------------
! 158: Effets de bord : néant
! 159: ================================================================================
! 160: */
! 161:
! 162: void
! 163: localisation_courante(struct_processus *s_etat_processus)
! 164: {
! 165: char **arguments;
! 166:
! 167: int ios;
! 168: int pipes_entree[2];
! 169: int pipes_erreur[2];
! 170: int pipes_sortie[2];
! 171: int status;
! 172:
! 173: logical1 drapeau_fin;
! 174:
! 175: long i;
! 176: long nombre_arguments;
! 177:
! 178: pid_t pid;
! 179:
! 180: sigset_t oldset;
! 181: sigset_t set;
! 182:
! 183: struct sigaction action_passee;
! 184:
! 185: unsigned char *tampon;
! 186:
! 187: unsigned long longueur_lecture;
! 188: unsigned long nombre_iterations;
! 189: unsigned long pointeur;
! 190:
! 191: if ((arguments = malloc(3 * sizeof(char **))) == NULL)
! 192: {
! 193: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 194: return;
! 195: }
! 196:
! 197: if ((arguments[0] = malloc((strlen("locale") + 1) * sizeof(char))) == NULL)
! 198: {
! 199: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 200: return;
! 201: }
! 202:
! 203: if ((arguments[1] = malloc((strlen("charmap") + 1) * sizeof(char))) == NULL)
! 204: {
! 205: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 206: return;
! 207: }
! 208:
! 209: strcpy(arguments[0], "locale");
! 210: strcpy(arguments[1], "charmap");
! 211: arguments[2] = NULL;
! 212:
! 213: nombre_arguments = 2;
! 214: drapeau_fin = d_faux;
! 215:
! 216: if (pipe(pipes_entree) != 0)
! 217: {
! 218: (*s_etat_processus).erreur_systeme = d_es_processus;
! 219: return;
! 220: }
! 221:
! 222: if (pipe(pipes_sortie) != 0)
! 223: {
! 224: (*s_etat_processus).erreur_systeme = d_es_processus;
! 225: return;
! 226: }
! 227:
! 228: if (pipe(pipes_erreur) != 0)
! 229: {
! 230: (*s_etat_processus).erreur_systeme = d_es_processus;
! 231: return;
! 232: }
! 233:
! 234: sigfillset(&set);
! 235: pthread_sigmask(SIG_BLOCK, &set, &oldset);
! 236:
! 237: verrouillage_threads_concurrents(s_etat_processus);
! 238: pid = fork();
! 239: deverrouillage_threads_concurrents(s_etat_processus);
! 240:
! 241: pthread_sigmask(SIG_SETMASK, &oldset, NULL);
! 242: sigpending(&set);
! 243:
! 244: if (pid < 0)
! 245: {
! 246: if (close(pipes_entree[0]) != 0)
! 247: {
! 248: (*s_etat_processus).erreur_systeme = d_es_processus;
! 249: return;
! 250: }
! 251:
! 252: if (close(pipes_entree[1]) != 0)
! 253: {
! 254: (*s_etat_processus).erreur_systeme = d_es_processus;
! 255: return;
! 256: }
! 257:
! 258: if (close(pipes_sortie[0]) != 0)
! 259: {
! 260: (*s_etat_processus).erreur_systeme = d_es_processus;
! 261: return;
! 262: }
! 263:
! 264: if (close(pipes_sortie[1]) != 0)
! 265: {
! 266: (*s_etat_processus).erreur_systeme = d_es_processus;
! 267: return;
! 268: }
! 269:
! 270: if (close(pipes_erreur[0]) != 0)
! 271: {
! 272: (*s_etat_processus).erreur_systeme = d_es_processus;
! 273: return;
! 274: }
! 275:
! 276: if (close(pipes_erreur[1]) != 0)
! 277: {
! 278: (*s_etat_processus).erreur_systeme = d_es_processus;
! 279: return;
! 280: }
! 281:
! 282: (*s_etat_processus).erreur_systeme = d_es_processus;
! 283: return;
! 284: }
! 285: else if (pid == 0)
! 286: {
! 287: if (close(pipes_entree[1]) != 0)
! 288: {
! 289: (*s_etat_processus).erreur_systeme = d_es_processus;
! 290: return;
! 291: }
! 292:
! 293: if (close(pipes_sortie[0]) != 0)
! 294: {
! 295: (*s_etat_processus).erreur_systeme = d_es_processus;
! 296: return;
! 297: }
! 298:
! 299: if (close(pipes_erreur[0]) != 0)
! 300: {
! 301: (*s_etat_processus).erreur_systeme = d_es_processus;
! 302: return;
! 303: }
! 304:
! 305: if (pipes_entree[0] != STDIN_FILENO)
! 306: {
! 307: if (dup2(pipes_entree[0], STDIN_FILENO) == -1)
! 308: {
! 309: (*s_etat_processus).erreur_systeme = d_es_processus;
! 310: return;
! 311: }
! 312: }
! 313:
! 314: if (pipes_sortie[1] != STDOUT_FILENO)
! 315: {
! 316: if (dup2(pipes_sortie[1], STDOUT_FILENO) == -1)
! 317: {
! 318: (*s_etat_processus).erreur_systeme = d_es_processus;
! 319: return;
! 320: }
! 321: }
! 322:
! 323: if (pipes_sortie[1] != STDERR_FILENO)
! 324: {
! 325: if (dup2(pipes_sortie[1], STDERR_FILENO) == -1)
! 326: {
! 327: (*s_etat_processus).erreur_systeme = d_es_processus;
! 328: return;
! 329: }
! 330: }
! 331:
! 332: if (nombre_arguments != 0)
! 333: {
! 334: execvp(arguments[0], arguments);
! 335: }
! 336: else
! 337: {
! 338: exit(EXIT_SUCCESS);
! 339: }
! 340:
! 341: /*
! 342: * L'appel système execvp() a généré une erreur et n'a pu exécuter
! 343: * argument[0] (fichier non exécutable ou inexistant).
! 344: */
! 345:
! 346: close(pipes_entree[0]);
! 347: close(pipes_sortie[1]);
! 348:
! 349: for(i = 0; i < nombre_arguments; i++)
! 350: {
! 351: free(arguments[i]);
! 352: }
! 353:
! 354: free(arguments);
! 355: (*s_etat_processus).erreur_systeme = d_es_processus;
! 356:
! 357: /*
! 358: * Envoi d'une erreur dans le pipe idoine. On ne regarde pas
! 359: * le nombre d'octets écrits car l'erreur ne pourra de toute
! 360: * façon pas être traitée.
! 361: */
! 362:
! 363: write_atomic(s_etat_processus, pipes_erreur[1], " ", 1);
! 364: close(pipes_erreur[1]);
! 365:
! 366: exit(EXIT_SUCCESS);
! 367: }
! 368: else
! 369: {
! 370: if (close(pipes_entree[0]) != 0)
! 371: {
! 372: (*s_etat_processus).erreur_systeme = d_es_processus;
! 373: return;
! 374: }
! 375:
! 376: if (close(pipes_sortie[1]) != 0)
! 377: {
! 378: (*s_etat_processus).erreur_systeme = d_es_processus;
! 379: return;
! 380: }
! 381:
! 382: if (close(pipes_erreur[1]) != 0)
! 383: {
! 384: (*s_etat_processus).erreur_systeme = d_es_processus;
! 385: return;
! 386: }
! 387:
! 388: if (close(pipes_entree[1]) != 0)
! 389: {
! 390: (*s_etat_processus).erreur_systeme = d_es_processus;
! 391: return;
! 392: }
! 393:
! 394: do
! 395: {
! 396: if (kill(pid, 0) != 0)
! 397: {
! 398: break;
! 399: }
! 400:
! 401: /*
! 402: * Récupération de la valeur de retour du processus détaché
! 403: */
! 404:
! 405: if (sem_post(&((*s_etat_processus).semaphore_fork))
! 406: != 0)
! 407: {
! 408: (*s_etat_processus).erreur_systeme = d_es_processus;
! 409: return;
! 410: }
! 411:
! 412: if (waitpid(pid, &status, 0) == -1)
! 413: {
! 414: if (sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 415: {
! 416: if (errno != EINTR)
! 417: {
! 418: (*s_etat_processus).erreur_systeme = d_es_processus;
! 419: return;
! 420: }
! 421: }
! 422:
! 423: (*s_etat_processus).erreur_systeme = d_es_processus;
! 424: return;
! 425: }
! 426:
! 427: if (sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 428: {
! 429: if (errno != EINTR)
! 430: {
! 431: (*s_etat_processus).erreur_systeme = d_es_processus;
! 432: return;
! 433: }
! 434: }
! 435: } while((!WIFEXITED(status)) && (!WIFSIGNALED(status)));
! 436:
! 437: longueur_lecture = 256;
! 438: pointeur = 0;
! 439: nombre_iterations = 1;
! 440:
! 441: if ((tampon = malloc((longueur_lecture + 1) *
! 442: sizeof(unsigned char))) == NULL)
! 443: {
! 444: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 445: return;
! 446: }
! 447:
! 448: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 449: {
! 450: (*s_etat_processus).erreur_systeme = d_es_processus;
! 451: return;
! 452: }
! 453:
! 454: while((ios = read_atomic(s_etat_processus,
! 455: pipes_sortie[0], &(tampon[pointeur]),
! 456: longueur_lecture)) > 0)
! 457: {
! 458: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 459: {
! 460: if (errno != EINTR)
! 461: {
! 462: (*s_etat_processus).erreur_systeme = d_es_processus;
! 463: return;
! 464: }
! 465: }
! 466:
! 467: tampon[pointeur + ios] = d_code_fin_chaine;
! 468: pointeur += longueur_lecture;
! 469: nombre_iterations++;
! 470:
! 471: if ((tampon = realloc(tampon,
! 472: ((nombre_iterations * longueur_lecture) + 1) *
! 473: sizeof(unsigned char))) == NULL)
! 474: {
! 475: (*s_etat_processus).erreur_systeme =
! 476: d_es_allocation_memoire;
! 477: return;
! 478: }
! 479:
! 480: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 481: {
! 482: (*s_etat_processus).erreur_systeme = d_es_processus;
! 483: return;
! 484: }
! 485: }
! 486:
! 487: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 488: {
! 489: if (errno != EINTR)
! 490: {
! 491: (*s_etat_processus).erreur_systeme = d_es_processus;
! 492: return;
! 493: }
! 494: }
! 495:
! 496: if (strlen(tampon) == 0)
! 497: {
! 498: (*s_etat_processus).erreur_systeme = d_es_processus;
! 499: return;
! 500: }
! 501:
! 502: tampon[strlen(tampon) - 1] = d_code_fin_chaine;
! 503:
! 504: if (ios == -1)
! 505: {
! 506: (*s_etat_processus).erreur_systeme = d_es_processus;
! 507: return;
! 508: }
! 509:
! 510: if (close(pipes_sortie[0]) != 0)
! 511: {
! 512: (*s_etat_processus).erreur_systeme = d_es_processus;
! 513: return;
! 514: }
! 515:
! 516: (*s_etat_processus).localisation = tampon;
! 517:
! 518: if (sigaction(SIGINT, &action_passee, NULL) != 0)
! 519: {
! 520: for(i = 0; i < nombre_arguments; i++)
! 521: {
! 522: free(arguments[i]);
! 523: }
! 524:
! 525: free(arguments);
! 526: (*s_etat_processus).erreur_systeme = d_es_signal;
! 527: return;
! 528: }
! 529:
! 530: for(i = 0; i < nombre_arguments; i++)
! 531: {
! 532: free(arguments[i]);
! 533: }
! 534:
! 535: free(arguments);
! 536:
! 537: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
! 538: {
! 539: (*s_etat_processus).erreur_systeme = d_es_processus;
! 540: return;
! 541: }
! 542:
! 543: if (read_atomic(s_etat_processus, pipes_erreur[0], tampon, 1) > 0)
! 544: {
! 545: // Le processus fils renvoie une erreur.
! 546:
! 547: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 548: {
! 549: if (errno != EINTR)
! 550: {
! 551: (*s_etat_processus).erreur_systeme = d_es_processus;
! 552: return;
! 553: }
! 554: }
! 555:
! 556: (*s_etat_processus).erreur_execution = d_ex_erreur_processus;
! 557: return;
! 558: }
! 559:
! 560: while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
! 561: {
! 562: if (errno != EINTR)
! 563: {
! 564: (*s_etat_processus).erreur_systeme = d_es_processus;
! 565: return;
! 566: }
! 567: }
! 568:
! 569: if (close(pipes_erreur[0]) != 0)
! 570: {
! 571: (*s_etat_processus).erreur_systeme = d_es_processus;
! 572: return;
! 573: }
! 574: }
! 575:
! 576: return;
! 577: }
! 578:
! 579: static int
! 580: vtransliterated_sprintf(char **strp, const char *fmt, va_list ap)
! 581: {
! 582: size_t bs, s;
! 583: char *b = NULL;
! 584: va_list cap;
! 585:
! 586: va_copy(cap, ap);
! 587:
! 588: for(bs = 256;; bs *= 2)
! 589: {
! 590: va_copy(ap, cap);
! 591: if (b != NULL) free(b);
! 592: if ((b = malloc(sizeof(*b) * bs)) == NULL) return -1;
! 593: if (((int) (s = vsnprintf(b, bs, fmt, ap))) < 0)
! 594: { va_end(ap); free(b); return -1; }
! 595: va_end(ap);
! 596: if (s < bs) break;
! 597: }
! 598:
! 599: if (((*strp) = realloc(b, ((s = strlen(b)) + 1) * sizeof(*b)))
! 600: == NULL) { free(b); return -1; }
! 601: return s;
! 602: }
! 603:
! 604: int
! 605: transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
! 606: const char *format, ...)
! 607: {
! 608: int ios;
! 609: char *tampon;
! 610: unsigned char *tampon2;
! 611: va_list arguments;
! 612:
! 613: va_start(arguments, format);
! 614:
! 615: if (vtransliterated_sprintf(&tampon, format, arguments) < 0)
! 616: {
! 617: va_end(arguments);
! 618:
! 619: if (s_etat_processus != NULL)
! 620: {
! 621: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 622: }
! 623:
! 624: return(-1);
! 625: }
! 626:
! 627: va_end(arguments);
! 628:
! 629: if (s_etat_processus != NULL)
! 630: {
! 631: if ((tampon2 = transliteration(s_etat_processus, tampon,
! 632: d_locale, (*s_etat_processus).localisation)) == NULL)
! 633: {
! 634: free(tampon);
! 635: return(-1);
! 636: }
! 637:
! 638: free(tampon);
! 639: }
! 640: else
! 641: {
! 642: tampon2 = tampon;
! 643: }
! 644:
! 645: # ifdef SunOS
! 646: while((ios = fprintf(flux, "%s", tampon2)) < 0)
! 647: {
! 648: if ((errno != EINTR) && (errno != 0))
! 649: {
! 650: break;
! 651: }
! 652: }
! 653: # else
! 654: ios = fprintf(flux, "%s", tampon2);
! 655: # endif
! 656:
! 657: free(tampon2);
! 658:
! 659: return(ios);
! 660: }
! 661:
! 662: #define fprintf NULL
! 663: #define printf NULL
! 664:
! 665: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to transliteration.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src