cplex.c

这是一个Linux下的集成开发环境

                  yycharno = 0;
               }
            }
            else if( yychar == '"' )
            {
               break;
            }
/* 08.12.97 rigo: nem feladatunk az ellenorzes, viszont szamolnunk kell a sorokat
 *          else if( yychar == '\n' )
 *          {
 *             unput();
 *             break;
 *          }
 */
            else if( yychar == '\r' )
            {
               input();
               if( yychar != '\n' )
               {
                  unput();
               }
               yylineno++;
               yycharno = 0;
            }
            else if( yychar == '\n' )
            {
               yylineno++;
               yycharno = 0;
            }
         }
         d_TokenReturn( SN_STRINGliteral )

      case '\'':
         while( input())
         {
            if( yychar == '\\' )
            {
/* A \ utani karaktert lenyeljuk.
   Ha \ utan cr+lf jon, akkor midkettot lenyeljuk */
               input();
               if( yychar == '\r' )
               {
                  input();
                  if( yychar != '\n' )
                  {
                     unput();
                  }
                  yylineno++;
                  yycharno = 0;
               }
               else if( yychar == '\n' )
               {
                  yylineno++;
                  yycharno = 0;
               }
            }
            else if( yychar == '\'' )
            {
               break;
            }
            else if( yychar == '\n' )
            {
               unput();
               break;
            }
         }
         d_TokenReturn( SN_CHARACTERconstant )

      case '#':
/* printf( "# %d\n", token_in_line_count ); */
         /* vizsgaljuk, hogy ebben a sorban nem volt-e mar mas Token */
         if( token_in_line_count == 0 )
         {
            Token_t Token;
            if(( Token = f_Preprocessor()))
            {
               return Token;
            }
         }
         break;

      case '<':   /* <, <<, <=, <<= */
         if( lex_mode == LEX_MODE_INCLUDE )
         {
            while( input())
            {
               if( yychar == '\\' )
               {
/* A \ utani karaktert lenyeljuk.
   Ha \ utan cr+lf jon, akkor midkettot lenyeljuk */
                  input();
                  if( yychar == '\r' )
                  {
                     input();
                     if( yychar != '\n' )
                     {
                        unput();
                     }
                     yylineno++;
                     yycharno = 0;
                  }
                  else if( yychar == '\n' )
                  {
                     yylineno++;
                     yycharno = 0;
                  }
               }
               else if( yychar == '>' )
               {
                  break;
               }
               else if( yychar == '\n' )
               {
                  unput();
                  break;
               }
            }
            d_TokenReturn( SN_INCLUDEliteral )
         }
         else
         {
            switch( input())
            {
            case '<':
               switch( input())
               {
               case '=':
                  d_TokenReturn( SN_LSassign )
               default:
                  unput();
                  d_TokenReturn( SN_LS )
               }

            case '=':
               d_TokenReturn( SN_LE )
            default:
               unput();
               d_TokenReturn( '<' )
            }
         }

      case '>':   /* >, >>, >=, >>= */
         switch( input())
         {
         case '>':
            switch( input())
            {
            case '=':
               d_TokenReturn( SN_RSassign )
            default:
               unput();
               d_TokenReturn( SN_RS )
            }

         case '=':
            d_TokenReturn( SN_GE )

         default:
            unput();
            d_TokenReturn( '>' )
         }

      case '=':   /* =, == */
         switch( input())
         {
         case '=':
            d_TokenReturn( SN_EQ )

         default:
            unput();
            d_TokenReturn( '=' )
         }

      case '!':   /* !, != */
         switch( input())
         {
         case '=':
            d_TokenReturn( SN_NE )

         default:
            unput();
            d_TokenReturn( '!' )
         }

      case '+':   /* +, ++, += */
         switch( input())
         {
         case '+':
            d_TokenReturn( SN_ICR )

         case '=':
            d_TokenReturn( SN_PLUSassign )

         default:
            unput();
            d_TokenReturn( '+' )
         }

      case '-':   /* -, --, -=, ->, ->* */
         switch( input())
         {
         case '>':
            switch( input())
            {
            case '*':
               d_TokenReturn( SN_ARROWstar )
            default:
               unput();
               d_TokenReturn( SN_ARROW )
            }

         case '-':
            d_TokenReturn( SN_DECR )

         case '=':
            d_TokenReturn( SN_MINUSassign )

         default:
            unput();
            d_TokenReturn( '-' )
         }

      case '*':   /* *, *= */
         switch( input())
         {
         case '=':
            d_TokenReturn( SN_MULTassign )

         default:
            unput();
            d_TokenReturn( '*' )
         }

      case '/':   /* /, /=, / *, // */
         switch( input())
         {
         case '=':
            d_TokenReturn( SN_DIVassign )

         case '*':   /* comment */
            yycharprev = 0;
            while( input())
            {
               if( yychar == '/' && yycharprev == '*' )
               {
                  break;
               }
               if( yychar == '\r' )
               {
                  input();
                  if( yychar != '\n' )
                  {
                     unput();
                  }
                  yylineno++;
                  yycharno = 0;
               }
               else if( yychar == '\n' )
               {
                  yylineno++;
                  yycharno = 0;
               }
               yycharprev = yychar;
            }
#ifdef PRINT_REM
            printf( "%d rem %d.%d %d.%d\n"
                   , PAF_HIGH
                   , yylineno_beg
                   , yycharno_beg
                   , yylineno
                   , yycharno
                   );
#endif
            if( hig_fp )
            {
               fprintf( hig_fp
                      ,"%d rem %d.%d %d.%d\n"
                      , PAF_HIGH
                      , yylineno_beg
                      , yycharno_beg
                      , yylineno
                      , yycharno
                      );
            }
            save_comment( yylineno_beg, yycharno_beg + 2, yytext + 2, yyleng - 4 );
            break;

         case '/':   /* comment */
            while( input())
            {
               if( yychar == '\n' )
               {
                  yylineno++;
                  yycharno = 0;
                  if( lex_mode == LEX_MODE_PP )
                  {
                     token_in_line_count = -1;
                     d_TokenReturn( SN_NEWLINE )
                  }
                  else
                  {
                     token_in_line_count = 0;
                  }
                  break;
               }
            }
#ifdef PRINT_REM
            printf( "%d rem %d.%d %d.%d\n"
                   , PAF_HIGH
                   , yylineno_beg
                   , yycharno_beg
                   , yylineno
                   , yycharno
                   );
#endif
            if( hig_fp )
            {
               fprintf( hig_fp
                      ,"%d rem %d.%d %d.%d\n"
                      , PAF_HIGH
                      , yylineno_beg
                      , yycharno_beg
                      , yylineno
                      , yycharno
                      );
            }
            save_comment( yylineno_beg, yycharno_beg + 2, yytext + 2, yyleng - 3 );
            break;

         default:
            unput();
            d_TokenReturn( '/' )
         }
         break;

      case '|':   /* |, ||, |= */
         switch( input())
         {
         case '=':
            d_TokenReturn( SN_ORassign )

         case '|':
            d_TokenReturn( SN_OROR )

         default:
            unput();
            d_TokenReturn( '|' )
         }

      case '^':   /* ^, ^= */
         switch( input())
         {
         case '=':
            d_TokenReturn( SN_ERassign )

         default:
            unput();
            d_TokenReturn( '^' )
         }

      case '%':   /* %, %= */
         switch( input())
         {
         case '=':
            d_TokenReturn( SN_MODassign )

         default:
            unput();
            d_TokenReturn( '%' )
         }

      case '&':   /* &, &&, &= */
         switch( input())
         {
         case '=':
            d_TokenReturn( SN_ANDassign )

         case '&':
            d_TokenReturn( SN_ANDAND )

         default:
            unput();
            d_TokenReturn( '&' )
         }

      case ':':   /* :, :: */
         switch( input())
         {
         case ':':
            d_TokenReturn( SN_CLCL )

         default:
            unput();
            d_TokenReturn( ':' )
         }

      case '.':   /* ., .*, ... */
         switch( input())
         {
         case '*':
            d_TokenReturn( SN_DOTstar )

         case '.':
            switch( input())
            {
            case '.':
               d_TokenReturn( SN_ELLIPSIS )
            default:
               unput();
               break;
            }
            unput();
            d_TokenReturn( '.' )

         case '0':
         case '1':
         case '2':
         case '3':
         case '4':
         case '5':
         case '6':
         case '7':
         case '8':
         case '9':
            while( my_isdigit( input()))
            {
            }
            if( yychar == 'E' || yychar == 'e' )
            {
               input();
               if( yychar == '+' || yychar == '-' )
               {
               }
               else
               {
                  unput();
               }
               while( my_isdigit( input()))
               {
               }
               if( yychar == '.' )
               {
                  while( my_isdigit( input()))
                  {
                  }
               }
            }
            if( !( yychar == 'l' || yychar == 'L' ))
            {
               unput();
            }
            d_TokenReturn( SN_FLOATINGconstant )

         default:
            unput();
            d_TokenReturn( '.' )
         }

      case '(':
      case ')':
      case '[':
      case ']':
      case '{':
      case '}':
      case ',':
      case ';':
      case '~':
      case '?':
      case '@':
         d_TokenReturn( yychar )

      case 0:
         yyleng = 0;
         d_TokenReturn( 0 )

      default:
