cp_declaration.c

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

         }
         f_DeclaratorStrcat( pc, Declarator, 0 );
      }
   }
}

static List_t __InitDeclaratorList( Boolean_t may_function )
{
   Declarator_t Declarator;
   List_t List = 0;
   Save();

   if(( Declarator = f_InitDeclarator( may_function )))
   {
      if( token( 0 ) == ';' )
      {
         step( 1 );
         f_ListAddLast( &List, (Elem_t) Declarator );
         return List;
      }
      else if( token( 0 ) == ',' )
      {
         step( 1 );
         f_ListAddLast( &List, (Elem_t) Declarator );
         f_ListConcat( &List, f_InitDeclaratorList( may_function ));
         return List;
      }
      else if( CompAct == 0 && f_DeclaratorIsFunctionDefinition( Declarator ))
      {
         if( token( 0 ) == LBRACE )
         {
            f_CompoundStatement( 0, 0 );
            f_ListAddLast( &List, (Elem_t) Declarator );
            return List;
         }
         else if( token( 0 ) == ':' )
         {
            ctor_initializer();
            f_CompoundStatement( 0, 0 );
            f_ListAddLast( &List, (Elem_t) Declarator );
            return List;
         }
         else if( token( 0 ) == SN_RETURN )  /* csak a gnu c++ -ban */
         {
            Declarator_t DeclaratorReturn;

            step( 1 );
            if(( DeclaratorReturn = f_InitDeclarator( False )))
            {
               if( token( 0 ) == ';' ) step( 1 );
               f_CompoundStatement( 0, 0 );
               f_ListAddLast( &List, (Elem_t) Declarator );
               return List;
            }
            else
            {
               f_DeclaratorDestroy( Declarator );
               Restore();
               return 0;
            }
         }
         else
         {
            /* lehet, hogy old_style_function_definition */
            if( f_DeclaratorOldStyleFunctionDefinition( Declarator ))
            {
               f_DeclaratorOldStyleFunctionDefinitionProcess( Declarator );
               if( token( 0 ) == LBRACE )
               {
                  f_CompoundStatement( 0, 0 );
                  f_ListAddLast( &List, (Elem_t) Declarator );
                  return List;
               }
               else
               {
                  f_InternalError( 12 );
               }
            }
            f_DeclaratorDestroy( Declarator );
            Restore();
            return 0;
         }
      }
      else
      {
         f_DeclaratorDestroy( Declarator );
         Restore();
         return 0;
      }
   }
   else
   {
      Restore();
      return 0;
   }
}

static List_t __MemberDeclaratorList( void )
{
   Declarator_t Declarator;
   List_t List = 0;
   Save();

   if(( Declarator = f_MemberDeclarator()))
   {
      if( token( 0 ) == ';' )
      {
         step( 1 );
         f_ListAddLast( &List, (Elem_t) Declarator );
         return List;
      }
      else if( token( 0 ) == ',' )
      {
         step( 1 );
         f_ListAddLast( &List, (Elem_t) Declarator );
         f_ListConcat( &List, f_MemberDeclaratorList());
         return List;
      }
      else if( f_DeclaratorIsFunctionDefinition( Declarator ))
      {
         if( token( 0 ) == LBRACE )
         {
            f_CompoundStatement( 0, 0 );
            f_ListAddLast( &List, (Elem_t) Declarator );
            return List;
         }
         else if( token( 0 ) == ':' )
         {
            ctor_initializer();
            f_CompoundStatement( 0, 0 );
            f_ListAddLast( &List, (Elem_t) Declarator );
            return List;
         }
         else
         {
            f_DeclaratorDestroy( Declarator );
            Restore();
            return 0;
         }
      }
      else
      {
         f_DeclaratorDestroy( Declarator );
         Restore();
         return 0;
      }
   }
   else
   {
      Restore();
      return 0;
   }
}

static void ctor_initializer( void )
{
/*    printf( "ctor_initializer: %d.%d\n", f_lineno(0), f_charno(0)); */

   niveau++;
   while( True )
   {
      switch( token( 0 ))
      {
      case LBRACE:
         niveau--;
         return;
      case  0 : 
         niveau--;
         return;
      default :
         break;
      }
      step( 1 );
   }
}

static Boolean_t f_IsDeclarationStrange( Declaration_t Declaration )
{
   Declarator_t Declarator;

   for( Declarator = (Declarator_t) d_ElemFirst( Declaration->ListDeclarator )
      ; Declarator
      ; Declarator = Declarator->DeclaratorNext )
   {
      if( Declarator->bStrange ) return True;
   }

   return False;
}

