"Fossies" - the Fresh Open Source Software Archive

Member "erltools/pub/cplusplu/test/test1.c_l" (25 Jul 1999, 50944 Bytes) of package /linux/misc/old/erltools-4.0.1.tar.gz:


As a special service "Fossies" has tried to format the requested text file into HTML format (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file.

    1 SortKeyWord ( defaultValue )
    2 int defaultValue ;
    3 {
    4     register int    Value ;
    5     
    6     Value = strcmp(lexEl.string, "enum");
    7     if ( Value > 0 ) {
    8         Value = strcmp(lexEl.string, "pascal");
    9         if ( Value > 0 ) {
   10             Value = strcmp(lexEl.string, "struct");
   11             if ( Value > 0 ) {
   12                 Value = strcmp(lexEl.string, "union");
   13                 if ( Value > 0 ) {
   14                     Value = strcmp(lexEl.string, "while");
   15                     if ( Value > 0 ) {
   16                         return (defaultValue);
   17                     } else if ( Value < 0 ) {
   18                         if ( !strcmp(lexEl.string, "unsigned") ) {
   19                             return (UNSIGNED_c);
   20                         }
   21                     } else 
   22                         return (WHILE_c);
   23                 } else if ( Value < 0 ) {
   24                     Value = strcmp(lexEl.string, "typedef");
   25                     if ( Value > 0 ) {
   26                         return (defaultValue);
   27                     } else if ( Value < 0 ) {
   28                         if ( !strcmp(lexEl.string, "switch") ) {
   29                             return (SWITCH_c);
   30                         }
   31                     } else 
   32                         return (TYPEDEF_c);
   33                 } else 
   34                     return (UNION_c);
   35             } else if ( Value < 0 ) {
   36                 Value = strcmp(lexEl.string, "short");
   37                 if ( Value > 0 ) {
   38                     Value = strcmp(lexEl.string, "static");
   39                     if ( Value > 0 ) {
   40                         return (defaultValue);
   41                     } else if ( Value < 0 ) {
   42                         if ( !strcmp(lexEl.string, "signed") ) {
   43                             return (SIGNED_c);
   44                         }
   45                     } else 
   46                         return (STATIC_c);
   47                 } else if ( Value < 0 ) {
   48                     Value = strcmp(lexEl.string, "return");
   49                     if ( Value > 0 ) {
   50                         return (defaultValue);
   51                     } else if ( Value < 0 ) {
   52                         if ( !strcmp(lexEl.string, "register") ) {
   53                             return (REGISTER_c);
   54                         }
   55                     } else 
   56                         return (RETURN_c);
   57                 } else 
   58                     return (SHORT_c);
   59             } else 
   60                 return (STRUCT_c);
   61         } else if ( Value < 0 ) {
   62             Value = strcmp(lexEl.string, "huge");
   63             if ( Value > 0 ) {
   64                 Value = strcmp(lexEl.string, "int");
   65                 if ( Value > 0 ) {
   66                     Value = strcmp(lexEl.string, "near");
   67                     if ( Value > 0 ) {
   68                         return (defaultValue);
   69                     } else if ( Value < 0 ) {
   70                         if ( !strcmp(lexEl.string, "long") ) {
   71                             return (LONG_c);
   72                         }
   73                     } else 
   74                         return (NEAR_c);
   75                 } else if ( Value < 0 ) {
   76                     Value = strcmp(lexEl.string, "include");
   77                     if ( Value > 0 ) {
   78                         return (defaultValue);
   79                     } else if ( Value < 0 ) {
   80                         if ( !strcmp(lexEl.string, "if") ) {
   81                             return (IF_c);
   82                         }
   83                     } else 
   84                         return (INCLUDE_c);
   85                 } else 
   86                     return (INT_c);
   87             } else if ( Value < 0 ) {
   88                 Value = strcmp(lexEl.string, "for");
   89                 if ( Value > 0 ) {
   90                     Value = strcmp(lexEl.string, "goto");
   91                     if ( Value > 0 ) {
   92                         return (defaultValue);
   93                     } else if ( Value < 0 ) {
   94                         if ( !strcmp(lexEl.string, "fortran") ) {
   95                             return (FORTRAN_c);
   96                         }
   97                     } else 
   98                         return (GOTO_c);
   99                 } else if ( Value < 0 ) {
  100                     Value = strcmp(lexEl.string, "far");
  101                     if ( Value > 0 ) {
  102                         if ( !strcmp(lexEl.string, "float") ) {
  103                             return (FLOAT_c);
  104                         }
  105                     } else if ( Value < 0 ) {
  106                         if ( !strcmp(lexEl.string, "extern") ) {
  107                             return (EXTERN_c);
  108                         }
  109                     } else 
  110                         return (FAR_c);
  111                 } else 
  112                     return (FOR_c);
  113             } else 
  114                 return (HUGE_c);
  115         } else 
  116             return (PASCAL_c);
  117     } else if ( Value < 0 ) {
  118         Value = strcmp(lexEl.string, "_FAR_");
  119         if ( Value > 0 ) {
  120             Value = strcmp(lexEl.string, "continue");
  121             if ( Value > 0 ) {
  122                 Value = strcmp(lexEl.string, "do");
  123                 if ( Value > 0 ) {
  124                     Value = strcmp(lexEl.string, "else");
  125                     if ( Value > 0 ) {
  126                         return (defaultValue);
  127                     } else if ( Value < 0 ) {
  128                         if ( !strcmp(lexEl.string, "double") ) {
  129                             return (DOUBLE_c);
  130                         }
  131                     } else 
  132                         return (ELSE_c);
  133                 } else if ( Value < 0 ) {
  134                     Value = strcmp(lexEl.string, "define");
  135                     if ( Value > 0 ) {
  136                         return (defaultValue);
  137                     } else if ( Value < 0 ) {
  138                         if ( !strcmp(lexEl.string, "default") ) {
  139                             return (DEFAULT_c);
  140                         }
  141                     } else 
  142                         return (DEFINE_c);
  143                 } else 
  144                     return (DO_c);
  145             } else if ( Value < 0 ) {
  146                 Value = strcmp(lexEl.string, "case");
  147                 if ( Value > 0 ) {
  148                     Value = strcmp(lexEl.string, "char");
  149                     if ( Value > 0 ) {
  150                         return (defaultValue);
  151                     } else if ( Value < 0 ) {
  152                         if ( !strcmp(lexEl.string, "cdecl") ) {
  153                             return (CDECL_c);
  154                         }
  155                     } else 
  156                         return (CHAR_c);
  157                 } else if ( Value < 0 ) {
  158                     Value = strcmp(lexEl.string, "break");
  159                     if ( Value > 0 ) {
  160                         return (defaultValue);
  161                     } else if ( Value < 0 ) {
  162                         if ( !strcmp(lexEl.string, "auto") ) {
  163                             return (AUTO_c);
  164                         }
  165                     } else 
  166                         return (BREAK_c);
  167                 } else 
  168                     return (CASE_c);
  169             } else 
  170                 return (CONTINUE_c);
  171         } else if ( Value < 0 ) {
  172             Value = strcmp(lexEl.string, "HUGE");
  173             if ( Value > 0 ) {
  174                 Value = strcmp(lexEl.string, "PROG_EXIT");
  175                 if ( Value > 0 ) {
  176                     Value = strcmp(lexEl.string, "TOKEN_EXIT");
  177                     if ( Value > 0 ) {
  178                         return (defaultValue);
  179                     } else if ( Value < 0 ) {
  180                         if ( !strcmp(lexEl.string, "PUSH_CALLlAFF") ) {
  181                             return (PUSH_CALLlAFF_c);
  182                         }
  183                     } else 
  184                         return (TOKEN_EXIT_c);
  185                 } else if ( Value < 0 ) {
  186                     Value = strcmp(lexEl.string, "PASCAL");
  187                     if ( Value > 0 ) {
  188                         return (defaultValue);
  189                     } else if ( Value < 0 ) {
  190                         if ( !strcmp(lexEl.string, "NEAR") ) {
  191                             return (NEAR1_c);
  192                         }
  193                     } else 
  194                         return (PASCAL1_c);
  195                 } else 
  196                     return (PROG_EXIT_c);
  197             } else if ( Value < 0 ) {
  198                 Value = strcmp(lexEl.string, "CDECL");
  199                 if ( Value > 0 ) {
  200                     Value = strcmp(lexEl.string, "FORTRAN");
  201                     if ( Value > 0 ) {
  202                         return (defaultValue);
  203                     } else if ( Value < 0 ) {
  204                         if ( !strcmp(lexEl.string, "FAR") ) {
  205                             return (FAR1_c);
  206                         }
  207                     } else 
  208                         return (FORTRAN1_c);
  209                 } else if ( Value < 0 ) {
  210                     Value = strcmp(lexEl.string, ")");
  211                     if ( Value > 0 ) {
  212                         if ( !strcmp(lexEl.string, "CASE_EXIT") ) {
  213                             return (CASE_EXIT_c);
  214                         }
  215                     } else if ( Value < 0 ) {
  216                         if ( !strcmp(lexEl.string, "(") ) {
  217                             return (POUV_c);
  218                         }
  219                     } else 
  220                         return (PFER_c);
  221                 } else 
  222                     return (CDECL1_c);
  223             } else 
  224                 return (HUGE1_c);
  225         } else 
  226             return (_FAR__c);
  227     } else 
  228         return (ENUM_c);
  229     return (defaultValue);
  230 }
  231 
  232 UpSortKeyWord ( value )
  233 int value ;
  234 {
  235     register char   *ptSource = lexEl.string ;
  236     
  237     for (; *ptSource ; ptSource++ ) 
  238         *ptSource = toupper(*ptSource);
  239     return SortKeyWord(value);
  240 }
  241 
  242 Lex_c ()
  243 {
  244     char    *_ptString ;
  245     int     _nbCharact ;
  246     int     bidon = oldLine = line ;
  247     
  248     ptStockBuf = - 1 ;
  249     while ( c == ' ' || c == '\t' || c == '\r' || c == '\n' ) 
  250         NextChar();
  251     ptStockBuf = - 1 ;
  252     *lexEl.string = '\0';
  253     _nbCharact = 0 ;
  254     tokenAhead = 0 ;
  255     _ptString = lexEl.string ;
  256     switch ( c ) {
  257         case '#' : 
  258             NextChar();
  259             switch ( c ) {
  260                 case 'i' : 
  261                     NextChar();
  262                     switch ( c ) {
  263                         case 'n' : 
  264                             NextChar();
  265                             if ( GetStringS("clude", 1) ) {
  266                                 lexEl.Value = DIESINCLUDE_c ;
  267                                 *_ptString = '\0';
  268                                 firstOnLine = 0 ;
  269                                 tokenAhead = 1 ;
  270                                 return (1);
  271                             } else {
  272                                 UnputChar(1);
  273                                 goto _exitDumpToken3 ;
  274                             }
  275                             break ;
  276                         case 'f' : 
  277                             NextChar();
  278                             switch ( c ) {
  279                                 case 'd' : 
  280                                     NextChar();
  281                                     if ( GetStringS("ef", 1) ) {
  282                                         lexEl.Value = DIESIFDEF_c ;
  283                                         *_ptString = '\0';
  284                                         firstOnLine = 0 ;
  285                                         tokenAhead = 1 ;
  286                                         return (1);
  287                                     } else {
  288                                         UnputChar(1);
  289                                         goto _exitDumpToken5 ;
  290                                     }
  291                                     break ;
  292                                 case 'n' : 
  293                                     NextChar();
  294                                     if ( GetStringS("def", 1) ) {
  295                                         lexEl.Value = DIESIFNDEF_c ;
  296                                         *_ptString = '\0';
  297                                         firstOnLine = 0 ;
  298                                         tokenAhead = 1 ;
  299                                         return (1);
  300                                     } else {
  301                                         UnputChar(1);
  302                                         goto _exitDumpToken5 ;
  303                                     }
  304                                     break ;
  305                                 _exitDumpToken5 : 
  306                                     ;
  307                                 default : 
  308                                     lexEl.Value = DIESIF_c ;
  309                                     *_ptString = '\0';
  310                                     firstOnLine = 0 ;
  311                                     tokenAhead = 1 ;
  312                                     return (1);
  313                             }
  314                             break ;
  315                         _exitDumpToken3 : 
  316                             ;
  317                         default : 
  318                             UnputChar(1);
  319                             goto _exitDumpToken2 ;
  320                     }
  321                     break ;
  322                 case 'd' : 
  323                     NextChar();
  324                     if ( GetStringS("efine", 1) ) {
  325                         lexEl.Value = DIESDEFINE_c ;
  326                         *_ptString = '\0';
  327                         firstOnLine = 0 ;
  328                         tokenAhead = 1 ;
  329                         return (1);
  330                     } else {
  331                         UnputChar(1);
  332                         goto _exitDumpToken2 ;
  333                     }
  334                     break ;
  335                 case 'e' : 
  336                     NextChar();
  337                     switch ( c ) {
  338                         case 'l' : 
  339                             NextChar();
  340                             switch ( c ) {
  341                                 case 's' : 
  342                                     NextChar();
  343                                     if ( GetStringS("e", 1) ) {
  344                                         lexEl.Value = DIESELSE_c ;
  345                                         *_ptString = '\0';
  346                                         firstOnLine = 0 ;
  347                                         tokenAhead = 1 ;
  348                                         return (1);
  349                                     } else {
  350                                         UnputChar(1);
  351                                         goto _exitDumpToken10 ;
  352                                     }
  353                                     break ;
  354                                 case 'i' : 
  355                                     NextChar();
  356                                     if ( GetStringS("f", 1) ) {
  357                                         lexEl.Value = DIESELIF_c ;
  358                                         *_ptString = '\0';
  359                                         firstOnLine = 0 ;
  360                                         tokenAhead = 1 ;
  361                                         return (1);
  362                                     } else {
  363                                         UnputChar(1);
  364                                         goto _exitDumpToken10 ;
  365                                     }
  366                                     break ;
  367                                 _exitDumpToken10 : 
  368                                     ;
  369                                 default : 
  370                                     UnputChar(1);
  371                                     goto _exitDumpToken9 ;
  372                             }
  373                             break ;
  374                         case 'n' : 
  375                             NextChar();
  376                             if ( GetStringS("dif", 1) ) {
  377                                 lexEl.Value = DIESENDIF_c ;
  378                                 *_ptString = '\0';
  379                                 firstOnLine = 0 ;
  380                                 tokenAhead = 1 ;
  381                                 return (1);
  382                             } else {
  383                                 UnputChar(1);
  384                                 goto _exitDumpToken9 ;
  385                             }
  386                             break ;
  387                         _exitDumpToken9 : 
  388                             ;
  389                         default : 
  390                             UnputChar(1);
  391                             goto _exitDumpToken2 ;
  392                     }
  393                     break ;
  394                 case 'l' : 
  395                     NextChar();
  396                     if ( GetStringS("ine", 1) ) {
  397                         lexEl.Value = DIESLINE_c ;
  398                         *_ptString = '\0';
  399                         firstOnLine = 0 ;
  400                         tokenAhead = 1 ;
  401                         return (1);
  402                     } else {
  403                         UnputChar(1);
  404                         goto _exitDumpToken2 ;
  405                     }
  406                     break ;
  407                 case 'u' : 
  408                     NextChar();
  409                     if ( GetStringS("ndef", 1) ) {
  410                         lexEl.Value = DIESUNDEF_c ;
  411                         *_ptString = '\0';
  412                         firstOnLine = 0 ;
  413                         tokenAhead = 1 ;
  414                         return (1);
  415                     } else {
  416                         UnputChar(1);
  417                         goto _exitDumpToken2 ;
  418                     }
  419                     break ;
  420                 case 'p' : 
  421                     NextChar();
  422                     if ( GetStringS("ragma", 1) ) {
  423                         lexEl.Value = DIESPRAGMA_c ;
  424                         *_ptString = '\0';
  425                         firstOnLine = 0 ;
  426                         tokenAhead = 1 ;
  427                         return (1);
  428                     } else {
  429                         UnputChar(1);
  430                         goto _exitDumpToken2 ;
  431                     }
  432                     break ;
  433                 _exitDumpToken2 : 
  434                     ;
  435                 default : 
  436                     lexEl.Value = DIES_c ;
  437                     *_ptString = '\0';
  438                     firstOnLine = 0 ;
  439                     tokenAhead = 1 ;
  440                     return (1);
  441             }
  442             break ;
  443         case ';' : 
  444             NextChar();
  445             lexEl.Value = PVIR_c ;
  446             *_ptString = '\0';
  447             firstOnLine = 0 ;
  448             tokenAhead = 1 ;
  449             return (1);
  450             break ;
  451         case '=' : 
  452             NextChar();
  453             switch ( c ) {
  454                 case '=' : 
  455                     NextChar();
  456                     lexEl.Value = EGALEGAL_c ;
  457                     *_ptString = '\0';
  458                     firstOnLine = 0 ;
  459                     tokenAhead = 1 ;
  460                     return (1);
  461                     break ;
  462                 _exitDumpToken18 : 
  463                     ;
  464                 default : 
  465                     lexEl.Value = EGAL_c ;
  466                     *_ptString = '\0';
  467                     firstOnLine = 0 ;
  468                     tokenAhead = 1 ;
  469                     return (1);
  470             }
  471             break ;
  472         case ',' : 
  473             NextChar();
  474             lexEl.Value = VIRG_c ;
  475             *_ptString = '\0';
  476             firstOnLine = 0 ;
  477             tokenAhead = 1 ;
  478             return (1);
  479             break ;
  480         case '{' : 
  481             NextChar();
  482             lexEl.Value = AOUV_c ;
  483             *_ptString = '\0';
  484             firstOnLine = 0 ;
  485             tokenAhead = 1 ;
  486             return (1);
  487             break ;
  488         case '}' : 
  489             NextChar();
  490             lexEl.Value = AFER_c ;
  491             *_ptString = '\0';
  492             firstOnLine = 0 ;
  493             tokenAhead = 1 ;
  494             return (1);
  495             break ;
  496         case '*' : 
  497             NextChar();
  498             switch ( c ) {
  499                 case '=' : 
  500                     NextChar();
  501                     lexEl.Value = ETOIEGAL_c ;
  502                     *_ptString = '\0';
  503                     firstOnLine = 0 ;
  504                     tokenAhead = 1 ;
  505                     return (1);
  506                     break ;
  507                 case '*' : 
  508                     NextChar();
  509                     if ( GetStringS("=", 1) ) {
  510                         lexEl.Value = ETOIETOIEGAL_c ;
  511                         *_ptString = '\0';
  512                         firstOnLine = 0 ;
  513                         tokenAhead = 1 ;
  514                         return (1);
  515                     } else {
  516                         UnputChar(1);
  517                         goto _exitDumpToken23 ;
  518                     }
  519                     break ;
  520                 _exitDumpToken23 : 
  521                     ;
  522                 default : 
  523                     lexEl.Value = ETOI_c ;
  524                     *_ptString = '\0';
  525                     firstOnLine = 0 ;
  526                     tokenAhead = 1 ;
  527                     return (1);
  528             }
  529             break ;
  530         case '(' : 
  531             NextChar();
  532             lexEl.Value = POUV_c ;
  533             *_ptString = '\0';
  534             firstOnLine = 0 ;
  535             tokenAhead = 1 ;
  536             return (1);
  537             break ;
  538         case ')' : 
  539             NextChar();
  540             lexEl.Value = PFER_c ;
  541             *_ptString = '\0';
  542             firstOnLine = 0 ;
  543             tokenAhead = 1 ;
  544             return (1);
  545             break ;
  546         case '[' : 
  547             NextChar();
  548             lexEl.Value = COUV_c ;
  549             *_ptString = '\0';
  550             firstOnLine = 0 ;
  551             tokenAhead = 1 ;
  552             return (1);
  553             break ;
  554         case ']' : 
  555             NextChar();
  556             lexEl.Value = CFER_c ;
  557             *_ptString = '\0';
  558             firstOnLine = 0 ;
  559             tokenAhead = 1 ;
  560             return (1);
  561             break ;
  562         case ':' : 
  563             NextChar();
  564             lexEl.Value = DPOI_c ;
  565             *_ptString = '\0';
  566             firstOnLine = 0 ;
  567             tokenAhead = 1 ;
  568             return (1);
  569             break ;
  570         case '%' : 
  571             NextChar();
  572             switch ( c ) {
  573                 case '=' : 
  574                     NextChar();
  575                     lexEl.Value = POURCEGAL_c ;
  576                     *_ptString = '\0';
  577                     firstOnLine = 0 ;
  578                     tokenAhead = 1 ;
  579                     return (1);
  580                     break ;
  581                 _exitDumpToken31 : 
  582                     ;
  583                 default : 
  584                     lexEl.Value = POURC_c ;
  585                     *_ptString = '\0';
  586                     firstOnLine = 0 ;
  587                     tokenAhead = 1 ;
  588                     return (1);
  589             }
  590             break ;
  591         case '+' : 
  592             NextChar();
  593             switch ( c ) {
  594                 case '=' : 
  595                     NextChar();
  596                     lexEl.Value = PLUSEGAL_c ;
  597                     *_ptString = '\0';
  598                     firstOnLine = 0 ;
  599                     tokenAhead = 1 ;
  600                     return (1);
  601                     break ;
  602                 case '+' : 
  603                     NextChar();
  604                     lexEl.Value = PLUSPLUS_c ;
  605                     *_ptString = '\0';
  606                     firstOnLine = 0 ;
  607                     tokenAhead = 1 ;
  608                     return (1);
  609                     break ;
  610                 _exitDumpToken33 : 
  611                     ;
  612                 default : 
  613                     lexEl.Value = PLUS_c ;
  614                     *_ptString = '\0';
  615                     firstOnLine = 0 ;
  616                     tokenAhead = 1 ;
  617                     return (1);
  618             }
  619             break ;
  620         case '-' : 
  621             NextChar();
  622             switch ( c ) {
  623                 case '=' : 
  624                     NextChar();
  625                     lexEl.Value = TIREEGAL_c ;
  626                     *_ptString = '\0';
  627                     firstOnLine = 0 ;
  628                     tokenAhead = 1 ;
  629                     return (1);
  630                     break ;
  631                 case '-' : 
  632                     NextChar();
  633                     lexEl.Value = TIRETIRE_c ;
  634                     *_ptString = '\0';
  635                     firstOnLine = 0 ;
  636                     tokenAhead = 1 ;
  637                     return (1);
  638                     break ;
  639                 case '>' : 
  640                     NextChar();
  641                     lexEl.Value = TIRESUPE_c ;
  642                     *_ptString = '\0';
  643                     firstOnLine = 0 ;
  644                     tokenAhead = 1 ;
  645                     return (1);
  646                     break ;
  647                 _exitDumpToken36 : 
  648                     ;
  649                 default : 
  650                     lexEl.Value = TIRE_c ;
  651                     *_ptString = '\0';
  652                     firstOnLine = 0 ;
  653                     tokenAhead = 1 ;
  654                     return (1);
  655             }
  656             break ;
  657         case '<' : 
  658             NextChar();
  659             switch ( c ) {
  660                 case '<' : 
  661                     NextChar();
  662                     switch ( c ) {
  663                         case '=' : 
  664                             NextChar();
  665                             lexEl.Value = INFEINFEEGAL_c ;
  666                             *_ptString = '\0';
  667                             firstOnLine = 0 ;
  668                             tokenAhead = 1 ;
  669                             return (1);
  670                             break ;
  671                         _exitDumpToken41 : 
  672                             ;
  673                         default : 
  674                             lexEl.Value = INFEINFE_c ;
  675                             *_ptString = '\0';
  676                             firstOnLine = 0 ;
  677                             tokenAhead = 1 ;
  678                             return (1);
  679                     }
  680                     break ;
  681                 case '=' : 
  682                     NextChar();
  683                     lexEl.Value = INFEEGAL_c ;
  684                     *_ptString = '\0';
  685                     firstOnLine = 0 ;
  686                     tokenAhead = 1 ;
  687                     return (1);
  688                     break ;
  689                 _exitDumpToken40 : 
  690                     ;
  691                 default : 
  692                     lexEl.Value = INFE_c ;
  693                     *_ptString = '\0';
  694                     firstOnLine = 0 ;
  695                     tokenAhead = 1 ;
  696                     return (1);
  697             }
  698             break ;
  699         case '>' : 
  700             NextChar();
  701             switch ( c ) {
  702                 case '>' : 
  703                     NextChar();
  704                     switch ( c ) {
  705                         case '=' : 
  706                             NextChar();
  707                             lexEl.Value = SUPESUPEEGAL_c ;
  708                             *_ptString = '\0';
  709                             firstOnLine = 0 ;
  710                             tokenAhead = 1 ;
  711                             return (1);
  712                             break ;
  713                         _exitDumpToken45 : 
  714                             ;
  715                         default : 
  716                             lexEl.Value = SUPESUPE_c ;
  717                             *_ptString = '\0';
  718                             firstOnLine = 0 ;
  719                             tokenAhead = 1 ;
  720                             return (1);
  721                     }
  722                     break ;
  723                 case '=' : 
  724                     NextChar();
  725                     lexEl.Value = SUPEEGAL_c ;
  726                     *_ptString = '\0';
  727                     firstOnLine = 0 ;
  728                     tokenAhead = 1 ;
  729                     return (1);
  730                     break ;
  731                 _exitDumpToken44 : 
  732                     ;
  733                 default : 
  734                     lexEl.Value = SUPE_c ;
  735                     *_ptString = '\0';
  736                     firstOnLine = 0 ;
  737                     tokenAhead = 1 ;
  738                     return (1);
  739             }
  740             break ;
  741         case '&' : 
  742             NextChar();
  743             switch ( c ) {
  744                 case '=' : 
  745                     NextChar();
  746                     lexEl.Value = ETCOEGAL_c ;
  747                     *_ptString = '\0';
  748                     firstOnLine = 0 ;
  749                     tokenAhead = 1 ;
  750                     return (1);
  751                     break ;
  752                 case '&' : 
  753                     NextChar();
  754                     lexEl.Value = ETCOETCO_c ;
  755                     *_ptString = '\0';
  756                     firstOnLine = 0 ;
  757                     tokenAhead = 1 ;
  758                     return (1);
  759                     break ;
  760                 _exitDumpToken48 : 
  761                     ;
  762                 default : 
  763                     lexEl.Value = ETCO_c ;
  764                     *_ptString = '\0';
  765                     firstOnLine = 0 ;
  766                     tokenAhead = 1 ;
  767                     return (1);
  768             }
  769             break ;
  770         case '|' : 
  771             NextChar();
  772             switch ( c ) {
  773                 case '=' : 
  774                     NextChar();
  775                     lexEl.Value = VBAREGAL_c ;
  776                     *_ptString = '\0';
  777                     firstOnLine = 0 ;
  778                     tokenAhead = 1 ;
  779                     return (1);
  780                     break ;
  781                 case '|' : 
  782                     NextChar();
  783                     lexEl.Value = VBARVBAR_c ;
  784                     *_ptString = '\0';
  785                     firstOnLine = 0 ;
  786                     tokenAhead = 1 ;
  787                     return (1);
  788                     break ;
  789                 _exitDumpToken51 : 
  790                     ;
  791                 default : 
  792                     lexEl.Value = VBAR_c ;
  793                     *_ptString = '\0';
  794                     firstOnLine = 0 ;
  795                     tokenAhead = 1 ;
  796                     return (1);
  797             }
  798             break ;
  799         case '^' : 
  800             NextChar();
  801             switch ( c ) {
  802                 case '=' : 
  803                     NextChar();
  804                     lexEl.Value = CHAPEGAL_c ;
  805                     *_ptString = '\0';
  806                     firstOnLine = 0 ;
  807                     tokenAhead = 1 ;
  808                     return (1);
  809                     break ;
  810                 _exitDumpToken54 : 
  811                     ;
  812                 default : 
  813                     lexEl.Value = CHAP_c ;
  814                     *_ptString = '\0';
  815                     firstOnLine = 0 ;
  816                     tokenAhead = 1 ;
  817                     return (1);
  818             }
  819             break ;
  820         case '?' : 
  821             NextChar();
  822             lexEl.Value = INTE_c ;
  823             *_ptString = '\0';
  824             firstOnLine = 0 ;
  825             tokenAhead = 1 ;
  826             return (1);
  827             break ;
  828         case '!' : 
  829             NextChar();
  830             switch ( c ) {
  831                 case '=' : 
  832                     NextChar();
  833                     lexEl.Value = EXCLEGAL_c ;
  834                     *_ptString = '\0';
  835                     firstOnLine = 0 ;
  836                     tokenAhead = 1 ;
  837                     return (1);
  838                     break ;
  839                 _exitDumpToken57 : 
  840                     ;
  841                 default : 
  842                     lexEl.Value = EXCL_c ;
  843                     *_ptString = '\0';
  844                     firstOnLine = 0 ;
  845                     tokenAhead = 1 ;
  846                     return (1);
  847             }
  848             break ;
  849         case '~' : 
  850             NextChar();
  851             lexEl.Value = TILD_c ;
  852             *_ptString = '\0';
  853             firstOnLine = 0 ;
  854             tokenAhead = 1 ;
  855             return (1);
  856             break ;
  857         case '.' : 
  858             NextChar();
  859             switch ( c ) {
  860                 case '.' : 
  861                     NextChar();
  862                     if ( GetStringS(".", 1) ) {
  863                         lexEl.Value = POINPOINPOIN_c ;
  864                         *_ptString = '\0';
  865                         firstOnLine = 0 ;
  866                         tokenAhead = 1 ;
  867                         return (1);
  868                     } else {
  869                         UnputChar(1);
  870                         goto _exitDumpToken60 ;
  871                     }
  872                     break ;
  873                 _exitDumpToken60 : 
  874                     ;
  875                 default : 
  876                     lexEl.Value = POIN_c ;
  877                     *_ptString = '\0';
  878                     firstOnLine = 0 ;
  879                     tokenAhead = 1 ;
  880                     return (1);
  881             }
  882             break ;
  883         _exitDumpToken0 : 
  884             ;
  885         default : break ;
  886     }
  887     if ( ptStockBuf > - 1 ) 
  888         UnputBuf();
  889     *lexEl.string = '\0';
  890     _nbCharact = 0 ;
  891     tokenAhead = 0 ;
  892     _ptString = lexEl.string ;
  893     switch ( c ) {
  894         case 'a' : 
  895         case 'b' : 
  896         case 'c' : 
  897         case 'd' : 
  898         case 'e' : 
  899         case 'f' : 
  900         case 'g' : 
  901         case 'h' : 
  902         case 'i' : 
  903         case 'j' : 
  904         case 'k' : 
  905         case 'l' : 
  906         case 'm' : 
  907         case 'n' : 
  908         case 'o' : 
  909         case 'p' : 
  910         case 'q' : 
  911         case 'r' : 
  912         case 's' : 
  913         case 't' : 
  914         case 'u' : 
  915         case 'v' : 
  916         case 'w' : 
  917         case 'x' : 
  918         case 'y' : 
  919         case 'z' : 
  920         case 'A' : 
  921         case 'B' : 
  922         case 'C' : 
  923         case 'D' : 
  924         case 'E' : 
  925         case 'F' : 
  926         case 'G' : 
  927         case 'H' : 
  928         case 'I' : 
  929         case 'J' : 
  930         case 'K' : 
  931         case 'L' : 
  932         case 'M' : 
  933         case 'N' : 
  934         case 'O' : 
  935         case 'P' : 
  936         case 'Q' : 
  937         case 'R' : 
  938         case 'S' : 
  939         case 'T' : 
  940         case 'U' : 
  941         case 'V' : 
  942         case 'W' : 
  943         case 'X' : 
  944         case 'Y' : 
  945         case 'Z' : 
  946         case '_' : 
  947             while ( 'a' <= c && c <= 'z'
  948                         || 'A' <= c && c <= 'Z'
  949                         || c == '_'
  950                         || '0' <= c && c <= '9' ) {
  951                 {
  952                     if ( _nbCharact++ < MAXLENGTH ) 
  953                         *_ptString++ = c ;
  954                     NextChar();
  955                 }
  956             }
  957             {
  958                 *_ptString = '\0';
  959                 firstOnLine = 0 ;
  960                 tokenAhead = 1 ;
  961                 lexEl.Value = SortKeyWord(IDENT_c);
  962                 return (1);
  963             }
  964             break ;
  965         case '"' : 
  966             NextChar();
  967             while ( c != EOF ) {
  968                 switch ( c ) {
  969                     case '"' : 
  970                         NextChar();
  971                         if ( c == '"' ) {
  972                             {
  973                                 if ( _nbCharact++ < MAXLENGTH ) 
  974                                     *_ptString++ = c ;
  975                                 NextChar();
  976                             }
  977                         } else {
  978                             {
  979                                 *_ptString = '\0';
  980                                 firstOnLine = 0 ;
  981                                 tokenAhead = 1 ;
  982                                 lexEl.Value = STRING_c ;
  983                                 return (1);
  984                             }
  985                         }
  986                         break ;
  987                     case '\\' : 
  988                         NextChar();
  989                         {
  990                             if ( _nbCharact + strlen("\\") < MAXLENGTH ) 
  991                                 strcpy(_ptString, "\\");
  992                             _nbCharact += strlen("\\");
  993                             _ptString = lexEl.string + _nbCharact ;
  994                         }
  995                         if ( !(c == '\r') ) {
  996                             {
  997                                 if ( _nbCharact++ < MAXLENGTH ) 
  998                                     *_ptString++ = c ;
  999                                 NextChar();
 1000                             }
 1001                         } else {
 1002                             if ( !(c != EOF && NextChar()) ) 
 1003                                 ;
 1004                         }
 1005                         break ;
 1006                     default : 
 1007                         if ( c != EOF ) {
 1008                             {
 1009                                 if ( _nbCharact++ < MAXLENGTH ) 
 1010                                     *_ptString++ = c ;
 1011                                 NextChar();
 1012                             }
 1013                         }
 1014                         break ;
 1015                 }
 1016             }
 1017             break ;
 1018         case '\'' : 
 1019             NextChar();
 1020             while ( c != EOF ) {
 1021                 if ( GetString("'", 1) && NextChar() ) {
 1022                     {
 1023                         *_ptString = '\0';
 1024                         firstOnLine = 0 ;
 1025                         tokenAhead = 1 ;
 1026                         lexEl.Value = CHARACT_c ;
 1027                         return (1);
 1028                     }
 1029                 } else if ( c != EOF ) {
 1030                     {
 1031                         if ( _nbCharact++ < MAXLENGTH ) 
 1032                             *_ptString++ = c ;
 1033                         NextChar();
 1034                     }
 1035                 } else 
 1036                     ;
 1037             }
 1038             break ;
 1039         case '1' : 
 1040         case '2' : 
 1041         case '3' : 
 1042         case '4' : 
 1043         case '5' : 
 1044         case '6' : 
 1045         case '7' : 
 1046         case '8' : 
 1047         case '9' : 
 1048             while ( '0' <= c && c <= '9' ) {
 1049                 {
 1050                     if ( _nbCharact++ < MAXLENGTH ) 
 1051                         *_ptString++ = c ;
 1052                     NextChar();
 1053                 }
 1054             }
 1055             switch ( c ) {
 1056                 case 'l' : 
 1057                 case 'L' : 
 1058                     NextChar();
 1059                     {
 1060                         *_ptString = '\0';
 1061                         firstOnLine = 0 ;
 1062                         tokenAhead = 1 ;
 1063                         lexEl.Value = LINTEGER_c ;
 1064                         return (1);
 1065                     }
 1066                     break ;
 1067                 case 'e' : 
 1068                 case 'E' : 
 1069                     NextChar();
 1070                     {
 1071                         if ( _nbCharact + strlen("e") < MAXLENGTH ) 
 1072                             strcpy(_ptString, "e");
 1073                         _nbCharact += strlen("e");
 1074                         _ptString = lexEl.string + _nbCharact ;
 1075                     }
 1076                     if ( c == '+' || c == '-' ) {
 1077                         {
 1078                             if ( _nbCharact++ < MAXLENGTH ) 
 1079                                 *_ptString++ = c ;
 1080                             NextChar();
 1081                         }
 1082                     }
 1083                     while ( '0' <= c && c <= '9' ) {
 1084                         {
 1085                             if ( _nbCharact++ < MAXLENGTH ) 
 1086                                 *_ptString++ = c ;
 1087                             NextChar();
 1088                         }
 1089                     }
 1090                     {
 1091                         *_ptString = '\0';
 1092                         firstOnLine = 0 ;
 1093                         tokenAhead = 1 ;
 1094                         lexEl.Value = FLOAT_c ;
 1095                         return (1);
 1096                     }
 1097                     break ;
 1098                 case '.' : 
 1099                     {
 1100                         if ( _nbCharact++ < MAXLENGTH ) 
 1101                             *_ptString++ = c ;
 1102                         NextChar();
 1103                     }
 1104                     while ( '0' <= c && c <= '9' ) {
 1105                         {
 1106                             if ( _nbCharact++ < MAXLENGTH ) 
 1107                                 *_ptString++ = c ;
 1108                             NextChar();
 1109                         }
 1110                     }
 1111                     if ( (c == 'e' || c == 'E') && NextChar() ) {
 1112                         {
 1113                             if ( _nbCharact + strlen("e") < MAXLENGTH ) 
 1114                                 strcpy(_ptString, "e");
 1115                             _nbCharact += strlen("e");
 1116                             _ptString = lexEl.string + _nbCharact ;
 1117                         }
 1118                         if ( c == '+' || c == '-' ) {
 1119                             {
 1120                                 if ( _nbCharact++ < MAXLENGTH ) 
 1121                                     *_ptString++ = c ;
 1122                                 NextChar();
 1123                             }
 1124                         }
 1125                         while ( '0' <= c && c <= '9' ) {
 1126                             {
 1127                                 if ( _nbCharact++ < MAXLENGTH ) 
 1128                                     *_ptString++ = c ;
 1129                                 NextChar();
 1130                             }
 1131                         }
 1132                     }
 1133                     {
 1134                         *_ptString = '\0';
 1135                         firstOnLine = 0 ;
 1136                         tokenAhead = 1 ;
 1137                         lexEl.Value = FLOAT_c ;
 1138                         return (1);
 1139                     }
 1140                     break ;
 1141                 default : 
 1142                     if ( c != EOF ) {
 1143                         {
 1144                             *_ptString = '\0';
 1145                             firstOnLine = 0 ;
 1146                             tokenAhead = 1 ;
 1147                             lexEl.Value = INTEGER_c ;
 1148                             return (1);
 1149                         }
 1150                     }
 1151                     break ;
 1152             }
 1153             break ;
 1154         case '0' : 
 1155             NextChar();
 1156             switch ( c ) {
 1157                 case 'x' : 
 1158                 case 'X' : 
 1159                     NextChar();
 1160                     {
 1161                         if ( _nbCharact + strlen("0x") < MAXLENGTH ) 
 1162                             strcpy(_ptString, "0x");
 1163                         _nbCharact += strlen("0x");
 1164                         _ptString = lexEl.string + _nbCharact ;
 1165                     }
 1166                     while ( '0' <= c && c <= '9'
 1167                                 || 'a' <= c && c <= 'f'
 1168                                 || 'A' <= c && c <= 'F' ) {
 1169                         {
 1170                             if ( _nbCharact++ < MAXLENGTH ) 
 1171                                 *_ptString++ = c ;
 1172                             NextChar();
 1173                         }
 1174                     }
 1175                     {
 1176                         *_ptString = '\0';
 1177                         firstOnLine = 0 ;
 1178                         tokenAhead = 1 ;
 1179                         lexEl.Value = INTEGER_c ;
 1180                         return (1);
 1181                     }
 1182                     break ;
 1183                 case '0' : 
 1184                 case '1' : 
 1185                 case '2' : 
 1186                 case '3' : 
 1187                 case '4' : 
 1188                 case '5' : 
 1189                 case '6' : 
 1190                 case '7' : 
 1191                     {
 1192                         if ( _nbCharact + strlen("0") < MAXLENGTH ) 
 1193                             strcpy(_ptString, "0");
 1194                         _nbCharact += strlen("0");
 1195                         _ptString = lexEl.string + _nbCharact ;
 1196                     }
 1197                     while ( '0' <= c && c <= '7' ) {
 1198                         {
 1199                             if ( _nbCharact++ < MAXLENGTH ) 
 1200                                 *_ptString++ = c ;
 1201                             NextChar();
 1202                         }
 1203                     }
 1204                     {
 1205                         *_ptString = '\0';
 1206                         firstOnLine = 0 ;
 1207                         tokenAhead = 1 ;
 1208                         lexEl.Value = INTEGER_c ;
 1209                         return (1);
 1210                     }
 1211                     break ;
 1212                 default : 
 1213                     if ( c != EOF ) {
 1214                         {
 1215                             if ( _nbCharact + strlen("0") < MAXLENGTH ) 
 1216                                 strcpy(_ptString, "0");
 1217                             _nbCharact += strlen("0");
 1218                             _ptString = lexEl.string + _nbCharact ;
 1219                         }
 1220                         {
 1221                             *_ptString = '\0';
 1222                             firstOnLine = 0 ;
 1223                             tokenAhead = 1 ;
 1224                             lexEl.Value = INTEGER_c ;
 1225                             return (1);
 1226                         }
 1227                     }
 1228                     break ;
 1229             }
 1230             break ;
 1231         case '$' : 
 1232             NextChar();
 1233             if ( !(c == '(') ) {
 1234                 while ( 'a' <= c && c <= 'z'
 1235                             || 'A' <= c && c <= 'Z'
 1236                             || '0' <= c && c <= '9'
 1237                             || c == '_' ) {
 1238                     {
 1239                         if ( _nbCharact++ < MAXLENGTH ) 
 1240                             *_ptString++ = c ;
 1241                         NextChar();
 1242                     }
 1243                 }
 1244             } else {
 1245                 int nbPar = 0 ;
 1246                 {
 1247                     if ( _nbCharact++ < MAXLENGTH ) 
 1248                         *_ptString++ = c ;
 1249                     NextChar();
 1250                 }
 1251                 while ( c != EOF ) {
 1252                     switch ( c ) {
 1253                         case '(' : 
 1254                             nbPar++ ;
 1255                             {
 1256                                 if ( _nbCharact++ < MAXLENGTH ) 
 1257                                     *_ptString++ = c ;
 1258                                 NextChar();
 1259                             }
 1260                             break ;
 1261                         case '\n' : 
 1262                             {
 1263                                 *_ptString = '\0';
 1264                                 firstOnLine = 0 ;
 1265                                 tokenAhead = 1 ;
 1266                                 lexEl.Value = META_c ;
 1267                                 return (1);
 1268                             }
 1269                             break ;
 1270                         case ')' : 
 1271                             if ( !nbPar ) {
 1272                                 {
 1273                                     if ( _nbCharact++ < MAXLENGTH ) 
 1274                                         *_ptString++ = c ;
 1275                                     NextChar();
 1276                                 }
 1277                                 {
 1278                                     *_ptString = '\0';
 1279                                     firstOnLine = 0 ;
 1280                                     tokenAhead = 1 ;
 1281                                     lexEl.Value = META_c ;
 1282                                     return (1);
 1283                                 }
 1284                             } else {
 1285                                 {
 1286                                     if ( _nbCharact++ < MAXLENGTH ) 
 1287                                         *_ptString++ = c ;
 1288                                     NextChar();
 1289                                 }
 1290                                 nbPar-- ;
 1291                             }
 1292                             break ;
 1293                         default : 
 1294                             if ( c != EOF ) {
 1295                                 {
 1296                                     if ( _nbCharact++ < MAXLENGTH ) 
 1297                                         *_ptString++ = c ;
 1298                                     NextChar();
 1299                                 }
 1300                             }
 1301                             break ;
 1302                     }
 1303                 }
 1304             }
 1305             {
 1306                 *_ptString = '\0';
 1307                 firstOnLine = 0 ;
 1308                 tokenAhead = 1 ;
 1309                 lexEl.Value = META_c ;
 1310                 return (1);
 1311             }
 1312             break ;
 1313         case '/' : 
 1314             NextChar();
 1315             switch ( c ) {
 1316                 case '=' : 
 1317                     NextChar();
 1318                     {
 1319                         *_ptString = '\0';
 1320                         firstOnLine = 0 ;
 1321                         tokenAhead = 1 ;
 1322                         lexEl.Value = SLASEGAL_c ;
 1323                         return (1);
 1324                     }
 1325                     break ;
 1326                 case '*' : 
 1327                     NextChar();
 1328                     {
 1329                         int level = 0 ;
 1330                         begin_comment();
 1331                         while ( c != EOF ) {
 1332                             if ( GetString("/*", 1) && NextChar() ) {
 1333                                 level++ ;
 1334                                 {
 1335                                     if ( _nbCharact + strlen("/*")
 1336                                         < MAXLENGTH ) 
 1337                                         strcpy(_ptString, "/*");
 1338                                     _nbCharact += strlen("/*");
 1339                                     _ptString = lexEl.string + _nbCharact ;
 1340                                 }
 1341                             } else if ( GetString("*/", 1) && NextChar() ) {
 1342                                 if ( !level ) {
 1343                                     {
 1344                                         store_comment_line(_nbCharact);
 1345                                         _nbCharact = 0 ;
 1346                                         _ptString = lexEl.string ;
 1347                                         ptStockBuf = - 1 ;
 1348                                     }
 1349                                     {
 1350                                         *_ptString = '\0';
 1351                                         firstOnLine = 0 ;
 1352                                         tokenAhead = 1 ;
 1353                                         return Lex_c();
 1354                                     }
 1355                                 } else {
 1356                                     level-- ;
 1357                                     {
 1358                                         if ( _nbCharact + strlen("*/")
 1359                                             < MAXLENGTH ) 
 1360                                             strcpy(_ptString, "*/");
 1361                                         _nbCharact += strlen("*/");
 1362                                         _ptString
 1363                                             = lexEl.string + _nbCharact ;
 1364                                     }
 1365                                 }
 1366                             } else if ( c == '\n' && NextChar() ) {
 1367                                 {
 1368                                     store_comment_line(_nbCharact);
 1369                                     _nbCharact = 0 ;
 1370                                     _ptString = lexEl.string ;
 1371                                     ptStockBuf = - 1 ;
 1372                                 }
 1373                             } else if ( c == '\r' && NextChar() ) {
 1374                             } else if ( c != EOF ) {
 1375                                 {
 1376                                     if ( _nbCharact++ < MAXLENGTH ) 
 1377                                         *_ptString++ = c ;
 1378                                     NextChar();
 1379                                 }
 1380                             } else 
 1381                                 ;
 1382                         }
 1383                     }
 1384                     break ;
 1385                 default : 
 1386                     if ( c != EOF ) {
 1387                         {
 1388                             *_ptString = '\0';
 1389                             firstOnLine = 0 ;
 1390                             tokenAhead = 1 ;
 1391                             lexEl.Value = SLAS_c ;
 1392                             return (1);
 1393                         }
 1394                     }
 1395                     break ;
 1396             }
 1397             break ;
 1398     }
 1399     line = oldLine ;
 1400     sprintf(errStr, "Error unexpected \"%s\" at line %d \n", GetLexString()
 1401         , line);
 1402     PrintError(errStr, 0);
 1403     lexEl.Value = - 1 ;
 1404 }