cplex.c

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

            if( lex == ',' )
            {
               *pbContinue = True;
               f_TokenFree( Token );
               return TokenReturn;
            }
            if( lex == ')' || lex == 0 )
            {
               *pbContinue = False;
               f_TokenFree( Token );
               return TokenReturn;
            }
         }
         /**/ if( lex == '(' ) p++;
         else if( lex == ')' ) p--;
      }

      f_TokenAppend( &TokenReturn, Token );
   }
}

extern void f_ParamFree( Param_t Param )
{
   int i;

   for( i = 0; i < Param->iToken; i++ )
   {
      Token_t Token = Param->pToken[i];
      f_TokenFreeAll( Token );
   }

   ckfree((char*) Param->pToken );
   ckfree((char*) Param );
}

extern Token_t f_ParameterPosition( Param_t Param, int position )
{
   if( position < Param->iToken )
   {
      return Param->pToken[position];
   }
   else
   {
      return 0;
   }
}

extern Token_t f_TokenMacroInput( Token_t Token, int *pmacro )
{
   Token_t TokenMerge;
   Token_t TokenNext;
   Macro_t Macro;
   Param_t Param;

   if(( Macro = f_MacroFind( Token->sString )))
   {
      *pmacro = True;

      if( Macro->typ == CPP_DEFINE )
      {
         TokenMerge = f_MacroMerge( Macro, Token, (Param_t) 0, True );
         f_TokenFree( Token );
         return TokenMerge;
      }
      else if( Macro->typ == CPP_MACRO )
      {
         TokenNext = f_TokenInput();
         if( TokenNext->lex == '(' )
         {
            f_TokenFree( TokenNext );
            Param = f_ParamCreate();
            TokenMerge = f_MacroMerge( Macro, Token, Param, True );
            f_TokenFree( Token );
            f_ParamFree( Param );
            return TokenMerge;
         }
         else
         {
            f_TokenUnput ( TokenNext );
            return Token;
         }
      }
      else  /* Macro->typ == CPP_UNDEF */
      {
         *pmacro = False;
         return Token;
      }
   }
   else
   {
      *pmacro = False;
      return Token;
   }
}

/* special f_TokenMacroInput() for #if and #elif, where after defined()
there is no macro substitute */
extern Token_t f_TokenSpecMacroInput( int *pmacro )
{
   Token_t TokenMerge;
   Token_t TokenNext;
   Macro_t Macro;
   Param_t Param;
   Token_t Token;

   Token = f_TokenInput();

   if( Token->lex == SN_IDENTIFIER )
   {
      if( f_StringCompare( Token->sString, "defined" ) == 0 )
      {
         int mode;
         Token_t TokenDefined;

         *pmacro = False;

         f_TokenFree( Token );
         Token = f_TokenInput();
         if( Token->lex == '(' )
         {
            f_TokenFree( Token );
            Token = f_TokenInput();
            mode = f_IsDefined( Token->sString );
            TokenDefined = Token;
            Token = f_TokenInput();
            f_TokenFree( Token );
         }
         else
         {
            mode = f_IsDefined( Token->sString );
            TokenDefined = Token;
         }
         if( mode == CPLEX_UNDEF )
         {
            TokenDefined->lex = SN_UNDEF;
         }
         else if( mode == CPLEX_TRUE )
         {
            TokenDefined->lex = SN_TRUE;
         }
         else  /* mode == CPLEX_FALSE */
         {
            TokenDefined->lex = SN_FALSE;
         }
         return TokenDefined;
      }
      else if(( Macro = f_MacroFind( Token->sString )))
      {
         *pmacro = True;

         if( Macro->typ == CPP_DEFINE )
         {
            TokenMerge = f_MacroMerge( Macro, Token, (Param_t) 0, True );
            f_TokenFree( Token );
            return TokenMerge;
         }
         else if( Macro->typ == CPP_MACRO )
         {
            TokenNext = f_TokenInput();
            if( TokenNext->lex == '(' )
            {
               f_TokenFree( TokenNext );
               Param = f_ParamCreate();
               TokenMerge = f_MacroMerge( Macro, Token, Param, True );
               f_TokenFree( Token );
               f_ParamFree( Param );
               return TokenMerge;
            }
            else
            {
               f_TokenUnput ( TokenNext );
               return Token;
            }
         }
         else /* Macro->typ == CPP_UNDEF */
         {
            *pmacro = False;
            return Token;
         }
      }
      else
      {
         *pmacro = False;
         return Token;
      }
   }
   else
   {
      *pmacro = False;
      return Token;
   }
}