/*          printf( "syntax error %d (%c)\n", yychar, yychar ); */
         break;
      }
   }
}

extern void f_TokenUnput( Token_t Token )
{
   if( TokenUnput )
   {
      printf( "fatal error by f_TokenUnput\n" );
      exit( -1 );
   }
   TokenUnput = Token;
}

extern Param_t f_ParamCreate( void )
{
   Param_t Param = (Param_t) ckalloc( sizeof( sParam_t ));
   Token_t Token;

   Param->iToken = 0;
   Param->pToken = (Token_t *) ckalloc( 100 * sizeof( Token_t ));

   while( True )
   {
      int bContinue;

      Token = f_ParamToken( &bContinue );
      Param->pToken[Param->iToken++] = Token;
      if( ! bContinue )
      {
         break;
      }
   }

   return Param;
}

extern Token_t f_ParamToken( int *pbContinue )
{
   Token_t TokenReturn = 0;
   Token_t Token;
   int p = 0;
   int lex;

   while( True )
   {
      int macro;

      Token = f_TokenInput();
/*    if( iMacroCount && Token->lex == SN_IDENTIFIER ) 21.11.97 rigo */
      if( Token->lex == SN_IDENTIFIER )
      {
         sString_t sString = Token->sString;

         Token = f_TokenMacroInput( Token, &macro );
         if( Token == 0 )   /* Atlepjuk a macro-t. 25.11.97 rigo */
         {
            printf( "Token Skip: %*.*s\n", sString.leng, sString.leng, sString.text );
            continue;
         }
      }
      else
      {
         macro = False;
      }

      if( ! macro )
      {
         lex = Token->lex;

         if( p == 0 )
         {