static Boolean_t f_DeclaratorOldStyleFunctionDefinition( Declarator_t Declarator_a )
{
   Save();
   niveau++;

   if( ! f_DeclaratorHasParameterList( Declarator_a ))
   {
      niveau--;
      Restore();
      return False;
   }

   while( True )
   {
      Declaration_t Declaration;

      if( token( 0 ) == LBRACE )
      {
         niveau--;
         Restore();
         return True;
      }

      if( token( 0 ) == 0 )
      {
         niveau--;
         Restore();
         return False;
      }

      if(( Declaration = f_DeclarationObject( LEVEL_2 )))
      {
         Declarator_t Declarator;

         for( Declarator = (Declarator_t) d_ElemFirst( Declaration->ListDeclarator)
            ; Declarator
            ; Declarator = Declarator->DeclaratorNext )
         {
            Declaration_t DeclarationParameter;
            DeclarationParameter = f_DeclaratorFindParameter( Declarator_a, Declarator->Name->pcName );

            if( ! DeclarationParameter )
            {
               f_DeclarationDestroy( Declaration );
               niveau--;
               Restore();
               return False;
            }
         }
         f_DeclarationDestroy( Declaration );
      }
      else
      {
         niveau--;
         Restore();
         return False;
      }
   }
}

static void f_DeclaratorOldStyleFunctionDefinitionProcess( Declarator_t Declarator_a )
{
   niveau++;

   while( True )
   {
      Declaration_t Declaration;

      if( token( 0 ) == LBRACE )
      {
         niveau--;
         return;
      }

      if( token( 0 ) == 0 )
      {
         f_InternalError( 23 );
         niveau--;
         return;
      }

      if(( Declaration = f_DeclarationObject( LEVEL_2 )))
      {
         Declarator_t Declarator;
         Declarator_t DeclaratorNext;

         for( Declarator = (Declarator_t) d_ElemFirst( Declaration->ListDeclarator )
            ; Declarator
            ; Declarator = DeclaratorNext )
         {
            Declaration_t DeclarationParameter;
            DeclarationParameter = f_DeclaratorFindParameter( Declarator_a, Declarator->Name->pcName );

            if( ! DeclarationParameter )
            {
               f_InternalError( 25 );
               niveau--;
               return;
            }
            else
            {
               DeclaratorNext = Declarator->DeclaratorNext;
               f_ListRemoveFirst( Declaration->ListDeclarator );
               f_DeclarationCopy( DeclarationParameter, Declaration, Declarator );
            }
         }
         f_DeclarationDestroy( Declaration );
      }
      else
      {
         f_InternalError( 24 );
         niveau--;
         return;
      }
   }
}

static Boolean_t f_DeclaratorHasParameterList( Declarator_t Declarator )
{
   if( Declarator )
   {
      if( d_ElemFirst( Declarator->ListOper ))
      {
         Oper_t Oper = (Oper_t) d_ElemFirst( Declarator->ListOper );

         if( Oper->type == FUNCTION )
         {
            Declaration_t Declaration;

            for( Declaration = (Declaration_t) d_ElemFirst( Oper->ListDeclaration )
               ; Declaration
               ; Declaration = Declaration->DeclarationNext )
            {
               if( ! f_DeclarationIsParameter( Declaration ))
               {
                  return False;
               }
            }
            return True;
         }
      }
   }

   return False;
}

static Boolean_t f_DeclarationIsParameter( Declaration_t Declaration )
{
   if( Declaration->storage_class  ) return False;
   if( Declaration->fct_specifier  ) return False;
   if( Declaration->s_ellipsis     ) return False;
   if( Declaration->s_const        ) return False;
   if( Declaration->s_volatile     ) return False;
   if( Declaration->s_char         ) return False;
   if( Declaration->s_short        ) return False;
   if( Declaration->s_int          ) return False;
   if( Declaration->s_long         ) return False;
   if( Declaration->s_signed       ) return False;
   if( Declaration->s_unsigned     ) return False;
   if( Declaration->s_float        ) return False;
   if( Declaration->s_double       ) return False;
   if( Declaration->s_bool         ) return False;
   if( Declaration->s_void         ) return False;
   if( Declaration->Class          ) return False;
   if( Declaration->Enum           ) return False;
   if( Declaration->ListDeclarator ) return False;

   return True;
}

static Declaration_t f_DeclaratorFindParameter( Declarator_t Declarator, char *pcName )
{
   if( Declarator )
   {
      if( d_ElemFirst( Declarator->ListOper ))
      {
         Oper_t Oper = (Oper_t) d_ElemFirst( Declarator->ListOper );

         if( Oper->type == FUNCTION )
         {
            Declaration_t Declaration;
            for( Declaration = (Declaration_t) d_ElemFirst( Oper->ListDeclaration )
               ; Declaration
               ; Declaration = Declaration->DeclarationNext )
            {
               if( Declaration && Declaration->Name )
               {
                  if( strcmp( Declaration->Name->pcName, pcName ) == 0 )
                  {
                     return Declaration;
                  }
               }
            }
         }
      }
   }

   return 0;
}