extern Token_t __Preprocessor( void );
extern Token_t f_TokenReadToNewline( void );
extern void f_TokenSkipToNewline( void );
extern char *f_TokenSkipToNewlineByDefine( void );   /* 21.11.97 rigo */

extern Token_t f_Preprocessor( void )
{
   Token_t Token;
   int lex_mode_save = lex_mode;

   lex_mode = LEX_MODE_PP;
   Token = __Preprocessor();
   lex_mode = lex_mode_save;

   return Token;
}

extern Token_t __Preprocessor( void )
{
   Token_t Token;
   int mode;

   Token = f_TokenInput();

   if( f_StringCompare( Token->sString, "define" ) == 0 )
   {
      f_TokenFree( Token );
      Token = f_TokenInput();
      if( Token->lex == SN_IDENTIFIER )
      {
         Token->lex = SN_PP_DEFINE;
         Token->pcValue = f_TokenSkipToNewlineByDefine();   /* 21.11.97 rigo */
         return Token;
      }
      else
      {
         f_TokenFree( Token );
         f_TokenSkipToNewline();
         return 0;
      }
   }
   else if( f_StringCompare( Token->sString, "include" ) == 0 )
   {
      int lex_mode_save = lex_mode;

      f_TokenFree( Token );
      lex_mode = LEX_MODE_INCLUDE;
      Token = f_TokenInput();
      lex_mode = lex_mode_save;
      f_TokenSkipToNewline();
      if( Token->lex == SN_STRINGliteral )
      {
         Token->lex = SN_PP_INCLUDE;
         return Token;
      }
      else if( Token->lex == SN_INCLUDEliteral )
      {
         Token->lex = SN_PP_INCLUDE;
         return Token;
      }
      else
      {
         f_TokenFree( Token );
         return 0;
      }
   }
   else if( f_StringCompare( Token->sString, "if" ) == 0 )
   {
      f_TokenFree( Token );
      Token = f_TokenReadToNewline();
      mode = __ConstantExpression( Token );
      f_TokenFreeAll( Token );
      Token = f_TokenCreate();
      Token->lex = SN_PP_IF;
      Token->mode = mode;
      return Token;
   }
   else if( f_StringCompare( Token->sString, "ifdef" ) == 0 )
   {
      f_TokenFree( Token );
      Token = f_TokenInput();
      f_TokenSkipToNewline();
      mode = f_IsDefined( Token->sString );
      f_TokenFree( Token );
      Token = f_TokenCreate();
      Token->lex = SN_PP_IF;
      Token->mode = mode;
      return Token;
   }
   else if( f_StringCompare( Token->sString, "ifndef" ) == 0 )
   {
      f_TokenFree( Token );
      Token = f_TokenInput();
      f_TokenSkipToNewline();
      mode = f_IsDefined( Token->sString );
      f_TokenFree( Token );
      Token = f_TokenCreate();
      Token->lex = SN_PP_IF;
      /**/ if( mode == CPLEX_TRUE  ) Token->mode = CPLEX_FALSE;
      else if( mode == CPLEX_FALSE ) Token->mode = CPLEX_TRUE ;
      else                           Token->mode = CPLEX_UNDEF;
      return Token;
   }
   else if( f_StringCompare( Token->sString, "else" ) == 0 )
   {
      f_TokenFree( Token );
      f_TokenSkipToNewline();
      Token = f_TokenCreate();
      Token->lex = SN_PP_ELSE;
      return Token;
   }
   else if( f_StringCompare( Token->sString, "elif" ) == 0 )
   {
      f_TokenFree( Token );
      Token = f_TokenReadToNewline();
      mode = __ConstantExpression( Token );
      f_TokenFreeAll( Token );
      Token = f_TokenCreate();
      Token->lex = SN_PP_ELIF;
      Token->mode = mode;
      return Token;
   }
   else if( f_StringCompare( Token->sString, "endif" ) == 0 )
   {
      f_TokenFree( Token );
      f_TokenSkipToNewline();
      Token = f_TokenCreate();
      Token->lex = SN_PP_ENDIF;
      return Token;
   }
   else if( Token->lex == SN_NEWLINE )
   {
      f_TokenFree( Token );
      return 0;
   }
   else
   {
      f_TokenFree( Token );
      f_TokenSkipToNewline();
      return 0;
   }
}

extern Token_t f_TokenReadToNewline( void )
{
   Token_t TokenReturn = 0;
   Token_t Token;

   while( True )
   {
      int macro;

      Token = f_TokenSpecMacroInput( &macro );  /* spec process defined() */
      if( Token == 0 )   /* 24.11.97 rigo */
      {
         continue;
      }
      f_TokenAppend( &TokenReturn, Token );

      if( ! macro && ( Token->lex == SN_NEWLINE || Token->lex == 0 ))
      {
         return TokenReturn;
      }
   }
}

