Fixed initializer problem & added debug printing routine

for AST

git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@662 4a8a32a2-be11-0410-ad9d-d568d2c75423

diff --git a/src/SDCCast.c b/src/SDCCast.c
index c76148afb9c645fc89af68abaace70ec8418c85f..d75e2d97a05d57356ea844fa62d78a5cfcb468f4 100644 (file)
--- a/src/SDCCast.c
+++ b/src/SDCCast.c
@@ -4135,3 +4135,653 @@ skipall:
   istack->syms = NULL;
   return NULL;
 }
+
+
+#define INDENT(x,f) { int i ; for (i=0;i < x; i++) fprintf(f," "); }
+/*-----------------------------------------------------------------*/
+/* ast_print : prints the ast (for debugging purposes)             */
+/*-----------------------------------------------------------------*/
+
+void ast_print (ast * tree, FILE *outfile, int indent)
+{
+       
+       if (!tree) return ;
+
+       /* can print only decorated trees */
+       if (!tree->decorated) return;
+
+       /* if any child is an error | this one is an error do nothing */
+       if (tree->isError ||
+           (tree->left && tree->left->isError) ||
+           (tree->right && tree->right->isError)) {
+               fprintf(outfile,"ERROR_NODE(%p)\n",tree);
+       }
+
+       
+       INDENT(indent,outfile);
+
+       /* print the line          */
+       /* if not block & function */
+       if (tree->type == EX_OP &&
+           (tree->opval.op != FUNCTION &&
+            tree->opval.op != BLOCK &&
+            tree->opval.op != NULLOP)) {
+       }
+       
+       if (tree->opval.op == FUNCTION) {
+               fprintf(outfile,"FUNCTION (%p) type (",tree);
+               printTypeChain (tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+       }
+       if (tree->opval.op == BLOCK) {
+               symbol *decls = tree->values.sym;
+               fprintf(outfile,"{\n");
+               while (decls) {
+                       INDENT(indent+4,outfile);
+                       fprintf(outfile,"DECLARE SYMBOL %s, type(",decls->name);
+                       printTypeChain(decls->type,outfile);
+                       fprintf(outfile,")\n");
+                       
+                       decls = decls->next;                    
+               }
+               ast_print(tree->right,outfile,indent+4);
+               return;
+       }
+       if (tree->opval.op == NULLOP) {
+               ast_print(tree->left,outfile,indent);
+               ast_print(tree->right,outfile,indent);
+               return ;
+       }
+
+       /*------------------------------------------------------------------*/
+       /*----------------------------*/
+       /*   leaf has been reached    */
+       /*----------------------------*/
+       /* if this is of type value */
+       /* just get the type        */
+       if (tree->type == EX_VALUE) {
+
+               if (IS_LITERAL (tree->opval.val->etype)) {                      
+                       fprintf(outfile,"CONSTANT (%p) value = %d, 0x%x, %g", tree,
+                               (int) floatFromVal(tree->opval.val),
+                               (int) floatFromVal(tree->opval.val),
+                               floatFromVal(tree->opval.val));
+               } else if (tree->opval.val->sym) {
+                       /* if the undefined flag is set then give error message */
+                       if (tree->opval.val->sym->undefined) {
+                               fprintf(outfile,"UNDEFINED SYMBOL ");
+                       } else {
+                               fprintf(outfile,"SYMBOL ");
+                       }
+                       fprintf(outfile,"(%p) name= %s ",tree,tree->opval.val->sym->name);
+               }
+               if (tree->ftype) {
+                       fprintf(outfile," type (");
+                       printTypeChain(tree->ftype,outfile);
+                       fprintf(outfile,")\n");
+               }
+               return ;
+       }
+
+       /* if type link for the case of cast */
+       if (tree->type == EX_LINK) {
+               fprintf(outfile,"TYPENODE (%p) type = (",tree);
+               printTypeChain(tree->opval.lnk,outfile);
+               fprintf(outfile,")\n");
+               return ;
+       }
+
+
+       /* depending on type of operator do */
+       
+       switch (tree->opval.op) {
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*        array node          */
+               /*----------------------------*/
+       case '[':
+               fprintf(outfile,"ARRAY_OP (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;
+
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*      struct/union          */
+               /*----------------------------*/
+       case '.':
+               fprintf(outfile,"STRUCT_ACCESS (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*    struct/union pointer    */
+               /*----------------------------*/
+       case PTR_OP:
+               fprintf(outfile,"PTR_ACCESS (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*  ++/-- operation           */
+               /*----------------------------*/
+       case INC_OP:            /* incerement operator unary so left only */
+               fprintf(outfile,"INC_OP (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               return ;
+
+       case DEC_OP:
+               fprintf(outfile,"DEC_OP (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               return ;
+
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*  bitwise and               */
+               /*----------------------------*/
+       case '&':                       
+               if (tree->right) {
+                       fprintf(outfile,"& (%p) type (",tree);
+                       printTypeChain(tree->ftype,outfile);
+                       fprintf(outfile,")\n");
+                       ast_print(tree->left,outfile,indent+4);
+                       ast_print(tree->right,outfile,indent+4);
+               } else {
+                       fprintf(outfile,"ADDRESS_OF (%p) type (",tree);
+                       printTypeChain(tree->ftype,outfile);
+                       fprintf(outfile,")\n");
+                       ast_print(tree->left,outfile,indent+4);
+                       ast_print(tree->right,outfile,indent+4);
+               }
+               return ;
+               /*----------------------------*/
+               /*  bitwise or                */
+               /*----------------------------*/
+       case '|':
+               fprintf(outfile,"OR (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*  bitwise xor               */
+               /*----------------------------*/
+       case '^':
+               fprintf(outfile,"XOR (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+               
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*  division                  */
+               /*----------------------------*/
+       case '/':
+               fprintf(outfile,"DIV (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*            modulus         */
+               /*----------------------------*/
+       case '%':
+               fprintf(outfile,"MOD (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*  address dereference       */
+               /*----------------------------*/
+       case '*':                       /* can be unary  : if right is null then unary operation */
+               if (!tree->right) {
+                       fprintf(outfile,"DEREF (%p) type (",tree);
+                       printTypeChain(tree->ftype,outfile);
+                       fprintf(outfile,")\n");
+                       ast_print(tree->left,outfile,indent+4);
+                       return ;
+               }                       
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*      multiplication        */
+               /*----------------------------*/                
+               fprintf(outfile,"MULT (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+
+
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*    unary '+' operator      */
+               /*----------------------------*/
+       case '+':
+               /* if unary plus */
+               if (!tree->right) {
+                       fprintf(outfile,"UPLUS (%p) type (",tree);
+                       printTypeChain(tree->ftype,outfile);
+                       fprintf(outfile,")\n");
+                       ast_print(tree->left,outfile,indent+4);
+               } else {
+                       /*------------------------------------------------------------------*/
+                       /*----------------------------*/
+                       /*      addition              */
+                       /*----------------------------*/
+                       fprintf(outfile,"ADD (%p) type (",tree);
+                       printTypeChain(tree->ftype,outfile);
+                       fprintf(outfile,")\n");
+                       ast_print(tree->left,outfile,indent+4);
+                       ast_print(tree->right,outfile,indent+4);
+               }
+               return;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*      unary '-'             */
+               /*----------------------------*/
+       case '-':                       /* can be unary   */
+               if (!tree->right) {
+                       fprintf(outfile,"UMINUS (%p) type (",tree);
+                       printTypeChain(tree->ftype,outfile);
+                       fprintf(outfile,")\n");
+                       ast_print(tree->left,outfile,indent+4);
+               } else {
+                       /*------------------------------------------------------------------*/
+                       /*----------------------------*/
+                       /*      subtraction           */
+                       /*----------------------------*/
+                       fprintf(outfile,"SUB (%p) type (",tree);
+                       printTypeChain(tree->ftype,outfile);
+                       fprintf(outfile,")\n");
+                       ast_print(tree->left,outfile,indent+4);
+                       ast_print(tree->right,outfile,indent+4);
+               }
+               return;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*    compliment              */
+               /*----------------------------*/
+       case '~':
+               fprintf(outfile,"COMPL (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               return ;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*           not              */
+               /*----------------------------*/
+       case '!':
+               fprintf(outfile,"NOT (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               return ;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*           shift            */
+               /*----------------------------*/
+       case RRC:
+               fprintf(outfile,"RRC (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               return ;
+
+       case RLC:
+               fprintf(outfile,"RLC (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               return ;
+       case GETHBIT:
+               fprintf(outfile,"GETHBIT (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               return ;
+       case LEFT_OP:
+               fprintf(outfile,"LEFT_SHIFT (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+       case RIGHT_OP:
+               fprintf(outfile,"RIGHT_SHIFT (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*         casting            */
+               /*----------------------------*/
+       case CAST:                      /* change the type   */
+               fprintf(outfile,"CAST (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+               
+       case AND_OP:
+               fprintf(outfile,"ANDAND (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+       case OR_OP:
+               fprintf(outfile,"OROR (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+               
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*     comparison operators   */
+               /*----------------------------*/
+       case '>':
+               fprintf(outfile,"GT(>) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+       case '<':
+               fprintf(outfile,"LT(<) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+       case LE_OP:
+               fprintf(outfile,"LE(<=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+       case GE_OP:
+               fprintf(outfile,"GE(>=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+       case EQ_OP:
+               fprintf(outfile,"EQ(==) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+       case NE_OP:
+               fprintf(outfile,"NE(!=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*             sizeof         */
+               /*----------------------------*/
+       case SIZEOF:            /* evaluate wihout code generation */
+               fprintf(outfile,"SIZEOF %d\n",(getSize (tree->right->ftype)));
+               return ;
+
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /* conditional operator  '?'  */
+               /*----------------------------*/
+       case '?':
+               fprintf(outfile,"QUEST(?) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+
+       case ':':
+               fprintf(outfile,"COLON(:) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return ;
+               
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*    assignment operators    */
+               /*----------------------------*/
+       case MUL_ASSIGN:
+               fprintf(outfile,"MULASS(*=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;
+       case DIV_ASSIGN:
+               fprintf(outfile,"DIVASS(/=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;
+       case AND_ASSIGN:
+               fprintf(outfile,"ANDASS(&=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;
+       case OR_ASSIGN:
+               fprintf(outfile,"ORASS(*=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;
+       case XOR_ASSIGN:
+               fprintf(outfile,"XORASS(*=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;
+       case RIGHT_ASSIGN:
+               fprintf(outfile,"RSHFTASS(>>=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;
+       case LEFT_ASSIGN:
+               fprintf(outfile,"LSHFTASS(*=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*    -= operator             */
+               /*----------------------------*/
+       case SUB_ASSIGN:
+               fprintf(outfile,"SUBASS(-=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*          += operator       */
+               /*----------------------------*/
+       case ADD_ASSIGN:
+               fprintf(outfile,"ADDASS(+=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*      straight assignemnt   */
+               /*----------------------------*/
+       case '=':
+               fprintf(outfile,"ASSIGN(=) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;     
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*      comma operator        */
+               /*----------------------------*/
+       case ',':
+               fprintf(outfile,"COMMA(,) (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*       function call        */
+               /*----------------------------*/
+       case CALL:
+       case PCALL:
+               fprintf(outfile,"CALL (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent+4);
+               return;
+       case PARAM:
+               fprintf(outfile,"PARM ");
+               ast_print(tree->left,outfile,indent+4);
+               if (tree->right && !IS_AST_PARAM(tree->right)) {
+                       fprintf(outfile,"PARM ");
+                       ast_print(tree->right,outfile,indent+4);
+               }
+               return ;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*     return statement       */
+               /*----------------------------*/
+       case RETURN:
+               fprintf(outfile,"RETURN (%p) type (",tree);
+               printTypeChain(tree->ftype,outfile);
+               fprintf(outfile,")\n");
+               ast_print(tree->left,outfile,indent+4);
+               return ;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*     label statement        */
+               /*----------------------------*/
+       case LABEL :
+               fprintf(outfile,"LABEL (%p)",tree);
+               ast_print(tree->left,outfile,indent+4);
+               ast_print(tree->right,outfile,indent);
+               return;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /*     switch statement       */
+               /*----------------------------*/
+       case SWITCH:
+               {
+                       value *val;
+                       fprintf(outfile,"SWITCH (%p) ",tree);
+                       ast_print(tree->left,outfile,0);
+                       for (val = tree->values.switchVals.swVals; val ; val = val->next) {
+                               INDENT(indent+4,outfile);
+                               fprintf(outfile,"CASE 0x%x GOTO _case_%d_%d\n",
+                                       (int) floatFromVal(val),
+                                       tree->values.switchVals.swNum,
+                                       (int) floatFromVal(val));
+                       }
+                       ast_print(tree->right,outfile,indent);
+               }
+               return ;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /* ifx Statement              */
+               /*----------------------------*/
+       case IFX:
+               fprintf(outfile,"IF (%p) \n",tree);
+               ast_print(tree->left,outfile,indent+4);
+               if (tree->trueLabel) {
+                       INDENT(indent,outfile);
+                       fprintf(outfile,"NE(==) 0 goto %s\n",tree->trueLabel->name);
+               }
+               if (tree->falseLabel) {
+                       INDENT(indent,outfile);
+                       fprintf(outfile,"EQ(==) 0 goto %s\n",tree->falseLabel->name);
+               }
+               ast_print(tree->right,outfile,indent);
+               return ;
+               /*------------------------------------------------------------------*/
+               /*----------------------------*/
+               /* for Statement              */
+               /*----------------------------*/
+       case FOR:
+               fprintf(outfile,"FOR (%p) \n",tree);
+               if (AST_FOR( tree, initExpr)) {
+                       INDENT(indent+4,outfile);
+                       fprintf(outfile,"INIT EXPR ");
+                       ast_print(AST_FOR(tree, initExpr),outfile,indent+4);
+               }
+               if (AST_FOR( tree, condExpr)) {
+                       INDENT(indent+4,outfile);
+                       fprintf(outfile,"COND EXPR ");
+                       ast_print(AST_FOR(tree, condExpr),outfile,indent+4);
+               }
+               if (AST_FOR( tree, loopExpr)) {
+                       INDENT(indent+4,outfile);
+                       fprintf(outfile,"LOOP EXPR ");
+                       ast_print(AST_FOR(tree, loopExpr),outfile,indent+4);
+               }
+               fprintf(outfile,"FOR LOOP BODY \n");
+               ast_print(tree->left,outfile,indent+4);
+               return ;
+       default:
+           return ;
+       }
+}
+
+void PA(ast *t)
+{
+       ast_print(t,stdout,1);
+}

diff --git a/src/SDCCast.h b/src/SDCCast.h
index 5d306632893913cbce0be9104b2c1b4526a7bdf2..a6ddbfb9fe3cf135119ecfcf9e1ab814a9f78124 100644 (file)
--- a/src/SDCCast.h
+++ b/src/SDCCast.h
@@ -141,6 +141,7 @@ ast;
 #define AST_VALUE(x)            (x->opval.val)
 #define AST_VALUES(x,y)        (x->values.y)
 #define AST_FOR(x,y) x->values.forVals.y
+#define  IS_AST_PARAM(x)       (IS_AST_OP(x) && x->opval.op == PARAM)
 
 #define  CAN_EVAL(x)   (     x ==  '[' || x == '.' || x == PTR_OP ||   \
              x ==  '&' || x == '|' || x == '^'    || x == '*' || \

diff --git a/src/SDCCglue.c b/src/SDCCglue.c
index 3ac3ddb4d3c99cb14287bee1c3603ad318c275b4..c2fea95f8db60af23fb62ce15a1ddcbbc4ff1c88 100644 (file)
--- a/src/SDCCglue.c
+++ b/src/SDCCglue.c
@@ -276,86 +276,105 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag)
 value *
 initPointer (initList * ilist)
 {
-  value *val;
-  ast *expr = list2expr (ilist);
-
-  if (!expr)
-    goto wrong;
+       value *val;
+       ast *expr = list2expr (ilist);
+       
+       if (!expr)
+               goto wrong;
+       
+       /* try it the oldway first */
+       if ((val = constExprValue (expr, FALSE)))
+               return val;
+       
+       /* no then we have to do these cludgy checks */
+       /* pointers can be initialized with address of
+          a variable or address of an array element */
+       if (IS_AST_OP (expr) && expr->opval.op == '&') {
+               /* address of symbol */
+               if (IS_AST_SYM_VALUE (expr->left)) {
+                       val = copyValue (AST_VALUE (expr->left));
+                       val->type = newLink ();
+                       if (SPEC_SCLS (expr->left->etype) == S_CODE) {
+                               DCL_TYPE (val->type) = CPOINTER;
+                               DCL_PTR_CONST (val->type) = port->mem.code_ro;
+                       }
+                       else if (SPEC_SCLS (expr->left->etype) == S_XDATA)
+                               DCL_TYPE (val->type) = FPOINTER;
+                       else if (SPEC_SCLS (expr->left->etype) == S_XSTACK)
+                               DCL_TYPE (val->type) = PPOINTER;
+                       else if (SPEC_SCLS (expr->left->etype) == S_IDATA)
+                               DCL_TYPE (val->type) = IPOINTER;
+                       else if (SPEC_SCLS (expr->left->etype) == S_EEPROM)
+                               DCL_TYPE (val->type) = EEPPOINTER;
+                       else
+                               DCL_TYPE (val->type) = POINTER;
+                       val->type->next = expr->left->ftype;
+                       val->etype = getSpec (val->type);
+                       return val;
+               }
 
-  /* try it the oldway first */
-  if ((val = constExprValue (expr, FALSE)))
-    return val;
+               /* if address of indexed array */
+               if (IS_AST_OP (expr->left) && expr->left->opval.op == '[')
+                       return valForArray (expr->left);
 
-  /* no then we have to do these cludgy checks */
-  /* pointers can be initialized with address of
-     a variable or address of an array element */
-  if (IS_AST_OP (expr) && expr->opval.op == '&')
-    {
-      /* address of symbol */
-      if (IS_AST_SYM_VALUE (expr->left))
-       {
-         val = copyValue (AST_VALUE (expr->left));
-         val->type = newLink ();
-         if (SPEC_SCLS (expr->left->etype) == S_CODE)
-           {
-             DCL_TYPE (val->type) = CPOINTER;
-             DCL_PTR_CONST (val->type) = port->mem.code_ro;
-           }
-         else if (SPEC_SCLS (expr->left->etype) == S_XDATA)
-           DCL_TYPE (val->type) = FPOINTER;
-         else if (SPEC_SCLS (expr->left->etype) == S_XSTACK)
-           DCL_TYPE (val->type) = PPOINTER;
-         else if (SPEC_SCLS (expr->left->etype) == S_IDATA)
-           DCL_TYPE (val->type) = IPOINTER;
-         else if (SPEC_SCLS (expr->left->etype) == S_EEPROM)
-           DCL_TYPE (val->type) = EEPPOINTER;
-         else
-           DCL_TYPE (val->type) = POINTER;
-         val->type->next = expr->left->ftype;
-         val->etype = getSpec (val->type);
-         return val;
-       }
+               /* if address of structure element then
+                  case 1. a.b ; */
+               if (IS_AST_OP (expr->left) &&
+                   expr->left->opval.op == '.') {
+                       return valForStructElem (expr->left->left,
+                                                expr->left->right);
+               }
 
-      /* if address of indexed array */
-      if (IS_AST_OP (expr->left) && expr->left->opval.op == '[')
-       return valForArray (expr->left);
+               /* case 2. (&a)->b ;
+                  (&some_struct)->element */
+               if (IS_AST_OP (expr->left) &&
+                   expr->left->opval.op == PTR_OP &&
+                   IS_ADDRESS_OF_OP (expr->left->left))
+                       return valForStructElem (expr->left->left->left,
+                                                expr->left->right);
 
-      /* if address of structure element then
-         case 1. a.b ; */
-      if (IS_AST_OP (expr->left) &&
-         expr->left->opval.op == '.')
-       {
-         return valForStructElem (expr->left->left,
-                                  expr->left->right);
        }
+       /* case 3. (((char *) &a) +/- constant) */
+       if (IS_AST_OP (expr) &&
+           (expr->opval.op == '+' || expr->opval.op == '-') &&
+           IS_AST_OP (expr->left) && expr->left->opval.op == CAST &&
+           IS_AST_OP (expr->left->right) &&
+           expr->left->right->opval.op == '&' &&
+           IS_AST_LIT_VALUE (expr->right)) {
+
+               return valForCastAggr (expr->left->right->left,
+                                      expr->left->left->opval.lnk,
+                                      expr->right, expr->opval.op);
 
-      /* case 2. (&a)->b ;
-         (&some_struct)->element */
-      if (IS_AST_OP (expr->left) &&
-         expr->left->opval.op == PTR_OP &&
-         IS_ADDRESS_OF_OP (expr->left->left))
-       return valForStructElem (expr->left->left->left,
-                                expr->left->right);
-
-    }
-  /* case 3. (((char *) &a) +/- constant) */
-  if (IS_AST_OP (expr) &&
-      (expr->opval.op == '+' || expr->opval.op == '-') &&
-      IS_AST_OP (expr->left) && expr->left->opval.op == CAST &&
-      IS_AST_OP (expr->left->right) &&
-      expr->left->right->opval.op == '&' &&
-      IS_AST_LIT_VALUE (expr->right))
-    {
-
-      return valForCastAggr (expr->left->right->left,
-                            expr->left->left->opval.lnk,
-                            expr->right, expr->opval.op);
-
-    }
-
-wrong:
-  werror (E_INIT_WRONG);
-  return NULL;
+       }
+       
+       /* case 4. (char *)(array type) */
+       if (IS_CAST_OP(expr) && IS_AST_SYM_VALUE (expr->right) &&
+           IS_ARRAY(expr->right->ftype)) {
+
+               val = copyValue (AST_VALUE (expr->right));
+               val->type = newLink ();
+               if (SPEC_SCLS (expr->right->etype) == S_CODE) {
+                       DCL_TYPE (val->type) = CPOINTER;
+                       DCL_PTR_CONST (val->type) = port->mem.code_ro;
+               }
+               else if (SPEC_SCLS (expr->right->etype) == S_XDATA)
+                       DCL_TYPE (val->type) = FPOINTER;
+               else if (SPEC_SCLS (expr->right->etype) == S_XSTACK)
+                       DCL_TYPE (val->type) = PPOINTER;
+               else if (SPEC_SCLS (expr->right->etype) == S_IDATA)
+                       DCL_TYPE (val->type) = IPOINTER;
+               else if (SPEC_SCLS (expr->right->etype) == S_EEPROM)
+                       DCL_TYPE (val->type) = EEPPOINTER;
+               else
+                       DCL_TYPE (val->type) = POINTER;
+               val->type->next = expr->right->ftype->next;
+               val->etype = getSpec (val->type);
+               return val;
+       }
+ wrong:
+       werror (E_INIT_WRONG);
+       return NULL;
 
 }
 
@@ -831,7 +850,7 @@ printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile)
       return;
 
   /* check the type      */
-  if (checkType (type, val->type) != 1)
+  if (checkType (type, val->type) == 0)
     werror (E_INIT_WRONG);
 
   /* if val is literal */

diff --git a/src/SDCCval.c b/src/SDCCval.c
index bfab16715b18024c6326bd5f26240abeab3d9fbc..9b5512cee0a4e73e06558b590898ab1d2ea65f17 100644 (file)
--- a/src/SDCCval.c
+++ b/src/SDCCval.c
@@ -1408,3 +1408,25 @@ valForCastAggr (ast * aexpr, sym_link * type, ast * cnst, int op)
   val->etype = getSpec (val->type);
   return val;
 }
+
+/*-----------------------------------------------------------------*/
+/* valForCastAggr - will return value for a cast of an aggregate   */
+/*                  with no constant                               */
+/*-----------------------------------------------------------------*/
+value *
+valForCastArr (ast * aexpr, sym_link * type)
+{
+  value *val;
+
+  if (!IS_AST_SYM_VALUE (aexpr))
+    return NULL;
+
+  val = newValue ();
+
+  sprintf (val->name, "(%s)",
+          AST_SYMBOL (aexpr)->rname);
+
+  val->type = type;
+  val->etype = getSpec (val->type);
+  return val;
+}

diff --git a/src/SDCCval.h b/src/SDCCval.h
index 77ea58cd5802ddab6cb2eede172d2bfc8669c29f..0ca0de48047d548d327b5e033631170e7f83a32f 100644 (file)
--- a/src/SDCCval.h
+++ b/src/SDCCval.h
@@ -103,4 +103,5 @@ int getNelements (sym_link *, initList *);
 value *valForArray (struct ast *);
 value *valForStructElem (struct ast *, struct ast *);
 value *valForCastAggr (struct ast *, sym_link *, struct ast *, int);
+value *valForCastArr (struct ast * , sym_link *);
 #endif