cp_type.c

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

                  f_DeclaratorDestroy( Declarator );
               }
               return Type;
            }
         }
         break;

      case '*':
      case '&':
      case SN_CLCL:
      case '[':
      case '(':
         if( bFirst )
         {
#ifdef TEST
            f_InternalError( 55 );
#endif
            f_TypeDestroy( Type );
            return 0;
         }
         if(( Declarator = AbstractDeclarator()) == 0 )
         {
            f_InternalError( 56 );
            f_TypeDestroy( Type );
            return 0;
         }
         else
         {
            if( Type->Declarator == 0 )
            {
               Type->Declarator = Declarator;
            }
            else
            {
               f_DeclaratorDestroy( Declarator );
            }
         }
         return Type;

      default:
         if( bFirst )
         {
            f_TypeDestroy( Type );
            return 0;
         }
         return Type;
      }
   }
}

static Declarator_t AbstractDeclarator( void )
{
   Oper_t OperPointer;
   Declarator_t Declarator;
   List_t ListOper;

   TokenSave();

/* printf( "AbstractDeclartor: %s {%s}\n", TokenIdent( 0 ), pcLex ); */

   switch( Token( 0 ))
   {
   case '*':
   case '&':
   case SN_IDENTIFIER:
   case SN_CLCL:
      if(( OperPointer = PtrOperator()) == 0 )
      {
         return 0;
      }
      if(( Declarator = AbstractDeclarator()) == 0 )  /* 14.02.97 rigo */
      {
         Declarator = f_DeclaratorCreate();
      }
      f_ListAddLast( &Declarator->ListOper, (Elem_t) OperPointer );
      return Declarator;

   case '[':
      Declarator = f_DeclaratorCreate();
      Declarator->ListOper = FunctionOrArrayList();
      return Declarator;

   case '(':
      TokenStep( 1 );
      if( OperPointer = PtrOperator())
      {
         f_OperDestroy( OperPointer );
         TokenRestore();
         TokenStep( 1 );
         if( Declarator = AbstractDeclarator())
         {
            if( Token( 0 ) == ')' )
            {
               TokenStep( 1 );
               ListOper = FunctionOrArrayList();
               f_ListConcat( &Declarator->ListOper, ListOper );
               return Declarator;
            }
            else
            {
               TokenRestore();
               f_DeclaratorDestroy( Declarator );
               return 0;
            }
         }
         else
         {
            TokenRestore();
            return 0;
         }
      }
      else if( Token( 0 ) == '[' )  /* 06.03.97 rigo: Void (*([]))() miatt */
      {
         if( Declarator = AbstractDeclarator())
         {
            if( Token( 0 ) == ')' )
            {
               TokenStep( 1 );
               ListOper = FunctionOrArrayList();
               f_ListConcat( &Declarator->ListOper, ListOper );
               return Declarator;
            }
            else
            {
               TokenRestore();
               f_DeclaratorDestroy( Declarator );
               return 0;
            }
         }
         else
         {
            TokenRestore();
            return 0;
         }
      }
      else
      {
         TokenRestore();
         Declarator = f_DeclaratorCreate();
         Declarator->ListOper = FunctionOrArrayList();
         return Declarator;
      }

   default:
      return 0;
   }
}


static Oper_t PtrOperator( void )
{
   Oper_t Oper = f_OperCreate();
   TokenSave();

/* printf( "PtrOperator: %s\n", TokenIdent( 0 )); */

   switch( Token( 0 ))
   {
   case '*':
      Oper->type = POINTER_STAR;
      TokenStep( 1 );
      CvQualifierList( Oper );
      return Oper;

   case '&':
      Oper->type = POINTER_AMPERSAND;
      TokenStep( 1 );
      CvQualifierList( Oper );
      return Oper;

   case SN_IDENTIFIER:
   case SN_CLCL:
      Oper->Name = CompleteClassName();
      if( Token( 0 ) != SN_CLCL )
      {
         f_OperDestroy( Oper );
         return 0;
      }
      TokenStep( 1 );
      switch( Token( 0 ))
      {
      case '*':
         Oper->type = POINTER_STAR;
         TokenStep( 1 );
         CvQualifierList( Oper );
         return Oper;

      default:
         TokenRestore();
         f_OperDestroy( Oper );
         return 0;
      }
      
   default:
      TokenRestore();
      f_OperDestroy( Oper );
      return 0;
   }
}