static void f_DeclarationCopy( Declaration_t DeclarationDest, Declaration_t DeclarationSrc, Declarator_t DeclaratorSrc )
{
   if( DeclarationDest->ListDeclarator == 0 )
   {
      f_ListAddLast( &DeclarationDest->ListDeclarator, (Elem_t) DeclaratorSrc );

      DeclarationDest->storage_class = DeclarationSrc->storage_class;
      DeclarationDest->fct_specifier = DeclarationSrc->fct_specifier;
      DeclarationDest->s_ellipsis    = DeclarationSrc->s_ellipsis;
      DeclarationDest->s_const       = DeclarationSrc->s_const;
      DeclarationDest->s_volatile    = DeclarationSrc->s_volatile;
      DeclarationDest->s_char        = DeclarationSrc->s_char;
      DeclarationDest->s_short       = DeclarationSrc->s_short;
      DeclarationDest->s_int         = DeclarationSrc->s_int;
      DeclarationDest->s_long        = DeclarationSrc->s_long;
      DeclarationDest->s_signed      = DeclarationSrc->s_signed;
      DeclarationDest->s_unsigned    = DeclarationSrc->s_unsigned;
      DeclarationDest->s_float       = DeclarationSrc->s_float;
      DeclarationDest->s_double      = DeclarationSrc->s_double;
      DeclarationDest->s_bool        = DeclarationSrc->s_bool;
      DeclarationDest->s_void        = DeclarationSrc->s_void;
      DeclarationDest->Name          = DeclarationSrc->Name;
      DeclarationDest->Class         = DeclarationSrc->Class;
      DeclarationDest->Enum          = DeclarationSrc->Enum;

      DeclarationSrc->Name  = f_NameDup     ( DeclarationDest->Name  );
      DeclarationSrc->Class = f_ClassPoorDup( DeclarationDest->Class );
      DeclarationSrc->Enum  = f_EnumPoorDup ( DeclarationDest->Enum  );
   }
   else
   {
      f_DeclaratorDestroy( DeclaratorSrc );
   }
}

extern void f_DeclarationProcess( Declaration_t Declaration, int record )
{
   switch( Declaration->iType )
   {
      case DECLARATION_ASM                        :
      case DECLARATION_TEMPLATE                   :
      case DECLARATION_LINKAGE_SPECIFICATION      :
      case DECLARATION_NAMESPACE_DEFINITION       :
      case DECLARATION_NAMESPACE_ALIAS_DEFINITION :
      case DECLARATION_USING_DIRECTIVE            :
      case DECLARATION_USING                      :
         _DeclarationSpecialProcess((DeclarationSpecial_t) Declaration, record );
         return;
         break;

      case DECLARATION_OBJECT                     :
      case DECLARATION_MEMBER                     :
      case DECLARATION_ARGUMENT                   :
         _DeclarationProcess( Declaration, record );
         break;

      default:
         f_InternalError( 3 );
         break;
   }
}

static void _DeclarationProcess( Declaration_t Declaration, int record )
{
   Declarator_t Declarator;
   Declarator_t DeclaratorNext;
   Type_t Type;
   Type_t TypeBasic;
   Type_t TypeToDestroy = 0;

   TypeBasic = f_TypeFromDeclaration( Declaration );

   /* feloldjuk az esetleges typedef-eket */
   TypeBasic = f_TypeBasic( TypeBasic, Declaration->lineno );

   for( Declarator = (Declarator_t) d_ElemFirst( Declaration->ListDeclarator )
      ; Declarator
      ; Declarator = DeclaratorNext )
   {
      DeclaratorNext = Declarator->DeclaratorNext;

      if( record )
      {
         f_ListRemoveFirst( Declaration->ListDeclarator );

         Type = f_TypeDeclaratorConcat( TypeBasic, Declarator );

         f_PutConstructor( Type, Declaration->lineno, CONSTRUCTOR | DESTRUCTOR );

         if( test_fp )
         {
            fprintf( test_fp
                   ,"%d xref_l %d.%d %d.%d\n"
                   , PAF_HIGH
                   , Declarator->lineno_beg
                   , Declarator->charno_beg
                   , Declarator->lineno_end
                   , Declarator->charno_end
                   );
         }

         if( SymtabInsert( SymtabVariable
                         , Type->Declarator->Name->pcName
                         , (void *) Type
                         , niveauComp ))
         {
#ifdef SYMTAB_TRACE
            char acType[10000];  /* old: 1000 */

            f_TypeToString( Type, acType, 1 );
            printf( "recorded type: %s ----- name: %s\n"
                  , acType
                  , Declarator->Name->pcName
                  );
#endif
         }
         else
         {
            TypeToDestroy = Type;
         }
      }

      /* TODO or BUG:
              There is something wrong with the Declarator->Init part
	      of the expression failing to correctly parser:
	                  int foo;
              But has no problems correctly understanding:
	                  int foo = 1;
      */

      if( Declarator->Expr || Declarator->Init )   /* inicializalt valtozo */