macro.c

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

               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;
               }
               yycharprev = yychar;
            }
            break;

         case '/':   /* comment */
            while( input()) 
            {
               if( yychar == '\n' )
               {
                  break;
               }
            }
            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:
         break;
      }
   }
}

extern Token_t f_MacroMerge( Macro_t Macro, Token_t TokenBasic, Param_t Param, int bProcessed )
{
   Token_t TokenReturn = 0;
   Token_t Token;
   Token_t TokenMacro;

   if( bProcessed ) TokenMacro = Macro->TokenProcessed;
   else             TokenMacro = Macro->Token;

/*    f_MacroPrint( Macro ); */
/*    f_TokenPrint( TokenMacro ); */

   WHILE_TOKEN( TokenMacro )

      if( TokenMacro->iParameter >= 0 && Param )
      {
         Token_t TokenParameter;

         TokenParameter = f_ParameterPosition( Param, TokenMacro->iParameter );

         WHILE_TOKEN( TokenParameter )

            Token = f_TokenDuplicate( TokenParameter );
            f_TokenAppend( &TokenReturn, Token );
   
         END_WHILE
      }
      else
      {
         Token = f_TokenCreate();

         Token->lex        = TokenMacro->lex;
         Token->sString    = TokenMacro->sString;
         Token->keyword    = TokenMacro->keyword;       /* 15.01.97 rigo */
         Token->is_cpp     = TokenMacro->is_cpp;        /* 15.01.97 rigo */
         Token->lineno_beg = TokenBasic->lineno_beg;
         Token->charno_beg = TokenBasic->charno_beg;
         Token->lineno_end = TokenBasic->lineno_end;
         Token->charno_end = TokenBasic->charno_end;

         f_TokenAppend( &TokenReturn, Token );
      }

   END_WHILE

   return TokenReturn;
}

extern void f_MacroTokenPrint( Token_t Token )
{
   WHILE_TOKEN( Token )

#ifdef DETAIL
      printf( "%s [%d %d] %*.*s "
            , Token->TokenFreeNext == 0 ? "    " : "free"
            , Token
            , Token->sString.text
            , Token->sString.leng
            , Token->sString.leng
            , Token->sString.text
            );
#else
      unsigned char *text = Token->sString.text;
      int            leng = Token->sString.leng;

      printf( "%3d ", Token->lex );

      if( Token->lex == SN_PP_IF )
      {
         printf( "#if %d\n", Token->mode );
      }
      else if( Token->lex == SN_PP_ELIF )
      {
         printf( "#elif %d\n", Token->mode );
      }
      else if( Token->lex == SN_PP_ELSE )
      {
         printf( "#else\n" );
      }
      else if( Token->lex == SN_PP_ENDIF )
      {
         printf( "#endif\n" );
      }
      else if( Token->lex == SN_PP_DEFINE )
      {
         printf( "#define %*.*s\n"
               , Token->sString.leng
               , Token->sString.leng
               , Token->sString.text
               );
      }
      else if( Token->lex == SN_PP_INCLUDE )
      {
         printf( "#include %*.*s\n"
               , Token->sString.leng
               , Token->sString.leng
               , Token->sString.text
               );
      }
      else
      {
         while( leng-- )
         {
            putchar( *text++ );
         }
         putchar( '\n' );
      }

#endif

      if( Token->TokenFreeNext )
      {
         printf( "fatal error by f_MacroTokenPrint\n" );
         exit( -1 );
      }

   END_WHILE

   printf( "\n" );
}

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

extern void f_MacroAppend( Macro_t *pMacroBeg1, Macro_t MacroBeg2 )
{
   if( *pMacroBeg1 == 0 )
   {
      *pMacroBeg1 = MacroBeg2;
   }
   else
   {
      Macro_t MacroBeg1 = *pMacroBeg1;
      Macro_t MacroEnd1 = MacroBeg1->MacroPrev;
      Macro_t MacroEnd2 = MacroBeg2->MacroPrev;

      MacroBeg1->MacroPrev = MacroEnd2;
      MacroBeg2->MacroPrev = MacroEnd1;
      MacroEnd1->MacroNext = MacroBeg2;
      MacroEnd2->MacroNext = MacroBeg1;
   }
}

extern void f_MacroPrint( Macro_t Macro )
{
   if( Macro->typ == CPP_DEFINE )
   {
      printf( "#define %*.*s %s\n"
            , Macro->sStringName.leng
            , Macro->sStringName.leng
            , Macro->sStringName.text
            , Macro->macro ? Macro->macro : ""
            );
   }
   else if( Macro->typ == CPP_MACRO )
   {
      printf( "#define %*.*s( %s ) %s\n"
            , Macro->sStringName.leng
            , Macro->sStringName.leng
            , Macro->sStringName.text
            , Macro->parameter_list
            , Macro->macro ? Macro->macro : ""
            );
   }
   else /* Macro->typ == CPP_UNDEF */
   {
      printf( "#undef %*.*s\n"
            , Macro->sStringName.leng
            , Macro->sStringName.leng
            , Macro->sStringName.text
            );
   }
   
   __TokenPrint( Macro->Token );
   __TokenPrint( Macro->TokenProcessed );
}

extern void f_MacroFreeAll( void )
{
   iMacroCount = 0;

   if (pbtrMacro)
      (*pbtrMacro->destroy)( &pbtrMacro );
}

static void __TokenPrint( Token_t Token )
{
   WHILE_TOKEN( Token )

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

      while( leng-- )
      {
         putchar( *text++ );
      }

      putchar( ' ' );

   END_WHILE

   printf( "\n" );
}

static char *Strdup( char *pc )
{
   if( pc ) return SN_StrDup( pc );
   else     return NULL;
}

extern void f_TokenOnePrint( Token_t Token )
{
   unsigned char *text = Token->sString.text;
   int            leng = Token->sString.leng;

   printf( "\tToken: %3d ", Token->lex );

   if( Token->lex == SN_PP_IF )
   {
      printf( "#if %d\n", Token->mode );
   }
   else if( Token->lex == SN_PP_ELIF )
   {
      printf( "#elif %d\n", Token->mode );
   }
   else if( Token->lex == SN_PP_ELSE )
   {
      printf( "#else\n" );
   }
   else if( Token->lex == SN_PP_ENDIF )
   {
      printf( "#endif\n" );
   }
   else if( Token->lex == SN_PP_DEFINE )
   {
      printf( "#define %*.*s\n"
            , Token->sString.leng
            , Token->sString.leng
            , Token->sString.text
            );
   }
   else if( Token->lex == SN_PP_INCLUDE )
   {
      printf( "#include %*.*s\n"
            , Token->sString.leng
            , Token->sString.leng
            , Token->sString.text
            );
   }
   else
   {
      while( leng-- )
      {
         putchar( *text++ );
      }
      putchar( '\n' );
   }
}

static void FreeMacroEntry( SearchEntry *entry )
{
#if 0	/* Found macros will be removed at a different location.
		 * It means that the not found macros will cause a small
		 * memory leak. */
   Macro_t Macro = entry->data;
   f_MacroDestroy( Macro );
#endif
}