static List_t FunctionOrArrayList( void )
{
   List_t ListOper = 0;
   Oper_t Oper;

   while( True )
   {
      switch( Token( 0 ))
      {
      case '[':
         TokenStep( 2 );
         Oper = f_OperCreate();
         Oper->type = ARRAY;
         f_ListAddLast( &ListOper, (Elem_t) Oper );
         break;

      case '(':
         TokenStep( 1 );
         Oper = f_OperCreate();
         Oper->type = FUNCTION;
         Oper->ListDeclaration = ArgumentDeclarationList();
         TokenStep( 1 );
         f_ListAddLast( &ListOper, (Elem_t) Oper );
         break;

      default:
         return ListOper;
      }
   }
}

static void CvQualifierList( Oper_t Oper )
{
   while( True )
   {
      switch( Token( 0 ))
      {
      case SN_CONST   : Oper->s_const    = True; break;
      case SN_VOLATILE: Oper->s_volatile = True; break;
      default      : return;
      }
      TokenStep( 1 );
   }
}

static Name_t CompleteClassName( void )
{
   char ac[10000];   /* old: 1000 */
   TokenSave();
   
   ac[0] = 0;

   if( Token( 0 ) == SN_CLCL )
   {
      f_Strcat( ac, "::" );
      TokenStep( 1 );
   }

   if( Token( 0 ) == SN_IDENTIFIER )
   {
      f_Strcat( ac, TokenIdent( 0 ));
      TokenStep( 1 );
      if( Token( 0 ) == '<' )
      {
         TemplateArgList( ac );
      }
   }
   else
   {
      TokenRestore();
      return 0;
   }

   while( True )
   {
/*    TokenSave(); */

      if( Token( 0 ) == SN_CLCL
       && Token( 1 ) == SN_IDENTIFIER )
      {
         f_Strcat( ac, "::" );
         f_Strcat( ac, TokenIdent( 1 ));
         TokenStep( 2 );
      }
      else
      {
         return f_NameCreate( ac );
      }
   }
}

static List_t ArgumentDeclarationList( void )
{
   List_t ListDeclaration = 0;
   Declaration_t Declaration;
   Type_t Type;

   while( True )
   {
      switch( Token( 0 ))
      {
      case SN_ELLIPSIS:
         TokenStep( 1 );
         Declaration = f_DeclarationCreate( DECLARATION_ARGUMENT );
         Declaration->s_ellipsis = True;
         f_ListAddLast( &ListDeclaration, (Elem_t) Declaration );
         return ListDeclaration;

      case ',':
         TokenStep( 1 );
         break;

      case ')':
         return ListDeclaration;

      default:
         Type = TypeName();
         if( Type == 0 )
         {
            Type = f_TypeCreateInt();
            while( True )
            {
               if( Token( 0 ) == ')' ) break;
               if( Token( 0 ) == ',' ) break;
               if( Token( 0 ) == SN_ELLIPSIS ) break;
               if( Token( 0 ) == 0   ) break;
               TokenStep( 1 );
            }
         }
         Declaration = f_TypeCastToDeclaration( Type );
         f_ListAddLast( &ListDeclaration, (Elem_t) Declaration );
         break;
      }
   }
}

/*************************************************************
**
**
**    Token processing
**
**
*************************************************************/

static void TokenInit( char *pc )
{
   iTokenA = 0;
   iTokenT = 0;
   pcLex = pc;
   pcLexBeg = pc;
}

static int Token( int i )
{
   return ((iTokenT<=iTokenA+(i)?TokenRead(i),0:0), asToken[(iTokenA+(i))].iToken);
}

static void TokenStep( int i )
{
   iTokenA += i;
}

