File:  [local] / rpl / src / messages.c
Revision 1.35: download - view: text, annotated - select for diffs - revision graph
Wed Jun 22 13:27:04 2011 UTC (12 years, 10 months ago) by bertrand
Branches: MAIN
CVS tags: HEAD
En route pour la 4.1.0.prerelease.3.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.0.prerelease.3
    4:   Copyright (C) 1989-2011 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: #define MESSAGES
   24: #include "rpl-conv.h"
   25: 
   26: 
   27: /*
   28: ================================================================================
   29:   Affichage des messages d'erreur
   30: ================================================================================
   31:   Entrées : structure sur l'état du processus
   32: --------------------------------------------------------------------------------
   33:   Sorties : néant
   34: --------------------------------------------------------------------------------
   35:   Effets de bord : néant
   36: ================================================================================
   37: */
   38: 
   39: unsigned char *
   40: messages(struct_processus *s_etat_processus)
   41: {
   42:     logical1                erreur_fonction_externe;
   43: 
   44:     unsigned char           *message;
   45:     unsigned char           *chaine;
   46:     unsigned char           *argument;
   47: 
   48:     chaine = NULL;
   49:     argument = NULL;
   50: 
   51:     erreur_fonction_externe = d_faux;
   52: 
   53:     (*s_etat_processus).derniere_exception = d_ep;
   54:     (*s_etat_processus).derniere_erreur_execution = d_ex;
   55:     (*s_etat_processus).derniere_erreur_systeme = d_es;
   56: 
   57:     if ((*s_etat_processus).erreur_execution != d_ex)
   58:     {
   59:         (*s_etat_processus).derniere_erreur_execution =
   60:                 (*s_etat_processus).erreur_execution;
   61: 
   62: /*
   63: --------------------------------------------------------------------------------
   64:   Erreurs dues aux définitions
   65: --------------------------------------------------------------------------------
   66: */
   67: 
   68:         switch((*s_etat_processus).erreur_execution)
   69:         {
   70:             case d_ex_pile_vide :
   71:             {
   72:                 if ((*s_etat_processus).langue == 'F')
   73:                 {
   74:                     chaine = "+++Erreur : Pile opérationnelle vide";
   75:                 }
   76:                 else
   77:                 {
   78:                     chaine = "+++Error : Empty stack";
   79:                 }
   80: 
   81:                 break;
   82:             }
   83: 
   84:             case d_ex_manque_argument :
   85:             {
   86:                 if ((*s_etat_processus).langue == 'F')
   87:                 {
   88:                     chaine ="+++Erreur : Arguments insuffisants pour la "
   89:                             "commande %s";
   90:                     argument = (*s_etat_processus).instruction_derniere_erreur;
   91:                 }
   92:                 else
   93:                 {
   94:                     chaine = "+++Error : Too few arguments for %s "
   95:                             "command";
   96:                     argument = (*s_etat_processus).instruction_derniere_erreur;
   97:                 }
   98: 
   99:                 break;
  100:             }
  101: 
  102:             case d_ex_argument_invalide :
  103:             {
  104:                 if ((*s_etat_processus).langue == 'F')
  105:                 {
  106:                     chaine = "+++Erreur : Argument invalide pour la "
  107:                             "commande %s";
  108:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  109:                 }
  110:                 else
  111:                 {
  112:                     chaine = "+++Error : Invalid argument for "
  113:                             "%s command";
  114:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  115:                 }
  116: 
  117:                 break;
  118:             }
  119: 
  120:             case d_ex_nom_reserve :
  121:             {
  122:                 if ((*s_etat_processus).langue == 'F')
  123:                 {
  124:                     chaine = "Erreur : Nom '%s' réservé";
  125:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  126:                 }
  127:                 else
  128:                 {
  129:                     chaine = "Error : '%s' reserved name";
  130:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  131:                 }
  132: 
  133:                 break;
  134:             }
  135: 
  136:             case d_ex_erreur_type_argument :
  137:             {
  138:                 if ((*s_etat_processus).langue == 'F')
  139:                 {
  140:                     chaine = "+++Erreur : Type d'argument invalide pour la "
  141:                             "commande %s";
  142:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  143:                 }
  144:                 else
  145:                 {
  146:                     chaine = "+++Error : Invalid argument type for "
  147:                             "%s command";
  148:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  149:                 }
  150: 
  151:                 break;
  152:             }
  153: 
  154:             case d_ex_nombre_arguments :
  155:             {
  156:                 if ((*s_etat_processus).langue == 'F')
  157:                 {
  158:                     chaine = "+++Erreur : Une même fonction apparaît avec "
  159:                             "des nombres d'arguments différents (%s)";
  160:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  161:                 }
  162:                 else
  163:                 {
  164:                     chaine = "+++Error : The same function seems to have "
  165:                             "different numbers of arguments (%s)";
  166:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  167:                 }
  168: 
  169:                 break;
  170:             }
  171: 
  172:             case d_ex_dimensions_invalides :
  173:             {
  174:                 if ((*s_etat_processus).langue == 'F')
  175:                 {
  176:                     chaine = "+++Erreur : Dimensions invalides pour "
  177:                             "l'instruction %s";
  178:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  179:                 }
  180:                 else
  181:                 {
  182:                     chaine = "+++Erreur : Invalid dimensions for "
  183:                             "%s instruction";
  184:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  185:                 }
  186: 
  187:                 break;
  188:             }
  189: 
  190:             case d_ex_expression_invalide :
  191:             {
  192:                 if ((*s_etat_processus).langue == 'F')
  193:                 {
  194:                     chaine = "+++Erreur : Expression %s invalide";
  195:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  196:                 }
  197:                 else
  198:                 {
  199:                     chaine = "+++Error : Invalid %s expression";
  200:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  201:                 }
  202: 
  203:                 break;
  204:             }
  205: 
  206:             case d_ex_erreur_traitement_condition :
  207:             {
  208:                 if ((*s_etat_processus).langue == 'F')
  209:                 {
  210:                     chaine = "+++Erreur : Traitement impossible d'une clause "
  211:                             "conditionnelle";
  212:                 }
  213:                 else
  214:                 {
  215:                     chaine = "+++Error : Illegal conditional structure";
  216:                 }
  217: 
  218:                 break;
  219:             }
  220: 
  221:             case d_ex_erreur_traitement_boucle :
  222:             {
  223:                 if ((*s_etat_processus).langue == 'F')
  224:                 {
  225:                     chaine = "+++Erreur : Traitement impossible "
  226:                             "d'une boucle";
  227:                 }
  228:                 else
  229:                 {
  230:                     chaine = "+++Error : Illegal loop structure";
  231:                 }
  232: 
  233:                 break;
  234:             }
  235: 
  236:             case d_ex_variable_non_definie :
  237:             {
  238:                 if ((*s_etat_processus).langue == 'F')
  239:                 {
  240:                     chaine = "+++Erreur : Variable non définie";
  241:                 }
  242:                 else
  243:                 {
  244:                     chaine = "+++Error : Undefined variable";
  245:                 }
  246: 
  247:                 break;
  248:             }
  249: 
  250:             case d_ex_drapeau_inexistant :
  251:             {
  252:                 if ((*s_etat_processus).langue == 'F')
  253:                 {
  254:                     chaine = "+++Erreur : Drapeau inexistant";
  255:                 }
  256:                 else
  257:                 {
  258:                     chaine = "+++Error : Non-existent flag";
  259:                 }
  260: 
  261:                 break;
  262:             }
  263: 
  264:             case d_ex_nom_invalide :
  265:             {
  266:                 if ((*s_etat_processus).langue == 'F')
  267:                 {
  268:                     chaine = "+++Erreur : Nom de variable invalide (%s)";
  269:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  270:                 }
  271:                 else
  272:                 {
  273:                     chaine = "+++Error : Invalid variable name (%s)";
  274:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  275:                 }
  276: 
  277:                 break;
  278:             }
  279: 
  280:             case d_ex_element_inexistant :
  281:             {
  282:                 if ((*s_etat_processus).langue == 'F')
  283:                 {
  284:                     chaine = "+++Erreur : Indice invalide";
  285:                 }
  286:                 else
  287:                 {
  288:                     chaine = "+++Error : Invalid index";
  289:                 }
  290: 
  291:                 break;
  292:             }
  293: 
  294:             case d_ex_absence_variable :
  295:             {
  296:                 if ((*s_etat_processus).langue == 'F')
  297:                 {
  298:                     chaine = "+++Erreur : Absence de variable";
  299:                 }
  300:                 else
  301:                 {
  302:                     chaine = "+++Error : Variable omission";
  303:                 }
  304: 
  305:                 break;
  306:             }
  307: 
  308:             case d_ex_erreur_evaluation :
  309:             {
  310:                 if ((*s_etat_processus).langue == 'F')
  311:                 {
  312:                     chaine = "+++Erreur : Erreur dans l'évaluation d'une "
  313:                             "expression";
  314:                 }
  315:                 else
  316:                 {
  317:                     chaine = "+++Error : Error in expression evaluation";
  318:                 }
  319: 
  320:                 break;
  321:             }
  322: 
  323:             case d_ex_longueur_fft :
  324:             {
  325:                 if ((*s_etat_processus).langue == 'F')
  326:                 {
  327:                     chaine = "+++Erreur : Longueur de FFT invalide";
  328:                 }
  329:                 else
  330:                 {
  331:                     chaine = "+++Error : Invalid FFT length";
  332:                 }
  333: 
  334:                 break;
  335:             }
  336: 
  337:             case d_ex_longueur_dft :
  338:             {
  339:                 if ((*s_etat_processus).langue == 'F')
  340:                 {
  341:                     chaine = "+++Erreur : Longueur de DFT invalide";
  342:                 }
  343:                 else
  344:                 {
  345:                     chaine = "+++Error : Invalid DFT length";
  346:                 }
  347: 
  348:                 break;
  349:             }
  350: 
  351:             case d_ex_queue_impression :
  352:             {
  353:                 if ((*s_etat_processus).langue == 'F')
  354:                 {
  355:                     chaine = "+++Erreur : Queue d'impression vide";
  356:                 }
  357:                 else
  358:                 {
  359:                     chaine = "+++Error : Empty printing spool queue";
  360:                 }
  361: 
  362:                 break;
  363:             }
  364: 
  365:             case d_ex_type_trace_invalide :
  366:             {
  367:                 if ((*s_etat_processus).langue == 'F')
  368:                 {
  369:                     chaine = "+++Erreur : Type de tracé invalide";
  370:                 }
  371:                 else
  372:                 {
  373:                     chaine = "+++Error : Invalid graph type";
  374:                 }
  375: 
  376:                 break;
  377:             }
  378: 
  379:             case d_ex_erreur_fichier :
  380:             {
  381:                 if ((*s_etat_processus).langue == 'F')
  382:                 {
  383:                     chaine = "+++Erreur : Erreur d'entrée/sortie sur un"
  384:                             " fichier ou une socket";
  385:                 }
  386:                 else
  387:                 {
  388:                     chaine = "+++Error : file or socket input/output error";
  389:                 }
  390: 
  391:                 break;
  392:             }
  393: 
  394:             case d_ex_absence_equation :
  395:             {
  396:                 if ((*s_etat_processus).langue == 'F')
  397:                 {
  398:                     chaine = "+++Erreur : Absence d'équation";
  399:                 }
  400:                 else
  401:                 {
  402:                     chaine = "+++Error : Equation omission";
  403:                 }
  404: 
  405:                 break;
  406:             }
  407: 
  408:             case d_ex_erreur_bibliotheque :
  409:             {
  410:                 if ((*s_etat_processus).langue == 'F')
  411:                 {
  412:                     chaine = "+++Erreur : Erreur portant sur une "
  413:                             "bibliothèque dynamique";
  414:                 }
  415:                 else
  416:                 {
  417:                     chaine = "+++Error : Dynamic library error";
  418:                 }
  419: 
  420:                 break;
  421:             }
  422: 
  423:             case d_ex_execution_bibliotheque :
  424:             {
  425:                 if ((*s_etat_processus).langue == 'F')
  426:                 {
  427:                     chaine = "+++Erreur : Problème lors de l'exécution d'une "
  428:                             "fonction externe";
  429:                 }
  430:                 else
  431:                 {
  432:                     chaine = "+++Error : External function execution "
  433:                             "error";
  434:                 }
  435: 
  436:                 break;
  437:             }
  438: 
  439:             case d_ex_matrice_statistique_invalide :
  440:             {
  441:                 if ((*s_etat_processus).langue == 'F')
  442:                 {
  443:                     chaine = "+++Erreur : Matrice statistique invalide";
  444:                 }
  445:                 else
  446:                 {
  447:                     chaine = "+++Error : Invalid statistical matrix";
  448:                 }
  449: 
  450:                 break;
  451:             }
  452: 
  453:             case d_ex_dimensions_matrice_statistique :
  454:             {
  455:                 if ((*s_etat_processus).langue == 'F')
  456:                 {
  457:                     chaine = "+++Erreur : Dimensions différentes des "
  458:                             "observations et de la matrice statistique";
  459:                 }
  460:                 else
  461:                 {
  462:                     chaine = "+++Error : Invalid dimensions between "
  463:                             "observations and statistical matrix";
  464:                 }
  465: 
  466:                 break;
  467:             }
  468: 
  469:             case d_ex_absence_observations :
  470:             {
  471:                 if ((*s_etat_processus).langue == 'F')
  472:                 {
  473:                     chaine = "+++Erreur : Absence de matrice statistique";
  474:                 }
  475:                 else
  476:                 {
  477:                     chaine = "+++Error : Statistical matrix omission";
  478:                 }
  479: 
  480:                 break;
  481:             }
  482: 
  483:             case d_ex_statistiques_echantillon :
  484:             {
  485:                 if ((*s_etat_processus).langue == 'F')
  486:                 {
  487:                     chaine = "+++Erreur : Echantillon trop restreint pour un "
  488:                             "calcul de statistique";
  489:                 }
  490:                 else
  491:                 {
  492:                     chaine = "+++Error : Too few statistical observations";
  493:                 }
  494: 
  495:                 break;
  496:             }
  497: 
  498:             case d_ex_observations_inexistantes :
  499:             {
  500:                 if ((*s_etat_processus).langue == 'F')
  501:                 {
  502:                     chaine = "+++Erreur : Colonne d'observations "
  503:                             "inexistante";
  504:                 }
  505:                 else
  506:                 {
  507:                     chaine = "+++Error : Non-existent observations column";
  508:                 }
  509: 
  510:                 break;
  511:             }
  512: 
  513:             case d_ex_syntaxe :
  514:             {
  515:                 if ((*s_etat_processus).langue == 'F')
  516:                 {
  517:                     chaine = "+++Erreur : Erreur de syntaxe";
  518:                 }
  519:                 else
  520:                 {
  521:                     chaine = "+++Error : Syntax error";
  522:                 }
  523: 
  524:                 break;
  525:             }
  526: 
  527:             case d_ex_cycle_hors_boucle :
  528:             {
  529:                 if ((*s_etat_processus).langue == 'F')
  530:                 {
  531:                     chaine = "+++Erreur : Instruction 'CYCLE' hors d'une"
  532:                             " boucle définie";
  533:                 }
  534:                 else
  535:                 {
  536:                     chaine = "+++Error : 'CYCLE' instruction out of any "
  537:                             "defined loop";
  538:                 }
  539: 
  540:                 break;
  541:             }
  542: 
  543:             case d_ex_conversion_unite :
  544:             {
  545:                 if ((*s_etat_processus).langue == 'F')
  546:                 {
  547:                     chaine = "+++Erreur : Conversion d'unité impossible";
  548:                 }
  549:                 else
  550:                 {
  551:                     chaine = "+++Error : Unit translation impossible";
  552:                 }
  553: 
  554:                 break;
  555:             }
  556: 
  557:             case d_ex_erreur_parametre_fichier :
  558:             {
  559:                 if ((*s_etat_processus).langue == 'F')
  560:                 {
  561:                     chaine = "+++Erreur : Paramètre de fichier ou de socket "
  562:                             "invalide";
  563:                 }
  564:                 else
  565:                 {
  566:                     chaine = "+++Error : Invalid file or socket parameter";
  567:                 }
  568: 
  569:                 break;
  570:             }
  571: 
  572:             case d_ex_erreur_acces_fichier :
  573:             {
  574:                 if ((*s_etat_processus).langue == 'F')
  575:                 {
  576:                     chaine = "+++Erreur : Erreur d'accès à un fichier ou à une"
  577:                             " socket";
  578:                 }
  579:                 else
  580:                 {
  581:                     chaine = "+++Error : File or socket access error";
  582:                 }
  583: 
  584:                 break;
  585:             }
  586: 
  587:             case d_ex_erreur_requete_fichier :
  588:             {
  589:                 if ((*s_etat_processus).langue == 'F')
  590:                 {
  591:                     chaine = "+++Erreur : Erreur de requête envers un "
  592:                             "fichier";
  593:                 }
  594:                 else
  595:                 {
  596:                     chaine = "+++Error : File request error";
  597:                 }
  598: 
  599:                 break;
  600:             }
  601: 
  602:             case d_ex_erreur_format_fichier :
  603:             {
  604:                 if ((*s_etat_processus).langue == 'F')
  605:                 {
  606:                     chaine = "+++Erreur : Erreur de format";
  607:                 }
  608:                 else
  609:                 {
  610:                     chaine = "+++Error : Format error";
  611:                 }
  612: 
  613:                 break;
  614:             }
  615: 
  616:             case d_ex_fichier_verrouille :
  617:             {
  618:                 if ((*s_etat_processus).langue == 'F')
  619:                 {
  620:                     chaine = "+++Erreur : Fichier verrouillé";
  621:                 }
  622:                 else
  623:                 {
  624:                     chaine = "+++Error : Locked file";
  625:                 }
  626: 
  627:                 break;
  628:             }
  629: 
  630:             case d_ex_verrou_indefini :
  631:             {
  632:                 if ((*s_etat_processus).langue == 'F')
  633:                 {
  634:                     chaine = "+++Erreur : Verrou indéfini";
  635:                 }
  636:                 else
  637:                 {
  638:                     chaine = "+++Error : Undefined lock";
  639:                 }
  640: 
  641:                 break;
  642:             }
  643: 
  644:             case d_ex_fin_de_fichier_atteinte :
  645:             {
  646:                 if ((*s_etat_processus).langue == 'F')
  647:                 {
  648:                     chaine = "+++Erreur : Fin de fichier atteinte";
  649:                 }
  650:                 else
  651:                 {
  652:                     chaine = "+++Error : End of file reached";
  653:                 }
  654: 
  655:                 break;
  656:             }
  657: 
  658:             case d_ex_debut_de_fichier_atteint :
  659:             {
  660:                 if ((*s_etat_processus).langue == 'F')
  661:                 {
  662:                     chaine = "+++Erreur : Début de fichier atteint";
  663:                 }
  664:                 else
  665:                 {
  666:                     chaine = "+++Error : Beginning of file reached";
  667:                 }
  668: 
  669:                 break;
  670:             }
  671: 
  672:             case d_ex_erreur_type_fichier :
  673:             {
  674:                 if ((*s_etat_processus).langue == 'F')
  675:                 {
  676:                     chaine = "+++Erreur : Type de fichier invalide";
  677:                 }
  678:                 else
  679:                 {
  680:                     chaine = "+++Error : Invalid file type";
  681:                 }
  682: 
  683:                 break;
  684:             }
  685: 
  686:             case d_ex_fichier_vide :
  687:             {
  688:                 if ((*s_etat_processus).langue == 'F')
  689:                 {
  690:                     chaine = "+++Erreur : Fichier vide";
  691:                 }
  692:                 else
  693:                 {
  694:                     chaine = "+++Error : Empty file";
  695:                 }
  696: 
  697:                 break;
  698:             }
  699: 
  700:             case d_ex_dimensions_differentes :
  701:             {
  702:                 if ((*s_etat_processus).langue == 'F')
  703:                 {
  704:                     chaine = "+++Erreur : Dimensions différentes pour "
  705:                             "deux graphiques à superposer";
  706:                 }
  707:                 else
  708:                 {
  709:                     chaine = "+++Error : Invalid graphical dimension";
  710:                 }
  711: 
  712:                 break;
  713:             }
  714: 
  715:             case d_ex_routines_mathematiques :
  716:             {
  717:                 if ((*s_etat_processus).langue == 'F')
  718:                 {
  719:                     chaine = "+++Erreur : Erreur interne dans la routine"
  720:                             " mathématique %s";
  721:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  722:                 }
  723:                 else
  724:                 {
  725:                     chaine = "+++Error : Internal error in mathematical"
  726:                          " subroutine %s";
  727:                     argument = (*s_etat_processus).instruction_derniere_erreur;
  728:                 }
  729: 
  730:                 break;
  731:             }
  732: 
  733:             case d_ex_exit_hors_boucle :
  734:             {
  735:                 if ((*s_etat_processus).langue == 'F')
  736:                 {
  737:                     chaine = "+++Erreur : Instruction 'EXIT' hors d'une"
  738:                             " boucle";
  739:                 }
  740:                 else
  741:                 {
  742:                     chaine = "+++Error : 'EXIT' instruction out of any "
  743:                             "loop";
  744:                 }
  745: 
  746:                 break;
  747:             }
  748: 
  749:             case d_ex_processus :
  750:             {
  751:                 if ((*s_etat_processus).langue == 'F')
  752:                 {
  753:                     chaine = "+++Erreur : Processus inexistant";
  754:                 }
  755:                 else
  756:                 {
  757:                     chaine = "+++Error : Non-existent process";
  758:                 }
  759: 
  760:                 break;
  761:             }
  762: 
  763:             case d_ex_image_processus :
  764:             {
  765:                 if ((*s_etat_processus).langue == 'F')
  766:                 {
  767:                     chaine = "+++Erreur : Création impossible de l'image"
  768:                             " du processus courant";
  769:                 }
  770:                 else
  771:                 {
  772:                     chaine = "+++Error : Cannot create dump of current process";
  773:                 }
  774: 
  775:                 break;
  776:             }
  777: 
  778:             case d_ex_erreur_sql :
  779:             {
  780:                 if ((*s_etat_processus).langue == 'F')
  781:                 {
  782:                     chaine = "+++Erreur : Requête SQL invalide";
  783:                 }
  784:                 else
  785:                 {
  786:                     chaine = "+++Error : Invalid SQL query";
  787:                 }
  788: 
  789:                 break;
  790:             }
  791: 
  792:             case d_ex_variable_verrouillee :
  793:             {
  794:                 if ((*s_etat_processus).langue == 'F')
  795:                 {
  796:                     chaine = "+++Erreur : Variable verrouillée";
  797:                 }
  798:                 else
  799:                 {
  800:                     chaine = "+++Error : Locked variable";
  801:                 }
  802: 
  803:                 break;
  804:             }
  805: 
  806:             case d_ex_variable_volatile :
  807:             {
  808:                 if ((*s_etat_processus).langue == 'F')
  809:                 {
  810:                     chaine = "+++Erreur : Variable volatile";
  811:                 }
  812:                 else
  813:                 {
  814:                     chaine = "+++Error : Volatile variable";
  815:                 }
  816: 
  817:                 break;
  818:             }
  819: 
  820:             case d_ex_erreur_processus :
  821:             {
  822:                 if ((*s_etat_processus).langue == 'F')
  823:                 {
  824:                     chaine = "+++Erreur : Commande inconnue";
  825:                 }
  826:                 else
  827:                 {
  828:                     chaine = "+++Error : Unknown command";
  829:                 }
  830: 
  831:                 break;
  832:             }
  833: 
  834:             case d_ex_erreur_impression :
  835:             {
  836:                 if ((*s_etat_processus).langue == 'F')
  837:                 {
  838:                     chaine = "+++Erreur : Fichier d'impression erroné";
  839:                 }
  840:                 else
  841:                 {
  842:                     chaine = "+++Error : Erroneous print file";
  843:                 }
  844: 
  845:                 break;
  846:             }
  847: 
  848:             case d_ex_nombre_arguments_fonction :
  849:             {
  850:                 if ((*s_etat_processus).langue == 'F')
  851:                 {
  852:                     chaine = "+++Erreur : Nombre d'arguments invalide";
  853:                 }
  854:                 else
  855:                 {
  856:                     chaine = "+++Error : Invalid number of arguments";
  857:                 }
  858: 
  859:                 break;
  860:             }
  861: 
  862:             case d_ex_fonction_indisponible :
  863:             {
  864:                 if ((*s_etat_processus).langue == 'F')
  865:                 {
  866:                     chaine = "+++Erreur : Fonction indisponible";
  867:                 }
  868:                 else
  869:                 {
  870:                     chaine = "+++Error : Unavailable function";
  871:                 }
  872: 
  873:                 break;
  874:             }
  875: 
  876:             case d_ex_bibliotheque_chargee :
  877:             {
  878:                 if ((*s_etat_processus).langue == 'F')
  879:                 {
  880:                     chaine = "+++Erreur : Bibliothèque ouverte";
  881:                 }
  882:                 else
  883:                 {
  884:                     chaine = "+++Error : Opened library";
  885:                 }
  886: 
  887:                 break;
  888:             }
  889: 
  890:             case d_ex_aucun_symbole :
  891:             {
  892:                 if ((*s_etat_processus).langue == 'F')
  893:                 {
  894:                     chaine = "+++Erreur : Aucun symbole déclaré";
  895:                 }
  896:                 else
  897:                 {
  898:                     chaine = "+++Error : Too few symbols";
  899:                 }
  900: 
  901:                 break;
  902:             }
  903: 
  904:             case d_ex_definition_ambigue :
  905:             {
  906:                 if ((*s_etat_processus).langue == 'F')
  907:                 {
  908:                     chaine = "+++Erreur : Définition externe ambiguë";
  909:                 }
  910:                 else
  911:                 {
  912:                     chaine = "+++Error : Ambiguous external definition";
  913:                 }
  914: 
  915:                 break;
  916:             }
  917: 
  918:             case d_ex_fichier_hors_contexte :
  919:             {
  920:                 if ((*s_etat_processus).langue == 'F')
  921:                 {
  922:                     chaine = "+++Erreur : Descripteur hors contexte";
  923:                 }
  924:                 else
  925:                 {
  926:                     chaine = "+++Error : Context mismatch";
  927:                 }
  928: 
  929:                 break;
  930:             }
  931: 
  932:             case d_ex_socket_en_ecoute :
  933:             {
  934:                 if ((*s_etat_processus).langue == 'F')
  935:                 {
  936:                     chaine = "+++Erreur : Connexion refusée sur une socket"
  937:                             " en attente";
  938:                 }
  939:                 else
  940:                 {
  941:                     chaine = "+++Error : Connexion refused on a"
  942:                             " waiting socket";
  943:                 }
  944: 
  945:                 break;
  946:             }
  947: 
  948:             case d_ex_interruption_invalide :
  949:             {
  950:                 if ((*s_etat_processus).langue == 'F')
  951:                 {
  952:                     chaine = "+++Erreur : Interruption invalide";
  953:                 }
  954:                 else
  955:                 {
  956:                     chaine = "+++Error : Unavailable interrupt";
  957:                 }
  958: 
  959:                 break;
  960:             }
  961: 
  962:             case d_ex_erreur_transcodage :
  963:             {
  964:                 if ((*s_etat_processus).langue == 'F')
  965:                 {
  966:                     chaine = "+++Erreur : Erreur de transcodage";
  967:                 }
  968:                 else
  969:                 {
  970:                     chaine = "+++Error : Transcodage error";
  971:                 }
  972: 
  973:                 break;
  974:             }
  975: 
  976:             case d_ex_contexte :
  977:             {
  978:                 if ((*s_etat_processus).langue == 'F')
  979:                 {
  980:                     chaine = "+++Erreur : Aucun contexte sauvegardé";
  981:                 }
  982:                 else
  983:                 {
  984:                     chaine = "+++Error : No stacked context";
  985:                 }
  986: 
  987:                 break;
  988:             }
  989: 
  990:             case d_ex_absence_processus_pere :
  991:             {
  992:                 if ((*s_etat_processus).langue == 'F')
  993:                 {
  994:                     chaine = "+++Erreur : Absence de processus père";
  995:                 }
  996:                 else
  997:                 {
  998:                     chaine = "+++Error : No parent process";
  999:                 }
 1000: 
 1001:                 break;
 1002:             }
 1003: 
 1004:             case d_ex_creation_variable :
 1005:             {
 1006:                 if ((*s_etat_processus).langue == 'F')
 1007:                 {
 1008:                     chaine = "+++Erreur : Création de variable impossible";
 1009:                 }
 1010:                 else
 1011:                 {
 1012:                     chaine = "+++Error : Variable initialization failed";
 1013:                 }
 1014: 
 1015:                 break;
 1016:             }
 1017: 
 1018:             case d_ex_fusible :
 1019:             {
 1020:                 if ((*s_etat_processus).langue == 'F')
 1021:                 {
 1022:                     chaine = "+++Erreur : Fusible préexistant";
 1023:                 }
 1024:                 else
 1025:                 {
 1026:                     chaine = "+++Error : Fuse error";
 1027:                 }
 1028: 
 1029:                 break;
 1030:             }
 1031: 
 1032:             case d_ex_iswi_hors_interruption :
 1033:             {
 1034:                 if ((*s_etat_processus).langue == 'F')
 1035:                 {
 1036:                     chaine = "+++Erreur : Aucune interruption en cours";
 1037:                 }
 1038:                 else
 1039:                 {
 1040:                     chaine = "+++Error : No current interrupt";
 1041:                 }
 1042: 
 1043:                 break;
 1044:             }
 1045: 
 1046:             case d_ex_daemon :
 1047:             {
 1048:                 if ((*s_etat_processus).langue == 'F')
 1049:                 {
 1050:                     chaine = "+++Erreur : Conversion en daemon impossible";
 1051:                 }
 1052:                 else
 1053:                 {
 1054:                     chaine = "+++Error : Unable to convert to daemon";
 1055:                 }
 1056: 
 1057:                 break;
 1058:             }
 1059: 
 1060:             case d_ex_mutex :
 1061:             {
 1062:                 if ((*s_etat_processus).langue == 'F')
 1063:                 {
 1064:                     chaine = "+++Erreur : Mutex non initialisé";
 1065:                 }
 1066:                 else
 1067:                 {
 1068:                     chaine = "+++Error : Uninitialized mutex";
 1069:                 }
 1070: 
 1071:                 break;
 1072:             }
 1073: 
 1074:             case d_ex_semaphore :
 1075:             {
 1076:                 if ((*s_etat_processus).langue == 'F')
 1077:                 {
 1078:                     chaine = "+++Erreur : Erreur d'accès à un sémaphore";
 1079:                 }
 1080:                 else
 1081:                 {
 1082:                     chaine = "+++Error : Semaphore access error";
 1083:                 }
 1084: 
 1085:                 break;
 1086:             }
 1087: 
 1088:             case d_ex_variable_statique_partagee :
 1089:             {
 1090:                 if ((*s_etat_processus).langue == 'F')
 1091:                 {
 1092:                     chaine = "+++Erreur : Variable statique partagée";
 1093:                 }
 1094:                 else
 1095:                 {
 1096:                     chaine = "+++Error : Static shared variable";
 1097:                 }
 1098: 
 1099:                 break;
 1100:             }
 1101: 
 1102:             case d_ex_variable_partagee :
 1103:             {
 1104:                 if ((*s_etat_processus).langue == 'F')
 1105:                 {
 1106:                     chaine = "+++Erreur : Variable partagée";
 1107:                 }
 1108:                 else
 1109:                 {
 1110:                     chaine = "+++Error : Shared variable";
 1111:                 }
 1112: 
 1113:                 break;
 1114:             }
 1115: 
 1116:             case d_ex_graphique_memorise :
 1117:             {
 1118:                 if ((*s_etat_processus).langue == 'F')
 1119:                 {
 1120:                     chaine = "+++Erreur : Données mémorisées non affichées";
 1121:                 }
 1122:                 else
 1123:                 {
 1124:                     chaine = "+++Error : Non plotted buffered data";
 1125:                 }
 1126: 
 1127:                 break;
 1128:             }
 1129: 
 1130:             case d_ex_absence_graphique_courant :
 1131:             {
 1132:                 if ((*s_etat_processus).langue == 'F')
 1133:                 {
 1134:                     chaine = "+++Erreur : Aucun graphique en cours";
 1135:                 }
 1136:                 else
 1137:                 {
 1138:                     chaine = "+++Error : No current graphic";
 1139:                 }
 1140: 
 1141:                 break;
 1142:             }
 1143: 
 1144:             case d_ex_stop :
 1145:             {
 1146:                 if ((*s_etat_processus).langue == 'F')
 1147:                 {
 1148:                     chaine = "+++Erreur : Masque du signal STOP";
 1149:                 }
 1150:                 else
 1151:                 {
 1152:                     chaine = "+++Error : STOP signal mask";
 1153:                 }
 1154: 
 1155:                 break;
 1156:             }
 1157: 
 1158:             case d_ex_matrice_non_diagonale :
 1159:             {
 1160:                 if ((*s_etat_processus).langue == 'F')
 1161:                 {
 1162:                     chaine = "+++Erreur : Matrice non diagonale";
 1163:                 }
 1164:                 else
 1165:                 {
 1166:                     chaine = "+++Error : Non diagonal matrix";
 1167:                 }
 1168: 
 1169:                 break;
 1170:             }
 1171: 
 1172:             case d_ex_locales :
 1173:             {
 1174:                 if ((*s_etat_processus).langue == 'F')
 1175:                 {
 1176:                     chaine = "+++Erreur : Variable de localisation "
 1177:                             "indisponible";
 1178:                 }
 1179:                 else
 1180:                 {
 1181:                     chaine = "+++Error : Unavailable locale";
 1182:                 }
 1183: 
 1184:                 break;
 1185:             }
 1186: 
 1187:             case d_ex_representation :
 1188:             {
 1189:                 if ((*s_etat_processus).langue == 'F')
 1190:                 {
 1191:                     chaine = "+++Erreur : Erreur de représentation";
 1192:                 }
 1193:                 else
 1194:                 {
 1195:                     chaine = "+++Error : Mapping error";
 1196:                 }
 1197: 
 1198:                 break;
 1199:             }
 1200: 
 1201:             case d_ex_erreur_profilage :
 1202:             {
 1203:                 if ((*s_etat_processus).langue == 'F')
 1204:                 {
 1205:                     chaine = "+++Erreur : Pile de profilage vide";
 1206:                 }
 1207:                 else
 1208:                 {
 1209:                     chaine = "+++Error : Empty profiles stack";
 1210:                 }
 1211: 
 1212:                 break;
 1213:             }
 1214: 
 1215:             case d_ex_enregistrement_inexistant :
 1216:             {
 1217:                 if ((*s_etat_processus).langue == 'F')
 1218:                 {
 1219:                     chaine = "+++Erreur : Enregistrement inexistant";
 1220:                 }
 1221:                 else
 1222:                 {
 1223:                     chaine = "+++Error : Record not found";
 1224:                 }
 1225: 
 1226:                 break;
 1227:             }
 1228: 
 1229:             case d_ex_clef_inexistante :
 1230:             {
 1231:                 if ((*s_etat_processus).langue == 'F')
 1232:                 {
 1233:                     chaine = "+++Erreur : Clef inexistante";
 1234:                 }
 1235:                 else
 1236:                 {
 1237:                     chaine = "+++Error : Key not found";
 1238:                 }
 1239: 
 1240:                 break;
 1241:             }
 1242: 
 1243:             case d_ex_nom_implicite :
 1244:             {
 1245:                 if ((*s_etat_processus).langue == 'F')
 1246:                 {
 1247:                     chaine = "+++Erreur : Nom implicite indéfini";
 1248:                 }
 1249:                 else
 1250:                 {
 1251:                     chaine = "+++Error : Undefined implicit name";
 1252:                 }
 1253: 
 1254:                 break;
 1255:             }
 1256: 
 1257:             case d_ex_version_bibliotheque :
 1258:             {
 1259:                 if ((*s_etat_processus).langue == 'F')
 1260:                 {
 1261:                     chaine = "+++Erreur : Version de bibliothèque incompatible";
 1262:                 }
 1263:                 else
 1264:                 {
 1265:                     chaine = "+++Error : Library version mismatch";
 1266:                 }
 1267: 
 1268:                 break;
 1269:             }
 1270: 
 1271:             case d_ex_creation_variable_globale :
 1272:             {
 1273:                 if ((*s_etat_processus).langue == 'F')
 1274:                 {
 1275:                     chaine = "+++Erreur : Création de variable globale "
 1276:                             "impossible";
 1277:                 }
 1278:                 else
 1279:                 {
 1280:                     chaine = "+Erreur : Cannot create global variable";
 1281:                 }
 1282: 
 1283:                 break;
 1284:             }
 1285: 
 1286:             case -1 : // Fonction externe
 1287:             {
 1288:                 if ((*s_etat_processus).langue == 'F')
 1289:                 {
 1290:                     chaine = "+++Erreur : Fonction dynamique %s (ligne %lld)";
 1291:                     argument = (*s_etat_processus).instruction_derniere_erreur;
 1292:                     erreur_fonction_externe = d_vrai;
 1293:                 }
 1294:                 else
 1295:                 {
 1296:                     chaine = "+++Error : %s dynamic function (line %lld)";
 1297:                     argument = (*s_etat_processus).instruction_derniere_erreur;
 1298:                     erreur_fonction_externe = d_vrai;
 1299:                 }
 1300: 
 1301:                 break;
 1302:             }
 1303: 
 1304:             default :
 1305:             {
 1306:                 if ((*s_etat_processus).langue == 'F')
 1307:                 {
 1308:                     chaine = "+++Erreur : Erreur d'exécution";
 1309:                 }
 1310:                 else
 1311:                 {
 1312:                     chaine = "+++Error : Execution error";
 1313:                 }
 1314: 
 1315:                 break;
 1316:             }
 1317:         }
 1318:     }
 1319:     else if ((*s_etat_processus).erreur_systeme != d_es)
 1320:     {
 1321:         (*s_etat_processus).derniere_erreur_systeme =
 1322:                 (*s_etat_processus).erreur_systeme;
 1323: 
 1324: /*
 1325: --------------------------------------------------------------------------------
 1326:   Erreurs dues au système et au séquenceur
 1327: --------------------------------------------------------------------------------
 1328: */
 1329: 
 1330:         switch((*s_etat_processus).erreur_systeme)
 1331:         {
 1332:             case d_es_allocation_memoire :
 1333:             {
 1334:                 if ((*s_etat_processus).langue == 'F')
 1335:                 {
 1336:                     chaine = "+++Système : Erreur d'allocation mémoire";
 1337:                 }
 1338:                 else
 1339:                 {
 1340:                     chaine = "+++System : Memory allocation error";
 1341:                 }
 1342: 
 1343:                 break;
 1344:             }
 1345: 
 1346:             case d_es_variable_introuvable :
 1347:             {
 1348:                 if ((*s_etat_processus).langue == 'F')
 1349:                 {
 1350:                     chaine = "+++Système : Variable non définie";
 1351:                 }
 1352:                 else
 1353:                 {
 1354:                     chaine = "+++System : Undefined variable";
 1355:                 }
 1356: 
 1357:                 break;
 1358:             }
 1359: 
 1360:             case d_es_pile_vide :
 1361:             {
 1362:                 if ((*s_etat_processus).langue == 'F')
 1363:                 {
 1364:                     chaine = "+++Système : Pile système vide";
 1365:                 }
 1366:                 else
 1367:                 {
 1368:                     chaine = "+++System : Empty system stack";
 1369:                 }
 1370: 
 1371:                 break;
 1372:             }
 1373: 
 1374:             case d_es_pile_operationnelle_vide :
 1375:             {
 1376:                 if ((*s_etat_processus).langue == 'F')
 1377:                 {
 1378:                     chaine = "+++Système : Pile vide";
 1379:                 }
 1380:                 else
 1381:                 {
 1382:                     chaine = "+++System : Empty stack";
 1383:                 }
 1384: 
 1385:                 break;
 1386:             }
 1387: 
 1388:             case d_es_end_incoherent :
 1389:             {
 1390:                 if ((*s_etat_processus).langue == 'F')
 1391:                 {
 1392:                     chaine = "+++Système : Instruction END incohérente";
 1393:                 }
 1394:                 else
 1395:                 {
 1396:                     chaine = "+++Systeme : Incoherent END instruction";
 1397:                 }
 1398: 
 1399:                 break;
 1400:             }
 1401: 
 1402:             case d_es_peripherique_stdin :
 1403:             {
 1404:                 if ((*s_etat_processus).langue == 'F')
 1405:                 {
 1406:                     chaine = "+++Système : Erreur de lecture sur stdin";
 1407:                 }
 1408:                 else
 1409:                 {
 1410:                     chaine = "+++System : Read error on stdin";
 1411:                 }
 1412: 
 1413:                 break;
 1414:             }
 1415: 
 1416:             case d_es_erreur_fichier :
 1417:             {
 1418:                 if ((*s_etat_processus).langue == 'F')
 1419:                 {
 1420:                     chaine = "+++Système : Erreur d'entrée/sortie sur un"
 1421:                             " fichier";
 1422:                 }
 1423:                 else
 1424:                 {
 1425:                     chaine = "+++System : File input/output error";
 1426:                 }
 1427: 
 1428:                 break;
 1429:             }
 1430: 
 1431:             case d_es_execution_bibliotheque :
 1432:             {
 1433:                 if ((*s_etat_processus).langue == 'F')
 1434:                 {
 1435:                     chaine = "+++Système : Problème lors de l'exécution "
 1436:                             "d'une fonction externe";
 1437:                 }
 1438:                 else
 1439:                 {
 1440:                     chaine = "+++System : Extern function execution error";
 1441:                 }
 1442: 
 1443:                 break;
 1444:             }
 1445: 
 1446:             case d_es_signal :
 1447:             {
 1448:                 if ((*s_etat_processus).langue == 'F')
 1449:                 {
 1450:                     chaine = "+++Système : Problème de gestion de signaux "
 1451:                             "POSIX";
 1452:                 }
 1453:                 else
 1454:                 {
 1455:                     chaine = "+++System : POSIX signal error";
 1456:                 }
 1457: 
 1458:                 break;
 1459:             }
 1460: 
 1461:         case d_es_processus :
 1462:         {
 1463:                 if ((*s_etat_processus).langue == 'F')
 1464:                 {
 1465:                     chaine = "+++Système : Erreur dans la gestion des"
 1466:                             " processus";
 1467:                 }
 1468:                 else
 1469:                 {
 1470:                     chaine = "+++System : Process management error";
 1471:                 }
 1472: 
 1473:                 break;
 1474:             }
 1475: 
 1476:             case d_es_nombre_max_descripteurs :
 1477:             {
 1478:                 if ((*s_etat_processus).langue == 'F')
 1479:                 {
 1480:                     chaine = "+++Système : Nombre maximal de descripteurs"
 1481:                             " de fichiers atteint";
 1482:                 }
 1483:                 else
 1484:                 {
 1485:                     chaine = "+++System : Too much file descriptors";
 1486:                 }
 1487: 
 1488:                 break;
 1489:             }
 1490: 
 1491:             case d_es_interruption_invalide :
 1492:             {
 1493:                 if ((*s_etat_processus).langue == 'F')
 1494:                 {
 1495:                     chaine = "+++Système : Interruption invalide";
 1496:                 }
 1497:                 else
 1498:                 {
 1499:                     chaine = "+++System : Unavailable interrupt";
 1500:                 }
 1501: 
 1502:                 break;
 1503:             }
 1504: 
 1505:             case d_es_contexte :
 1506:             {
 1507:                 if ((*s_etat_processus).langue == 'F')
 1508:                 {
 1509:                     chaine = "+++Système : Erreur dans la gestion des"
 1510:                             " contextes";
 1511:                 }
 1512:                 else
 1513:                 {
 1514:                     chaine = "+++System : Context management error";
 1515:                 }
 1516: 
 1517:                 break;
 1518:             }
 1519: 
 1520:             case d_es_somme_controle :
 1521:             {
 1522:                 if ((*s_etat_processus).langue == 'F')
 1523:                 {
 1524:                     chaine = "+++Système : Somme de contrôle invalide";
 1525:                 }
 1526:                 else
 1527:                 {
 1528:                     chaine = "+++System : Invalid hash sum";
 1529:                 }
 1530: 
 1531:                 break;
 1532:             }
 1533: 
 1534:             case d_es_semaphore :
 1535:             {
 1536:                 if ((*s_etat_processus).langue == 'F')
 1537:                 {
 1538:                     chaine = "+++Système : Erreur d'accès à un sémaphore";
 1539:                 }
 1540:                 else
 1541:                 {
 1542:                     chaine = "+++System : Semaphore access error";
 1543:                 }
 1544: 
 1545:                 break;
 1546:             }
 1547: 
 1548:             case -1 : // Fonction externe
 1549:             {
 1550:                 if ((*s_etat_processus).langue == 'F')
 1551:                 {
 1552:                     chaine = "+++Système : Fonction dynamique %s (ligne %lld)";
 1553:                     argument = (*s_etat_processus).instruction_derniere_erreur;
 1554:                     erreur_fonction_externe = d_vrai;
 1555:                 }
 1556:                 else
 1557:                 {
 1558:                     chaine = "+++System : %s dynamic function (line %lld)";
 1559:                     argument = (*s_etat_processus).instruction_derniere_erreur;
 1560:                     erreur_fonction_externe = d_vrai;
 1561:                 }
 1562: 
 1563:                 break;
 1564:             }
 1565: 
 1566:             default :
 1567:             {
 1568:                 if ((*s_etat_processus).langue == 'F')
 1569:                 {
 1570:                     chaine = "+++Système : Erreur interne";
 1571:                 }
 1572:                 else
 1573:                 {
 1574:                     chaine = "+++System : Internal error";
 1575:                 }
 1576: 
 1577:                 break;
 1578:             }
 1579:         }
 1580:     }
 1581:     else if ((*s_etat_processus).exception != d_ep)
 1582:     {
 1583:         (*s_etat_processus).derniere_exception =
 1584:                 (*s_etat_processus).exception;
 1585: 
 1586: /*
 1587: --------------------------------------------------------------------------------
 1588:   Exceptions mathématiques
 1589: --------------------------------------------------------------------------------
 1590: */
 1591: 
 1592:         switch((*s_etat_processus).exception)
 1593:         {
 1594:             case d_ep_division_par_zero :
 1595:             {
 1596:                 if ((*s_etat_processus).langue == 'F')
 1597:                 {
 1598:                     chaine = "+++Exception : Division par zéro";
 1599:                 }
 1600:                 else
 1601:                 {
 1602:                     chaine = "+++Exception : Division by zero";
 1603:                 }
 1604: 
 1605:                 break;
 1606:             }
 1607: 
 1608:             case d_ep_matrice_non_inversible :
 1609:             {
 1610:                 if ((*s_etat_processus).langue == 'F')
 1611:                 {
 1612:                     chaine = "+++Exception : Matrice non inversible";
 1613:                 }
 1614:                 else
 1615:                 {
 1616:                     chaine = "+++Exception : Non inversible matrix";
 1617:                 }
 1618: 
 1619:                 break;
 1620:             }
 1621: 
 1622:             case d_ep_resultat_indefini :
 1623:             {
 1624:                 if ((*s_etat_processus).langue == 'F')
 1625:                 {
 1626:                     chaine = "+++Exception : Résultat indéfini";
 1627:                 }
 1628:                 else
 1629:                 {
 1630:                     chaine = "+++Exception : Undefined result";
 1631:                 }
 1632: 
 1633:                 break;
 1634:             }
 1635: 
 1636:             case d_ep_underflow :
 1637:             {
 1638:                 if ((*s_etat_processus).langue == 'F')
 1639:                 {
 1640:                     chaine = "+++Exception : Dépassement de capacité"
 1641:                             " (underflow)";
 1642:                 }
 1643:                 else
 1644:                 {
 1645:                     chaine = "+++Exception : Underflow exception";
 1646:                 }
 1647: 
 1648:                 break;
 1649:             }
 1650: 
 1651:             case d_ep_overflow :
 1652:             {
 1653:                 if ((*s_etat_processus).langue == 'F')
 1654:                 {
 1655:                     chaine = "+++Exception : Dépassement de capacité"
 1656:                             " (overflow)";
 1657:                 }
 1658:                 else
 1659:                 {
 1660:                     chaine = "+++Exception : Overflow exception";
 1661:                 }
 1662: 
 1663:                 break;
 1664:             }
 1665: 
 1666:             case d_ep_domaine_definition :
 1667:             {
 1668:                 if ((*s_etat_processus).langue == 'F')
 1669:                 {
 1670:                     chaine = "+++Exception : Domaine de définition";
 1671:                 }
 1672:                 else
 1673:                 {
 1674:                     chaine = "+++Exception : Domain exception";
 1675:                 }
 1676: 
 1677:                 break;
 1678:             }
 1679: 
 1680:             case d_ep_perte_precision :
 1681:             {
 1682:                 if ((*s_etat_processus).langue == 'F')
 1683:                 {
 1684:                     chaine = "+++Exception : Perte de précision";
 1685:                 }
 1686:                 else
 1687:                 {
 1688:                     chaine = "+++Exception : Loss of precision";
 1689:                 }
 1690: 
 1691:                 break;
 1692:             }
 1693: 
 1694:             case d_ep_decomposition_QR :
 1695:             {
 1696:                 if ((*s_etat_processus).langue == 'F')
 1697:                 {
 1698:                     chaine = "+++Exception : Décomposition QR impossible";
 1699:                 }
 1700:                 else
 1701:                 {
 1702:                     chaine = "+++Exception : QR decomposition failed";
 1703:                 }
 1704: 
 1705:                 break;
 1706:             }
 1707: 
 1708:             case d_ep_matrice_non_definie_positive :
 1709:             {
 1710:                 if ((*s_etat_processus).langue == 'F')
 1711:                 {
 1712:                     chaine = "+++Exception : Matrice non définie positive";
 1713:                 }
 1714:                 else
 1715:                 {
 1716:                     chaine = "+++Exception : Non positive defined matrix";
 1717:                 }
 1718: 
 1719:                 break;
 1720:             }
 1721: 
 1722:             case d_ep_decomposition_QZ :
 1723:             {
 1724:                 if ((*s_etat_processus).langue == 'F')
 1725:                 {
 1726:                     chaine = "+++Exception : Décomposition QZ impossible";
 1727:                 }
 1728:                 else
 1729:                 {
 1730:                     chaine = "+++Exception : QZ decomposition failed";
 1731:                 }
 1732: 
 1733:                 break;
 1734:             }
 1735: 
 1736:             case d_ep_decomposition_SVD :
 1737:             {
 1738:                 if ((*s_etat_processus).langue == 'F')
 1739:                 {
 1740:                     chaine = "+++Exception : Décomposition SVD impossible";
 1741:                 }
 1742:                 else
 1743:                 {
 1744:                     chaine = "+++Exception : SVD decomposition failed";
 1745:                 }
 1746: 
 1747:                 break;
 1748:             }
 1749: 
 1750:             default :
 1751:             {
 1752:                 if ((*s_etat_processus).langue == 'F')
 1753:                 {
 1754:                     chaine = "+++Exception : Exception mathématique";
 1755:                 }
 1756:                 else
 1757:                 {
 1758:                     chaine = "+++Exception : Mathematical exception";
 1759:                 }
 1760: 
 1761:                 break;
 1762:             }
 1763:         }
 1764:     }
 1765:     else if ((*s_etat_processus).erreur_compilation != d_ec)
 1766:     {
 1767: 
 1768: /*
 1769: --------------------------------------------------------------------------------
 1770:   Erreurs de compilation
 1771: --------------------------------------------------------------------------------
 1772: */
 1773: 
 1774:         switch((*s_etat_processus).erreur_compilation)
 1775:         {
 1776:             case d_ec_niveau_definition_negatif :
 1777:             {
 1778:                 if ((*s_etat_processus).langue == 'F')
 1779:                 {
 1780:                     chaine = "+++Fatal : Niveau de définition négatif";
 1781:                 }
 1782:                 else
 1783:                 {
 1784:                     chaine = "+++Fatal : Negative definition level";
 1785:                 }
 1786: 
 1787:                 break;
 1788:             }
 1789: 
 1790:             case d_ec_nom_definition_invalide :
 1791:             {
 1792:                 if ((*s_etat_processus).langue == 'F')
 1793:                 {
 1794:                     chaine = "+++Fatal : Nom de définition invalide";
 1795:                 }
 1796:                 else
 1797:                 {
 1798:                     chaine = "+++Fatal : Invalid definition name";
 1799:                 }
 1800: 
 1801:                 break;
 1802:             }
 1803: 
 1804:             case d_ec_erreur_boucle_definie :
 1805:             {
 1806:                 if ((*s_etat_processus).langue == 'F')
 1807:                 {
 1808:                     chaine = "+++Fatal : Définition illégale "
 1809:                             "d'une boucle définie";
 1810:                 }
 1811:                 else
 1812:                 {
 1813:                     chaine = "+++Fatal : Illegal use of a defined loop";
 1814:                 }
 1815: 
 1816:                 break;
 1817:             }
 1818: 
 1819:             case d_ec_erreur_instruction_end :
 1820:             {
 1821:                 if ((*s_etat_processus).langue == 'F')
 1822:                 {
 1823:                     chaine = "+++Fatal : Erreur dans une structure terminée "
 1824:                             "par l'instruction END";
 1825:                 }
 1826:                 else
 1827:                 {
 1828:                     chaine = "+++Fatal : Error in an END-closed structure";
 1829:                 }
 1830: 
 1831:                 break;
 1832:             }
 1833: 
 1834:             case d_ec_erreur_instruction_until :
 1835:             {
 1836:                 if ((*s_etat_processus).langue == 'F')
 1837:                 {
 1838:                     chaine = "+++Fatal : Erreur dans une boucle DO/UNTIL/END";
 1839:                 }
 1840:                 else
 1841:                 {
 1842:                     chaine = "+++Fatal : Error in a DO/UNTIL/END loop";
 1843:                 }
 1844: 
 1845:                 break;
 1846:             }
 1847: 
 1848:             case d_ec_source_incoherent :
 1849:             {
 1850:                 if ((*s_etat_processus).langue == 'F')
 1851:                 {
 1852:                     chaine = "+++Fatal : Définitions incohérentes";
 1853:                 }
 1854:                 else
 1855:                 {
 1856:                     chaine = "+++Fatal : Incoherent definitions";
 1857:                 }
 1858: 
 1859:                 break;
 1860:             }
 1861: 
 1862:             case d_ec_erreur_instruction_while :
 1863:             {
 1864:                 if ((*s_etat_processus).langue == 'F')
 1865:                 {
 1866:                     chaine = "+++Fatal : Erreur dans une boucle WHILE/REPEAT/"
 1867:                             "END";
 1868:                 }
 1869:                 else
 1870:                 {
 1871:                     chaine = "+++Fatal : Error in a WHILE/REPEAT/END loop";
 1872:                 }
 1873: 
 1874:                 break;
 1875:             }
 1876: 
 1877:             case d_ec_erreur_instruction_select :
 1878:             {
 1879:                 if ((*s_etat_processus).langue == 'F')
 1880:                 {
 1881:                     chaine = "+++Fatal : Erreur dans une structure SELECT"
 1882:                             "/DEFAULT/END";
 1883:                 }
 1884:                 else
 1885:                 {
 1886:                     chaine = "+++Fatal : Error in a SELECT/DEFAULT/END "
 1887:                             "structure";
 1888:                 }
 1889: 
 1890:                 break;
 1891:             }
 1892: 
 1893:             case d_ec_erreur_instruction_case :
 1894:             {
 1895:                 if ((*s_etat_processus).langue == 'F')
 1896:                 {
 1897:                     chaine = "+++Fatal : Erreur dans une structure CASE"
 1898:                             "/THEN/END";
 1899:                 }
 1900:                 else
 1901:                 {
 1902:                     chaine = "+++Fatal : Error in a CASE/THEN/END "
 1903:                             "structure";
 1904:                 }
 1905: 
 1906:                 break;
 1907:             }
 1908: 
 1909:             case d_ec_erreur_instruction_then :
 1910:             {
 1911:                 if ((*s_etat_processus).langue == 'F')
 1912:                 {
 1913:                     chaine = "+++Fatal : Erreur dans une structure IF, "
 1914:                             "IFERR ou CASE/THEN/END";
 1915:                 }
 1916:                 else
 1917:                 {
 1918:                     chaine = "+++Fatal : Error in a IF, IFERR or "
 1919:                             "CASE/THEN/END structure";
 1920:                 }
 1921: 
 1922:                 break;
 1923:             }
 1924: 
 1925:             case d_ec_erreur_instruction_else :
 1926:             {
 1927:                 if ((*s_etat_processus).langue == 'F')
 1928:                 {
 1929:                     chaine = "+++Fatal : Erreur dans une structure ELSE";
 1930:                 }
 1931:                 else
 1932:                 {
 1933:                     chaine = "+++Fatal : Error in a ELSE structure";
 1934:                 }
 1935: 
 1936:                 break;
 1937:             }
 1938: 
 1939:             case d_ec_erreur_instruction_elseif :
 1940:             {
 1941:                 if ((*s_etat_processus).langue == 'F')
 1942:                 {
 1943:                     chaine = "+++Fatal : Erreur dans une structure ELSEIF";
 1944:                 }
 1945:                 else
 1946:                 {
 1947:                     chaine = "+++Fatal : Error in a ELSEIF structure";
 1948:                 }
 1949: 
 1950:                 break;
 1951:             }
 1952: 
 1953:             default :
 1954:             {
 1955:                 if ((*s_etat_processus).langue == 'F')
 1956:                 {
 1957:                     chaine = "+++Fatal : Erreur de compilation";
 1958:                 }
 1959:                 else
 1960:                 {
 1961:                     chaine = "+++Fatal : compilation error";
 1962:                 }
 1963: 
 1964:                 break;
 1965:             }
 1966:         }
 1967:     }
 1968:     else
 1969:     {
 1970:         if ((*s_etat_processus).langue == 'F')
 1971:         {
 1972:             chaine = "";
 1973:         }
 1974:         else
 1975:         {
 1976:             chaine = "";
 1977:         }
 1978:     }
 1979: 
 1980:     if (argument == NULL)
 1981:     {
 1982:         if ((message = malloc((strlen(chaine) + 1) * sizeof(unsigned char)))
 1983:                 == NULL)
 1984:         {
 1985:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1986:             return NULL;
 1987:         }
 1988: 
 1989:         strcpy(message, chaine);
 1990:     }
 1991:     else
 1992:     {
 1993:         if (erreur_fonction_externe == d_faux)
 1994:         {
 1995:             if ((message = malloc((strlen(chaine) + strlen(argument) - 1) *
 1996:                     sizeof(unsigned char))) == NULL)
 1997:             {
 1998:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1999:                 return NULL;
 2000:             }
 2001: 
 2002:             sprintf(message, chaine, argument);
 2003:         }
 2004:         else
 2005:         {
 2006:             if ((message = malloc((strlen(chaine) + strlen(argument) + 64
 2007:                     - 1) * sizeof(unsigned char))) == NULL)
 2008:             {
 2009:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 2010:                 return NULL;
 2011:             }
 2012: 
 2013:             sprintf(message, chaine, argument,
 2014:                     (*s_etat_processus).derniere_erreur_fonction_externe);
 2015:         }
 2016:     }
 2017: 
 2018:     return(message);
 2019: }
 2020: 
 2021: // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>