#include "SDCCmem.h"
#include "SDCCast.h"
#include "port.h"
+#include "newalloc.h"
+#include "SDCCerr.h"
extern int yyerror (char *);
extern FILE *yyin;
symbol *sym ; /* symbol table pointer */
structdef *sdef; /* structure definition */
char yychar[SDCC_NAME_MAX+1];
- link *lnk ; /* declarator or specifier */
+ sym_link *lnk ; /* declarator or specifier */
int yyint; /* integer value returned */
value *val ; /* for integer constant */
initList *ilist; /* initial list */
external_definition
: function_definition { blockNo=0;}
| declaration {
+ if ($1 && $1->type
+ && IS_FUNC($1->type))
+ {
+ /* The only legal storage classes for
+ * a function prototype (declaration)
+ * are extern and static. extern is the
+ * default. Thus, if this function isn't
+ * explicitly marked static, mark it
+ * extern.
+ */
+ if ($1->etype
+ && IS_SPEC($1->etype)
+ && !SPEC_STAT($1->etype))
+ {
+ SPEC_EXTR($1->etype) = 1;
+ }
+ }
addSymChain ($1);
allocVariables ($1) ;
cleanUpLevel (SymbolTab,1);
;
primary_expr
- : identifier { $$ = newAst(EX_VALUE,symbolVal($1)); }
- | CONSTANT { $$ = newAst(EX_VALUE,$1); }
+ : identifier { $$ = newAst_VALUE(symbolVal($1)); }
+ | CONSTANT { $$ = newAst_VALUE($1); }
| string_literal
| '(' expr ')' { $$ = $2 ; }
;
string_literal
- : STRING_LITERAL { $$ = newAst(EX_VALUE,$1); }
+ : STRING_LITERAL { $$ = newAst_VALUE($1); }
;
postfix_expr
{
$3 = newSymbol($3->name,NestLevel);
$3->implicit = 1;
- $$ = newNode(PTR_OP,newNode('&',$1,NULL),newAst(EX_VALUE,symbolVal($3)));
+ $$ = newNode(PTR_OP,newNode('&',$1,NULL),newAst_VALUE(symbolVal($3)));
/* $$ = newNode('.',$1,newAst(EX_VALUE,symbolVal($3))) ; */
}
| postfix_expr PTR_OP identifier
{
$3 = newSymbol($3->name,NestLevel);
$3->implicit = 1;
- $$ = newNode(PTR_OP,$1,newAst(EX_VALUE,symbolVal($3)));
+ $$ = newNode(PTR_OP,$1,newAst_VALUE(symbolVal($3)));
}
| postfix_expr INC_OP
{ $$ = newNode(INC_OP,$1,NULL);}
| DEC_OP unary_expr { $$ = newNode(DEC_OP,NULL,$2); }
| unary_operator cast_expr { $$ = newNode($1,$2,NULL) ; }
| SIZEOF unary_expr { $$ = newNode(SIZEOF,NULL,$2); }
- | SIZEOF '(' type_name ')' { $$ = newAst(EX_VALUE,sizeofOp($3)); }
+ | SIZEOF '(' type_name ')' { $$ = newAst_VALUE(sizeofOp($3)); }
;
unary_operator
cast_expr
: unary_expr
- | '(' type_name ')' cast_expr { $$ = newNode(CAST,newAst(EX_LINK,$2),$4); }
+ | '(' type_name ')' cast_expr { $$ = newNode(CAST,newAst_LINK($2),$4); }
;
multiplicative_expr
symbol *sym , *sym1;
for (sym1 = sym = reverseSyms($2);sym != NULL;sym = sym->next) {
- link *lnk = copyLinkChain($1);
+ sym_link *lnk = copyLinkChain($1);
/* do the pointer stuff */
pointerTypes(sym->type,lnk);
addDecl (sym,0,lnk) ;
/* if the decl $2 is not a specifier */
/* find the spec and replace it */
if ( !IS_SPEC($2)) {
- link *lnk = $2 ;
+ sym_link *lnk = $2 ;
while (lnk && !IS_SPEC(lnk->next))
lnk = lnk->next;
lnk->next = mergeSpec($1,lnk->next);
/* if the decl $2 is not a specifier */
/* find the spec and replace it */
if ( !IS_SPEC($2)) {
- link *lnk = $2 ;
+ sym_link *lnk = $2 ;
while (lnk && !IS_SPEC(lnk->next))
lnk = lnk->next;
lnk->next = mergeSpec($1,lnk->next);
| TYPE_NAME
{
symbol *sym;
- link *p ;
+ sym_link *p ;
sym = findSym(TypedefTab,NULL,$1) ;
$$ = p = copyLinkChain(sym->type);
| '(' declarator ')' { $$ = $2; }
| declarator2 '[' ']'
{
- link *p;
+ sym_link *p;
p = newLink ();
DCL_TYPE(p) = ARRAY ;
}
| declarator2 '[' constant_expr ']'
{
- link *p ;
+ sym_link *p ;
value *tval;
p = (tval = constExprValue($3,TRUE))->etype;
| type_specifier_list abstract_declarator
{
/* go to the end of the list */
- link *p;
+ sym_link *p;
pointerTypes($2,$1);
for ( p = $2 ; p->next ; p=p->next);
p->next = $1 ;
| jump_statement
| INLINEASM ';' {
ast *ex = newNode(INLINEASM,NULL,NULL);
- ALLOC_ATOMIC(ex->values.inlineasm,strlen($1));
+ ex->values.inlineasm = Safe_calloc(1,strlen($1)+1);
strcpy(ex->values.inlineasm,$1);
$$ = ex;
}
jump_statement
: GOTO identifier ';' {
$2->islbl = 1;
- $$ = newAst(EX_VALUE,symbolVal($2));
+ $$ = newAst_VALUE(symbolVal($2));
$$ = newNode(GOTO,$$,NULL);
}
| CONTINUE ';' {
$$ = NULL;
}
else {
- $$ = newAst(EX_VALUE,symbolVal(STACK_PEEK(continueStack)));
+ $$ = newAst_VALUE(symbolVal(STACK_PEEK(continueStack)));
$$ = newNode(GOTO,$$,NULL);
/* mark the continue label as referenced */
STACK_PEEK(continueStack)->isref = 1;
werror(E_BREAK_CONTEXT);
$$ = NULL;
} else {
- $$ = newAst(EX_VALUE,symbolVal(STACK_PEEK(breakStack)));
+ $$ = newAst_VALUE(symbolVal(STACK_PEEK(breakStack)));
$$ = newNode(GOTO,$$,NULL);
STACK_PEEK(breakStack)->isref = 1;
}