static char *TokenIdent( int i )
{
   static char ac[10000];  /* old: 1000 */
   struct _sToken *psToken = asToken + (iTokenA+(i));

   if( iTokenT <= iTokenA + i )
   {
      TokenRead( i );
   }

   memcpy( ac, psToken->pcToken, psToken->iLength );

   ac[ psToken->iLength ] = 0;

   return ac;
}

static void TokenRead( int i )
{
   while( iTokenT <= iTokenA + i )
   {
      struct _sToken *psToken = asToken + (iTokenT);

      psToken->iToken = TokenLex();
      psToken->pcToken = pcToken;
      psToken->iLength = iLength;

      iTokenT++;
   }
}

#define input() (iLength++,(yychar=*pcLex++))
#define unput() (--iLength,(yychar=*--pcLex))

#include "cpkeyw.h"

static int TokenLex( void )
{
   int yychar;

   while( 1 )
   {
      pcToken = pcLex;
      iLength = 0;

      input();

      switch( yychar )
      {
      case 'a':
      case 'b':
      case 'c':
      case 'd':
      case 'e':
      case 'f':
      case 'g':
      case 'h':
      case 'i':
      case 'j':
      case 'k':
      case 'l':
      case 'm':
      case 'n':
      case 'o':
      case 'p':
      case 'q':
      case 'r':
      case 's':
      case 't':
      case 'u':
      case 'x':
      case 'y':
      case 'v':
      case 'w':
      case 'z':

      case 'A':
      case 'B':
      case 'C':
      case 'D':
      case 'E':
      case 'F':
      case 'G':
      case 'H':
      case 'I':
      case 'J':
      case 'K':
      case 'L':
      case 'M':
      case 'N':
      case 'O':
      case 'P':
      case 'Q':
      case 'R':
      case 'S':
      case 'T':
      case 'U':
      case 'X':
      case 'Y':
      case 'V':
      case 'W':
      case 'Z':

      case '_':

         {
            register int ihash = 0;
            register int j = 0;

            do
            {
               if( j++ < 6 && ihash < HASH_MAX )
               {
                  ihash += c_hash[ (int) yychar ];
               }
            }
            while( isalnum( input()) || yychar == '_' );

            unput();

            if( ihash < HASH_MAX &&
                LexKeyWordTab[ihash].leng == iLength &&
                strncmp( LexKeyWordTab[ihash].pcName, pcToken, iLength ) == 0 )
            {
               return LexKeyWordTab[ihash].wLexId; 
            }

            return SN_IDENTIFIER;
         }

      case ' ':
      case '\t':
      case '\r':
      case '\n':
         break;

      case ':':   /* :, :: */
         switch( input())
         {
         case ':':
            return SN_CLCL;
         default:
            unput();
            return ':';
         }

      case 0:
         unput();
         return 0;

      default:
         return yychar;
      }
   }
}

extern void f_Strcat( char *pc1, char *pc2 )
{
   register int len = strlen( pc1 );

   if( pc2[0] != 0 )
   {
      if( len > 0 )
      {
         register char c1;
         register char c2;

         c1 = pc1[len-1];
         c2 = pc2[    0];

         if(( isalnum( c1 ) || c1 == '_' || c1 == '$' ) &&
            ( c2 != '>' ))
         {
            strcat( pc1 + len, " " );
            len++;
         }
      }
      strcat( pc1 + len, pc2 );
   }
}

static void TemplateArgList( char *pname )
{
   int i = 1;

   TokenStep( 1 );
   strcat( pname, "<" );

   while( i > 0 )
   {
      switch( Token( 0 ))
      {
         case '>':
            i--;
            break;

         case '<':
            i++;
            break;

         case 0:
            f_InternalError( 71 );
            i = 0;
            break;
      }
      f_Strcat( pname, TokenIdent( 0 ));
      TokenStep( 1 );
   }

   return;
}

extern void f_TypeProcess( Type_t Type )
{
   if( Type )
   {
      if( Type->Declarator )
      {
         f_DeclaratorProcess( Type->Declarator );
      }
   }
}