extern void f_TokenSkipToNewline( void )
{
   Token_t Token;
   int lex;

   while( True )
   {
      Token = f_TokenInput();
      lex = Token->lex;
      f_TokenFree( Token );

      if( lex == SN_NEWLINE || lex == 0 )
      {
         return;
      }
   }
}

extern char *f_TokenSkipToNewlineByDefine( void ) /* 21.11.97 rigo */
{
   Token_t Token;
   LongString lstr;
   int lex_last;

   LongStringInit( &lstr, -1 );

   Token = f_TokenInput();
   if(( Token->lex == SN_IDENTIFIER && Token->keyword == 0 ) || Token->lex == SN_CLCL )
   {
      lstr.append( &lstr, Token->sString.text, Token->sString.leng );
      lex_last = Token->lex;
      f_TokenFree( Token );

      while( True )
      {
         Token = f_TokenInput();
         if((( Token->lex == SN_IDENTIFIER && Token->keyword == 0 ) || Token->lex == SN_CLCL ) &&
              Token->lex != lex_last )
         {
            lstr.append( &lstr, Token->sString.text, Token->sString.leng );
            lex_last = Token->lex;
            f_TokenFree( Token );
         }
         else
         {
            if( Token->lex != SN_NEWLINE && Token->lex != 0 )
            {
               f_TokenSkipToNewline();
            }
            f_TokenFree( Token );
            return lstr.buf;
         }
      }
   }
   else
   {
      if( Token->lex != SN_NEWLINE && Token->lex != 0 )
      {
         f_TokenSkipToNewline();
      }
      f_TokenFree( Token );
      return 0;
   }
}

extern int f_IsDefined( sString_t sString )
{
   Macro_t Macro;

/* if(( Macro = f_MacroFind( sString ))) 27.11.97 rigo */
   if(( Macro = f_MacroFind( sString )) && Macro->paf_typ != PAF_WORD_REPLACE )
   {
      if( Macro->typ == CPP_UNDEF )
         return CPLEX_FALSE;
      else
         return CPLEX_TRUE;
   }
   else
   {
      return CPLEX_UNDEF;
   }
}

extern int f_StringCompare( sString_t sString, char *pc )
{
   char ac[1000];

   strncpy( ac, sString.text, sString.leng );
   ac[sString.leng] = 0;

   return strcmp( ac, pc );
}

extern void f_FileTokenPrint( Token_t Token )
{
   static int lineno = 0;
   static int charno = 0;
   static FILE *pfile;
   static int bFirst = True;

   if( bFirst )
   {
      bFirst = False;
      pfile = fopen( "macro.trace", "w+" );
      if( pfile == 0 )
      {
          pfile = stdout;
          perror( "malloc.trace" );
      }
   }

   WHILE_TOKEN( Token )

      unsigned char *text = Token->sString.text;
      int            leng = Token->sString.leng;

      if( Token->lineno_beg > lineno )
      {
         while( Token->lineno_beg > lineno )
         {
            fprintf( pfile, "\n" );
            lineno++;
            charno = 0;
         }
      }

      if( Token->lex == SN_PP_IF )
      {
         fprintf( pfile, "#if %d", Token->mode );
      }
      else if( Token->lex == SN_PP_ELIF )
      {
         fprintf( pfile, "#elif %d", Token->mode );
      }
      else if( Token->lex == SN_PP_ELSE )
      {
         fprintf( pfile, "#else" );
      }
      else if( Token->lex == SN_PP_ENDIF )
      {
         fprintf( pfile, "#endif" );
      }
      else if( Token->lex == SN_PP_DEFINE )
      {
         fprintf( pfile, "#define %*.*s"
               , Token->sString.leng
               , Token->sString.leng
               , Token->sString.text
               );
      }
      else if( Token->lex == SN_PP_INCLUDE )
      {
         fprintf( pfile, "#include %*.*s"
               , Token->sString.leng
               , Token->sString.leng
               , Token->sString.text
               );
      }
      else
      {
         fprintf( pfile, " " ); charno++; /* 15.01.97 rigo */

         if( Token->lineno_beg == lineno && Token->charno_beg > charno )
         {
            while( Token->charno_beg > charno )
            {
               fprintf( pfile, " " );
               charno++;
            }
         }

         charno += leng;

         while( leng-- )
         {
            fputc( *text++, pfile );
         }
      }

   END_WHILE
}

void
free_lex_buffers()
{
  Tcl_DStringFree(&yybuf);
}