use dbuf for "_asm" definitions; my_unput() replaced by unput()

[fw/sdcc] / src / SDCC.y

diff --git a/src/SDCC.y b/src/SDCC.y
index 5847cbe78db16c5e367a4fdd63dc059e473b48dd..2ef823c93c0e07a1a29af9226af9f376b788dc58 100644 (file)
--- a/src/SDCC.y
+++ b/src/SDCC.y
@@ -66,12 +66,12 @@ bool uselessDecl = TRUE;
     symbol     *sym ;      /* symbol table pointer       */
     structdef  *sdef;      /* structure definition       */
     char       yychar[SDCC_NAME_MAX+1];
-    sym_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               */
-    char       *yyinline; /* inlined assembler code */
-    ast       *asts;     /* expression tree            */
+    const char *yyinline;  /* inlined assembler code     */
+    ast        *asts;      /* expression tree            */
 }
 
 %token <yychar> IDENTIFIER TYPE_NAME
@@ -550,7 +550,17 @@ storage_class_specifier
    ;
 
 Interrupt_storage
-   : INTERRUPT CONSTANT  { $$ = (int) floatFromVal($2) ;  }
+   : INTERRUPT { $$ = INTNO_UNSPEC ; }
+   | INTERRUPT CONSTANT
+        { int intno = (int) floatFromVal($2);
+          if ((intno >= 0) && (intno <= INTNO_MAX))
+            $$ = intno;
+          else
+            {
+              werror(E_INT_BAD_INTNO, intno);
+              $$ = INTNO_UNSPEC;
+            }
+        }
    ;
 
 type_specifier
@@ -778,13 +788,33 @@ struct_declarator_list
 
 struct_declarator
    : declarator 
-   | ':' constant_expr  {  
+   | ':' constant_expr  {
+                           int bitsize;
                            $$ = newSymbol (genSymName(NestLevel),NestLevel) ; 
-                           $$->bitVar = (int) floatFromVal(constExprValue($2,TRUE));
+                           bitsize= (int) floatFromVal(constExprValue($2,TRUE));
+                           if (bitsize > (port->s.int_size * 8)) {
+                             bitsize = port->s.int_size * 8;
+                             werror(E_BITFLD_SIZE, bitsize);
+                           }
+                           if (!bitsize)
+                             bitsize = BITVAR_PAD;
+                           $$->bitVar = bitsize;
                         }                        
    | declarator ':' constant_expr 
-                        { 
-                         $1->bitVar = (int) floatFromVal(constExprValue($3,TRUE));                     
+                        {
+                          int bitsize;
+                          bitsize= (int) floatFromVal(constExprValue($3,TRUE));
+                          if (bitsize > (port->s.int_size * 8)) {
+                            bitsize = port->s.int_size * 8;
+                            werror(E_BITFLD_SIZE, bitsize);
+                          }
+                          if (!bitsize) {
+                            $$ = newSymbol (genSymName(NestLevel),NestLevel) ; 
+                            $$->bitVar = BITVAR_PAD;
+                            werror(W_BITFLD_NAMED);
+                          }
+                         else
+                           $1->bitVar = bitsize;
                         }
    ;
 
@@ -898,22 +928,32 @@ declarator
 declarator2_function_attributes
    : declarator2                 { $$ = $1 ; } 
    | declarator2 function_attribute  { 
-       // copy the functionAttributes (not the args and hasVargs !!)
-       sym_link *funcType=$1->etype;
-       struct value *args=FUNC_ARGS(funcType);
-       unsigned hasVargs=FUNC_HASVARARGS(funcType);
-
-       memcpy (&funcType->funcAttrs, &$2->funcAttrs, 
-              sizeof($2->funcAttrs));
-
-       FUNC_ARGS(funcType)=args;
-       FUNC_HASVARARGS(funcType)=hasVargs;
-
-       // just to be sure
-       memset (&$2->funcAttrs, 0,
-              sizeof($2->funcAttrs));
-       
-       addDecl ($1,0,$2); 
+       if ((! $1) || (! IS_FUNC($1->etype)))
+         {
+           // function_attribute is only allowed if declarator2 was
+           // an actual function
+           werror(E_FUNC_ATTR);
+           $$=$1;
+         }
+       else
+         {
+           // copy the functionAttributes (not the args and hasVargs !!)
+           sym_link *funcType=$1->etype;
+           struct value *args=FUNC_ARGS(funcType);
+           unsigned hasVargs=FUNC_HASVARARGS(funcType);
+
+           memcpy (&funcType->funcAttrs, &$2->funcAttrs, 
+              sizeof($2->funcAttrs));
+
+           FUNC_ARGS(funcType)=args;
+           FUNC_HASVARARGS(funcType)=hasVargs;
+
+           // just to be sure
+           memset (&$2->funcAttrs, 0,
+              sizeof($2->funcAttrs));
+           
+           addDecl ($1,0,$2); 
+         }
    }     
    ;
 
@@ -987,6 +1027,8 @@ pointer
          {
             $$ = $1  ;         
             DCL_TSPEC($1) = $2;
+             DCL_PTR_CONST($1) = SPEC_CONST($2);
+             DCL_PTR_VOLATILE($1) = SPEC_VOLATILE($2);
         }
    | unqualified_pointer pointer         
          {
@@ -1014,7 +1056,6 @@ pointer
                     DCL_TYPE($3) = POINTER ;
                     break;
                 case S_CODE:
-                    DCL_PTR_CONST($3) = 1;
                     DCL_TYPE($3) = CPOINTER ;
                     break;
                 case S_EEPROM:
@@ -1123,7 +1164,10 @@ type_name
 abstract_declarator
    : pointer { $$ = reverseLink($1); }
    | abstract_declarator2
-   | pointer abstract_declarator2   { $1 = reverseLink($1); $1->next = $2 ; $$ = $1;} 
+   | pointer abstract_declarator2   { $1 = reverseLink($1); $1->next = $2 ; $$ = $1;
+         if (IS_PTR($1) && IS_FUNC($2))
+           DCL_TYPE($1) = CPOINTER;
+       } 
    ;
 
 abstract_declarator2
@@ -1167,22 +1211,21 @@ abstract_declarator2
      }
      $1->next=p;
    }
-   | abstract_declarator2 '(' parameter_type_list ')' {
-     if (!IS_VOID($3->etype)) {
-       // this is nonsense, so let's just burp something
-       werror(E_TOO_FEW_PARMS);
-     } else {
-       // $1 must be a pointer to a function
+   | abstract_declarator2 '(' { NestLevel++ ; currBlockno++; } parameter_type_list ')' {
        sym_link *p=newLink(DECLARATOR);
        DCL_TYPE(p) = FUNCTION;
-       if (!$1) {
-        // ((void (code *) (void)) 0) ()
-        $1=newLink(DECLARATOR);
-        DCL_TYPE($1)=CPOINTER;
-        $$ = $1;
-       }
-       $1->next=p;
-     }
+          
+       FUNC_HASVARARGS(p) = IS_VARG($4);
+       FUNC_ARGS(p) = reverseVal($4);
+            
+       /* nest level was incremented to take care of the parms  */
+       NestLevel-- ;
+       currBlockno--;
+       p->next = $1;
+       $$ = p;
+
+       // remove the symbol args (if any)
+       cleanUpLevel(SymbolTab,NestLevel+1);
    }
    ;