extern Enum_t f_Enum( void )
{
Enum_t Enum;
Save();
niveau++;
if( token( 0 ) != SN_ENUM )
{
niveau--;
Restore();
return 0;
}
Enum = f_EnumCreate();
step( 1 );
if( token( 0 ) != LBRACE ) /* SN_IDENTIFIER or SN_NEW or ... */
{
Enum->Name = f_NameCreate( ident( 0 ));
step( 1 );
}
if( token( 0 ) == LBRACE )
{
// step( 1 ); //- MTP (bugfix -- skipped 1st enum)
Enum->ListEnumerator = f_EnumeratorList();
f_StepTo( RBRACE, 0 );
step( 1 );
}
niveau--;
return Enum;
}
static Enumerator_t f_Enumerator( void )
{
Enumerator_t Enumerator;
Save();
niveau++;
if( token( 0 ) == SN_IDENTIFIER )
{
Enumerator = f_EnumeratorCreate();
Enumerator->Name = f_NameCreate( ident( 0 ));
step( 1 );
if( token( 0 ) == '=' )
{
step( 1 );
Enumerator->Expr = f_ConstantExpression();
}
niveau--;
return Enumerator;
}
else
{
Restore();
niveau--;
return 0;
}
}
extern Type_t f_TypeFromDeclaration( Declaration_t Declaration )
{
Type_t Type = f_TypeCreate();
char *name;
if( Declaration->Name )
{
name = Declaration->Name->pcName;
}
else if( Declaration->Class )
{
if( Declaration->Class->Name )
name = Declaration->Class->Name->pcName;
else
name = 0;
}
else if( Declaration->Enum )
{
if( Declaration->Enum->Name )
name = Declaration->Enum->Name->pcName;
else
name = 0;
}
else
{
name = 0;
}
Type->fct_specifier = Declaration->fct_specifier;
Type->s_ellipsis = Declaration->s_ellipsis;
Type->s_const = Declaration->s_const;
Type->s_volatile = Declaration->s_volatile;
Type->s_char = Declaration->s_char;
Type->s_short = Declaration->s_short;
Type->s_int = Declaration->s_int;
Type->s_long = Declaration->s_long;
Type->s_signed = Declaration->s_signed;
Type->s_unsigned = Declaration->s_unsigned;
Type->s_float = Declaration->s_float;
Type->s_double = Declaration->s_double;
Type->s_bool = Declaration->s_bool;
Type->s_void = Declaration->s_void;
Type->Name = name ? f_NameCreate( name ) : 0;
Type->Class = 0;
Type->Enum = 0;
Type->Declarator = 0;
return Type;
}
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 );
}
}
}
extern Boolean_t f_CompoundStatement( char *types, char *names )
{
int retval;
/* printf( "Compund Statement: (%s) (%s)\n", types, names ); */
if( SymtabVariable == 0 )
{
SymtabVariable = SymtabCreate((void (*)(void*)) f_TypeDestroy );
}
if( SymtabClass == 0 )
{
SymtabClass = SymtabCreate((void (*)(void*)) f_ClassDestroy );
}
if( types && names )
{
/* feldolgozzuk a fuggveny argumentum listat */
char *my_types, *types_beg, *types_end;
char *my_names, *names_beg, *names_end;
int iBreak;
my_types = SN_StrDup( types );
my_names = SN_StrDup( names );
types_beg = my_types;
names_beg = my_names;
iBreak = False;
while( ! iBreak )
{
if(( types_end = my_strchr( types_beg, ',' ))) { *types_end = 0; }
else { iBreak = True; }
if(( names_end = my_strchr( names_beg, ',' ))) { *names_end = 0; }
else { iBreak = True; }
if( *names_beg && types_beg[0] != '.' )
{
Type_t Type;
Type = f_TypeFromString( types_beg );
if( Type == 0 )
{
/* 24.02.97 rigo */
/* int DEFUN(_IO_fflush, (fp), register _IO_FILE *fp ){} eseten elofordul */
/* f_InternalError( 61 ); */
Type = f_TypeCreateInt();
}
if( Type->Declarator == 0 )
{
Type->Declarator = f_DeclaratorCreate();
Type->Declarator->Name = f_NameCreate( names_beg );
}
else
{
if( Type->Declarator->Name )
{
f_InternalError( 62 );
}
else
{
Type->Declarator->Name = f_NameCreate( names_beg );
}
}
/* felodjuk az esetleges typedef-eket */
Type = f_TypeBasic( Type, start_lineno_g - 1 );
if( SymtabInsert( SymtabVariable
, Type->Declarator->Name->pcName
, (void *) Type
, niveauComp ))
{
#ifdef SYMTAB_TRACE
char acType[10000]; /* old: 1000 */
f_TypeToString( Type, acType, 1 );
printf( "argument type: %s ----- name: %s\n"
, acType
, Type->Declarator->Name->pcName
);
#endif
}
else
{
f_TypeDestroy( Type );
}
}
if( ! iBreak )
{
types_beg = types_end + 1;
names_beg = names_end + 1;
}
}
ckfree( my_names );
ckfree( my_types );
}
retval = compound_statement();
#ifdef SYMTAB_TRACE
printf( "vor Clear\n" );
SymtabPrint( SymtabVariable, 0 );
#endif
SymtabClear( SymtabVariable );
SymtabClear( SymtabClass );
#ifdef SYMTAB_TRACE
printf( "after Clear\n" );
SymtabPrint( SymtabVariable, 0 );
#endif
return retval;
}
