Use 'ao-dbg' instead of 's51' to communicate with TeleMetrum

[fw/sdcc] / src / SDCCast.c

diff --git a/src/SDCCast.c b/src/SDCCast.c
index 9c929bd9dc0f663d4a59fa4d765e8e9e235a35c7..3470ac464fd14634807ae340f78bc699ce23901d 100644 (file)
--- a/src/SDCCast.c
+++ b/src/SDCCast.c
@@ -84,12 +84,11 @@ static ast *
 newAst_ (unsigned type)
 {
   ast *ex;
 newAst_ (unsigned type)
 {
   ast *ex;

-  static int oldLineno = 0;

 
   ex = Safe_alloc ( sizeof (ast));
 
   ex->type = type;
 
   ex = Safe_alloc ( sizeof (ast));
 
   ex->type = type;

-  ex->lineno = (noLineno ? oldLineno : lexLineno);
+  ex->lineno = (noLineno ? 0 : lexLineno);

   ex->filename = lexFilename;
   ex->level = NestLevel;
   ex->block = currBlockno;
   ex->filename = lexFilename;
   ex->level = NestLevel;
   ex->block = currBlockno;


@@ -169,7 +168,7 @@ newIfxNode (ast * condAst, symbol * trueLabel, symbol * falseLabel)
 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/

-/* copyAstValues - copies value portion of ast if needed     */
+/* copyAstValues - copies value portion of ast if needed           */

 /*-----------------------------------------------------------------*/
 void
 copyAstValues (ast * dest, ast * src)
 /*-----------------------------------------------------------------*/
 void
 copyAstValues (ast * dest, ast * src)


@@ -223,6 +222,7 @@ copyAst (ast * src)
   dest = Safe_alloc ( sizeof (ast));
 
   dest->type = src->type;
   dest = Safe_alloc ( sizeof (ast));
 
   dest->type = src->type;

+  dest->filename = src->filename;

   dest->lineno = src->lineno;
   dest->level = src->level;
   dest->funcName = src->funcName;
   dest->lineno = src->lineno;
   dest->level = src->level;
   dest->funcName = src->funcName;


@@ -391,6 +391,9 @@ ast * createRMW (ast *target, unsigned op, ast *operand)
         tempvar1 = replaceAstWithTemporary(&(target->left));
       if (hasSEFcalls(target->right))
         tempvar2 = replaceAstWithTemporary(&(target->right));
         tempvar1 = replaceAstWithTemporary(&(target->left));
       if (hasSEFcalls(target->right))
         tempvar2 = replaceAstWithTemporary(&(target->right));

+    } else if ((target->opval.op == INC_OP) || (target->opval.op == DEC_OP)) {
+      /* illegal pre/post-increment/decrement */
+      werrorfl (target->filename, target->lineno, E_LVALUE_REQUIRED, "=");

     } else {
       /* we would have to handle '.', but it is not generated any more */
       wassertl(target->opval.op != '.', "obsolete opcode in tree");
     } else {
       /* we would have to handle '.', but it is not generated any more */
       wassertl(target->opval.op != '.', "obsolete opcode in tree");


@@ -537,7 +540,6 @@ resolveSymbols (ast * tree)
             werrorfl (tree->filename, tree->lineno, E_LABEL_UNDEF,
                       tree->falseLabel->name);
         }
             werrorfl (tree->filename, tree->lineno, E_LABEL_UNDEF,
                       tree->falseLabel->name);
         }

-

     }
 
   /* if this is a label resolve it from the labelTab */
     }
 
   /* if this is a label resolve it from the labelTab */


@@ -545,7 +547,6 @@ resolveSymbols (ast * tree)
       tree->opval.val->sym &&
       tree->opval.val->sym->islbl)
     {
       tree->opval.val->sym &&
       tree->opval.val->sym->islbl)
     {

-

       symbol *csym = findSym (LabelTab, tree->opval.val->sym,
                               tree->opval.val->sym->name);
 
       symbol *csym = findSym (LabelTab, tree->opval.val->sym,
                               tree->opval.val->sym->name);
 


@@ -563,10 +564,9 @@ resolveSymbols (ast * tree)
       tree->opval.val->sym &&
       !tree->opval.val->sym->implicit)
     {
       tree->opval.val->sym &&
       !tree->opval.val->sym->implicit)
     {

-

       symbol *csym = findSymWithLevel (SymbolTab, tree->opval.val->sym);
 
       symbol *csym = findSymWithLevel (SymbolTab, tree->opval.val->sym);
 

-      /* if found in the symbol table & they r not the same */
+      /* if found in the symbol table & they are not the same */

       if (csym && tree->opval.val->sym != csym)
         {
           tree->opval.val->sym = csym;
       if (csym && tree->opval.val->sym != csym)
         {
           tree->opval.val->sym = csym;


@@ -575,11 +575,10 @@ resolveSymbols (ast * tree)
         }
 
       /* if not found in the symbol table */
         }
 
       /* if not found in the symbol table */

-      /* mark it as undefined assume it is */
-      /* an integer in data space         */
+      /* mark it as undefined & assume it */
+      /* is an integer in data space      */

       if (!csym && !tree->opval.val->sym->implicit)
         {
       if (!csym && !tree->opval.val->sym->implicit)
         {

-

           /* if this is a function name then */
           /* mark it as returning an int     */
           if (tree->funcName)
           /* if this is a function name then */
           /* mark it as returning an int     */
           if (tree->funcName)


@@ -613,17 +612,18 @@ resolveChildren:
   return tree;
 }
 
   return tree;
 }
 

-/*-----------------------------------------------------------------*/
-/* setAstLineno - walks a ast tree & sets the line number          */
-/*-----------------------------------------------------------------*/
-int setAstLineno (ast * tree, int lineno)
+/*------------------------------------------------------------------------*/
+/* setAstFileLine - walks a ast tree & sets the file name and line number */
+/*------------------------------------------------------------------------*/
+int setAstFileLine (ast * tree, char *filename, int lineno)

 {
   if (!tree)
     return 0;
 
 {
   if (!tree)
     return 0;
 

+  tree->filename = filename;

   tree->lineno = lineno;
   tree->lineno = lineno;

-  setAstLineno (tree->left, lineno);
-  setAstLineno (tree->right, lineno);
+  setAstFileLine (tree->left, filename, lineno);
+  setAstFileLine (tree->right, filename, lineno);

   return 0;
 }
 
   return 0;
 }
 


@@ -780,15 +780,15 @@ processParms (ast *func,
   else
     functype = func->ftype;
 
   else
     functype = func->ftype;
 

-  /* if the function is being called via a pointer &   */
-  /* it has not been defined a reentrant then we cannot */
-  /* have parameters                                   */
+  /* if the function is being called via a pointer &  */
+  /* it has not been defined reentrant then we cannot */
+  /* have parameters                                  */

   /* PIC16 port can... */
   if (!TARGET_IS_PIC16)
     {
       if (func->type != EX_VALUE && !IFFUNC_ISREENT (functype) && !options.stackAuto)
         {
   /* PIC16 port can... */
   if (!TARGET_IS_PIC16)
     {
       if (func->type != EX_VALUE && !IFFUNC_ISREENT (functype) && !options.stackAuto)
         {

-          werror (W_NONRENT_ARGS);
+          werror (E_NONRENT_ARGS);

           fatalError++;
           return 1;
         }
           fatalError++;
           return 1;
         }


@@ -850,8 +850,12 @@ processParms (ast *func,
       ast *newType = NULL;
       sym_link *ftype;
 
       ast *newType = NULL;
       sym_link *ftype;
 

-      if (IS_CAST_OP (*actParm)
-          || (IS_AST_LIT_VALUE (*actParm) && (*actParm)->values.literalFromCast))
+      /* don't perform integer promotion of explicitly typecasted variable arguments
+       * if sdcc extensions are enabled */
+      if (options.std_sdcc &&
+        (IS_CAST_OP (*actParm) ||
+        (IS_AST_SYM_VALUE (*actParm) && AST_VALUES (*actParm, removedCast)) ||
+        (IS_AST_LIT_VALUE (*actParm) && AST_VALUES (*actParm, literalFromCast))))

         {
           /* Parameter was explicitly typecast; don't touch it. */
           return 0;
         {
           /* Parameter was explicitly typecast; don't touch it. */
           return 0;


@@ -859,6 +863,8 @@ processParms (ast *func,
 
       ftype = (*actParm)->ftype;
 
 
       ftype = (*actParm)->ftype;
 

+      resultType = RESULT_TYPE_NONE;
+

       /* If it's a char, upcast to int. */
       if (IS_INTEGRAL (ftype)
           && (getSize (ftype) < (unsigned) INTSIZE))
       /* If it's a char, upcast to int. */
       if (IS_INTEGRAL (ftype)
           && (getSize (ftype) < (unsigned) INTSIZE))


@@ -870,12 +876,14 @@ processParms (ast *func,
         {
           newType = newAst_LINK (copyLinkChain(ftype));
           DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer;
         {
           newType = newAst_LINK (copyLinkChain(ftype));
           DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer;

+          resultType = RESULT_TYPE_GPTR;

         }
 
       if (IS_AGGREGATE (ftype))
         {
           newType = newAst_LINK (copyLinkChain (ftype));
           DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer;
         }
 
       if (IS_AGGREGATE (ftype))
         {
           newType = newAst_LINK (copyLinkChain (ftype));
           DCL_TYPE (newType->opval.lnk) = port->unqualified_pointer;

+          resultType = RESULT_TYPE_GPTR;

         }
 
       if (newType)
         }
 
       if (newType)


@@ -883,9 +891,10 @@ processParms (ast *func,
           /* cast required; change this op to a cast. */
           (*actParm)->decorated = 0;
            *actParm = newNode (CAST, newType, *actParm);
           /* cast required; change this op to a cast. */
           (*actParm)->decorated = 0;
            *actParm = newNode (CAST, newType, *actParm);

+          (*actParm)->filename = (*actParm)->right->filename;

           (*actParm)->lineno = (*actParm)->right->lineno;
 
           (*actParm)->lineno = (*actParm)->right->lineno;
 

-          decorateType (*actParm, RESULT_TYPE_NONE);
+          decorateType (*actParm, resultType);

         }
       return 0;
     } /* vararg */
         }
       return 0;
     } /* vararg */


@@ -920,13 +929,25 @@ processParms (ast *func,
       (*actParm)->left = newAst_LINK (defParm->type);
       (*actParm)->right = pTree;
       (*actParm)->decorated = 0; /* force typechecking */
       (*actParm)->left = newAst_LINK (defParm->type);
       (*actParm)->right = pTree;
       (*actParm)->decorated = 0; /* force typechecking */

-      decorateType (*actParm, resultType);
+      decorateType (*actParm, IS_GENPTR (defParm->type) ? RESULT_TYPE_GPTR : resultType);

     }
 
   /* make a copy and change the regparm type to the defined parm */
   (*actParm)->etype = getSpec ((*actParm)->ftype = copyLinkChain ((*actParm)->ftype));
   SPEC_REGPARM ((*actParm)->etype) = SPEC_REGPARM (defParm->etype);
   SPEC_ARGREG  ((*actParm)->etype) = SPEC_ARGREG (defParm->etype);
     }
 
   /* make a copy and change the regparm type to the defined parm */
   (*actParm)->etype = getSpec ((*actParm)->ftype = copyLinkChain ((*actParm)->ftype));
   SPEC_REGPARM ((*actParm)->etype) = SPEC_REGPARM (defParm->etype);
   SPEC_ARGREG  ((*actParm)->etype) = SPEC_ARGREG (defParm->etype);

+
+  /* if the function is being called via a pointer &  */
+  /* this parameter is not passed in registers        */
+  /* then the function must be defined reentrant      */
+  if (IS_FUNCPTR (func->ftype) && !SPEC_REGPARM ((*actParm)->etype) &&
+      !IFFUNC_ISREENT (functype) && !options.stackAuto)
+    {
+      werror (E_NONRENT_ARGS);
+      fatalError++;
+      return 1;
+    }
+

   (*parmNumber)++;
   return 0;
 }
   (*parmNumber)++;
   return 0;
 }


@@ -940,10 +961,13 @@ createIvalType (ast * sym, sym_link * type, initList * ilist)
   ast *iExpr;
 
   /* if initList is deep */
   ast *iExpr;
 
   /* if initList is deep */

-  if (ilist->type == INIT_DEEP)
+  if (ilist && ilist->type == INIT_DEEP)

     ilist = ilist->init.deep;
 
     ilist = ilist->init.deep;
 

-  iExpr = decorateType (resolveSymbols (list2expr (ilist)), RESULT_TYPE_NONE);
+  if (ilist)
+    iExpr = decorateType (resolveSymbols (list2expr (ilist)), RESULT_TYPE_NONE);
+  else
+    iExpr = newAst_VALUE (valueFromLit (0));

   return decorateType (newNode ('=', sym, iExpr), RESULT_TYPE_NONE);
 }
 
   return decorateType (newNode ('=', sym, iExpr), RESULT_TYPE_NONE);
 }
 


@@ -951,46 +975,51 @@ createIvalType (ast * sym, sym_link * type, initList * ilist)
 /* createIvalStruct - generates initial value for structures       */
 /*-----------------------------------------------------------------*/
 static ast *
 /* createIvalStruct - generates initial value for structures       */
 /*-----------------------------------------------------------------*/
 static ast *

-createIvalStruct (ast * sym, sym_link * type, initList * ilist, ast *rootValue)
+createIvalStruct (ast *sym, sym_link *type, initList *ilist, ast *rootValue)

 {
   ast *rast = NULL;
   ast *lAst;
   symbol *sflds;
   initList *iloop;
 {
   ast *rast = NULL;
   ast *lAst;
   symbol *sflds;
   initList *iloop;

+  sym_link * etype = getSpec (type);

 
 

-  sflds = SPEC_STRUCT (type)->fields;
-  if (ilist->type != INIT_DEEP)
+  if (ilist && ilist->type != INIT_DEEP)

     {
       werror (E_INIT_STRUCT, "");
       return NULL;
     }
 
     {
       werror (E_INIT_STRUCT, "");
       return NULL;
     }
 

-  iloop = ilist->init.deep;
+  iloop = ilist ? ilist->init.deep : NULL;

 
 

-  for (; sflds; sflds = sflds->next, iloop = (iloop ? iloop->next : NULL))
+  for (sflds = SPEC_STRUCT (type)->fields; sflds; sflds = sflds->next)

     {
       /* if we have come to end */
     {
       /* if we have come to end */

-      if (!iloop)
+      if (!iloop && (!AST_SYMBOL (rootValue)->islocal || SPEC_STAT (etype)))

         break;
         break;

-      sflds->implicit = 1;
-      lAst = newNode (PTR_OP, newNode ('&', sym, NULL), newAst_VALUE (symbolVal (sflds)));
-      lAst = decorateType (resolveSymbols (lAst), RESULT_TYPE_NONE);
-      rast = decorateType (resolveSymbols (createIval (lAst, sflds->type,
-                                                       iloop, rast, rootValue)),
-                           RESULT_TYPE_NONE);

 
 

+      if (!IS_BITFIELD (sflds->type) || !SPEC_BUNNAMED (sflds->etype))
+        {
+          sflds->implicit = 1;
+          lAst = newNode (PTR_OP, newNode ('&', sym, NULL), newAst_VALUE (symbolVal (sflds)));
+          lAst = decorateType (resolveSymbols (lAst), RESULT_TYPE_NONE);
+          rast = decorateType (resolveSymbols (createIval (lAst, sflds->type, iloop, rast, rootValue)), RESULT_TYPE_NONE);
+          iloop = iloop ? iloop->next : NULL;
+        }

     }
 
     }
 

-  if (iloop) {
-    werrorfl (sym->opval.val->sym->fileDef, sym->opval.val->sym->lineDef,
-              W_EXCESS_INITIALIZERS, "struct",
-              sym->opval.val->sym->name);
-  }
+  if (iloop)
+    {
+      if (IS_AST_VALUE (sym))
+        werrorfl (sym->opval.val->sym->fileDef, sym->opval.val->sym->lineDef,
+                  W_EXCESS_INITIALIZERS, "struct",
+                  sym->opval.val->sym->name);
+      else
+        werrorfl (sym->filename, sym->lineno, E_INIT_COUNT);
+    }

 
   return rast;
 }
 
 
   return rast;
 }
 

-

 /*-----------------------------------------------------------------*/
 /* createIvalArray - generates code for array initialization       */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
 /* createIvalArray - generates code for array initialization       */
 /*-----------------------------------------------------------------*/


@@ -1001,6 +1030,7 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist, ast *rootValue)
   initList *iloop;
   int lcnt = 0, size = 0;
   literalList *literalL;
   initList *iloop;
   int lcnt = 0, size = 0;
   literalList *literalL;

+  sym_link * etype = getSpec (type);

 
   /* take care of the special   case  */
   /* array of characters can be init  */
 
   /* take care of the special   case  */
   /* array of characters can be init  */


@@ -1008,23 +1038,29 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist, ast *rootValue)
   if (IS_CHAR (type->next))
     if ((rast = createIvalCharPtr (sym,
                                    type,
   if (IS_CHAR (type->next))
     if ((rast = createIvalCharPtr (sym,
                                    type,

-                        decorateType (resolveSymbols (list2expr (ilist)), RESULT_TYPE_NONE),
+                                   decorateType (resolveSymbols (list2expr (ilist)), RESULT_TYPE_NONE),

                                    rootValue)))
 
       return decorateType (resolveSymbols (rast), RESULT_TYPE_NONE);
 
                                    rootValue)))
 
       return decorateType (resolveSymbols (rast), RESULT_TYPE_NONE);
 

-  /* not the special case             */
-  if (ilist->type != INIT_DEEP)
-  {
+  /* not the special case */
+  if (ilist && ilist->type != INIT_DEEP)
+    {

       werror (E_INIT_STRUCT, "");
       return NULL;
       werror (E_INIT_STRUCT, "");
       return NULL;

-  }
+    }

 
 

-  iloop = ilist->init.deep;
+  iloop = ilist ? ilist->init.deep : NULL;

   lcnt = DCL_ELEM (type);
 
   lcnt = DCL_ELEM (type);
 

-  if (port->arrayInitializerSuppported && convertIListToConstList(ilist, &literalL))
-  {
+  if (!iloop &&
+      (!lcnt || !DCL_ELEM (type) || !AST_SYMBOL (rootValue)->islocal || SPEC_STAT (etype)))
+    {
+      return NULL;
+    }
+
+  if (port->arrayInitializerSuppported && convertIListToConstList(ilist, &literalL, lcnt))
+    {

       ast *aSym;
 
       aSym = decorateType (resolveSymbols(sym), RESULT_TYPE_NONE);
       ast *aSym;
 
       aSym = decorateType (resolveSymbols(sym), RESULT_TYPE_NONE);


@@ -1034,45 +1070,48 @@ createIvalArray (ast * sym, sym_link * type, initList * ilist, ast *rootValue)
 
       // Make sure size is set to length of initializer list.
       while (iloop)
 
       // Make sure size is set to length of initializer list.
       while (iloop)

-      {
+        {

           size++;
           iloop = iloop->next;
           size++;
           iloop = iloop->next;

-      }
+        }

 
       if (lcnt && size > lcnt)
 
       if (lcnt && size > lcnt)

-      {
+        {

           // Array size was specified, and we have more initializers than needed.
           werrorfl (sym->opval.val->sym->fileDef, sym->opval.val->sym->lineDef,
           // Array size was specified, and we have more initializers than needed.
           werrorfl (sym->opval.val->sym->fileDef, sym->opval.val->sym->lineDef,

-            W_EXCESS_INITIALIZERS, "array", sym->opval.val->sym->name);
-      }
-  }
+                    W_EXCESS_INITIALIZERS, "array", sym->opval.val->sym->name);
+        }
+    }

   else
   else

-  {
+    {

       for (;;)
       for (;;)

-      {
+        {

           ast *aSym;
 
           ast *aSym;
 

+          if (!iloop &&
+              (!lcnt || !DCL_ELEM (type) || !AST_SYMBOL (rootValue)->islocal || SPEC_STAT (etype)))
+            {
+              break;
+            }
+

           aSym = newNode ('[', sym, newAst_VALUE (valueFromLit ((float) (size++))));
           aSym = decorateType (resolveSymbols (aSym), RESULT_TYPE_NONE);
           rast = createIval (aSym, type->next, iloop, rast, rootValue);
           aSym = newNode ('[', sym, newAst_VALUE (valueFromLit ((float) (size++))));
           aSym = decorateType (resolveSymbols (aSym), RESULT_TYPE_NONE);
           rast = createIval (aSym, type->next, iloop, rast, rootValue);

+          lcnt--;

           iloop = (iloop ? iloop->next : NULL);
           iloop = (iloop ? iloop->next : NULL);

-          if (!iloop)
-          {
-              break;
-          }

 
           /* no of elements given and we    */
           /* have generated for all of them */
 
           /* no of elements given and we    */
           /* have generated for all of them */

-          if (!--lcnt)
-          {
+          if (!lcnt && iloop)
+            {

               // is this a better way? at least it won't crash
               char *name = (IS_AST_SYM_VALUE(sym)) ? AST_SYMBOL(sym)->name : "";
               werrorfl (iloop->filename, iloop->lineno, W_EXCESS_INITIALIZERS, "array", name);
 
               break;
               // is this a better way? at least it won't crash
               char *name = (IS_AST_SYM_VALUE(sym)) ? AST_SYMBOL(sym)->name : "";
               werrorfl (iloop->filename, iloop->lineno, W_EXCESS_INITIALIZERS, "array", name);
 
               break;

-          }
-      }
-  }
+            }
+        }
+    }

 
   /* if we have not been given a size  */
   if (!DCL_ELEM (type))
 
   /* if we have not been given a size  */
   if (!DCL_ELEM (type))


@@ -1104,8 +1143,30 @@ createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr, ast *rootVal)
                         && IS_ARRAY (iexpr->ftype)))
     return newNode ('=', sym, iexpr);
 
                         && IS_ARRAY (iexpr->ftype)))
     return newNode ('=', sym, iexpr);
 

-  /* left side is an array so we have to assign each */
-  /* element                                         */
+  /* left side is an array so we have to assign each element */
+  if (!iexpr)
+    {
+      /* for each character generate an assignment */
+      /* to the array element */
+      unsigned int i = 0;
+      unsigned int symsize = getSize (type);
+
+      if (!AST_SYMBOL (rootVal)->islocal || SPEC_STAT (getSpec (type)))
+        return NULL;
+
+      for (i = 0; i < symsize; ++i)
+        {
+          rast = newNode (NULLOP,
+                          rast,
+                          newNode ('=',
+                                   newNode ('[', sym,
+                                            newAst_VALUE (valueFromLit ((float) i))),
+                                   newAst_VALUE (valueFromLit (0))));
+        }
+
+      return decorateType (resolveSymbols (rast), RESULT_TYPE_NONE);
+    }
+

   if ((IS_LITERAL (iexpr->etype) ||
        SPEC_SCLS (iexpr->etype) == S_CODE)
       && IS_ARRAY (iexpr->ftype))
   if ((IS_LITERAL (iexpr->etype) ||
        SPEC_SCLS (iexpr->etype) == S_CODE)
       && IS_ARRAY (iexpr->ftype))


@@ -1117,9 +1178,9 @@ createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr, ast *rootVal)
       unsigned int symsize = getSize (type);
 
       size = getSize (iexpr->ftype);
       unsigned int symsize = getSize (type);
 
       size = getSize (iexpr->ftype);

-      if (symsize && size>symsize)
+      if (symsize && size > symsize)

         {
         {

-          if (size>(symsize+1))
+          if (size > symsize)

             {
               char *name = (IS_AST_SYM_VALUE(sym)) ? AST_SYMBOL(sym)->name : "";
 
             {
               char *name = (IS_AST_SYM_VALUE(sym)) ? AST_SYMBOL(sym)->name : "";
 


@@ -1129,15 +1190,14 @@ createIvalCharPtr (ast * sym, sym_link * type, ast * iexpr, ast *rootVal)
           size = symsize;
         }
 
           size = symsize;
         }
 

-      for (i=0;i<size;i++)
+      for (i = 0; i < size; i++)

         {
           rast = newNode (NULLOP,
                           rast,
                           newNode ('=',
                                    newNode ('[', sym,
                                    newAst_VALUE (valueFromLit ((float) i))),
         {
           rast = newNode (NULLOP,
                           rast,
                           newNode ('=',
                                    newNode ('[', sym,
                                    newAst_VALUE (valueFromLit ((float) i))),

-                                   newAst_VALUE (valueFromLit (*s))));
-          s++;
+                                   newAst_VALUE (valueFromLit (*s++))));

         }
 
       // now WE don't need iexpr's symbol anymore
         }
 
       // now WE don't need iexpr's symbol anymore


@@ -1169,7 +1229,7 @@ createIvalPtr (ast * sym, sym_link * type, initList * ilist, ast *rootVal)
   ast *iexpr;
 
   /* if deep then   */
   ast *iexpr;
 
   /* if deep then   */

-  if (ilist->type == INIT_DEEP)
+  if (ilist && ilist->type == INIT_DEEP)

     ilist = ilist->init.deep;
 
   iexpr = decorateType (resolveSymbols (list2expr (ilist)), RESULT_TYPE_NONE);
     ilist = ilist->init.deep;
 
   iexpr = decorateType (resolveSymbols (list2expr (ilist)), RESULT_TYPE_NONE);


@@ -1190,7 +1250,7 @@ createIval (ast * sym, sym_link * type, initList * ilist, ast * wid, ast *rootVa
 {
   ast *rast = NULL;
 
 {
   ast *rast = NULL;
 

-  if (!ilist)
+  if (!ilist && (!AST_SYMBOL (rootValue)->islocal || SPEC_STAT (getSpec (type))))

     return NULL;
 
   /* if structure then    */
     return NULL;
 
   /* if structure then    */


@@ -1218,14 +1278,15 @@ createIval (ast * sym, sym_link * type, initList * ilist, ast * wid, ast *rootVa
 /*-----------------------------------------------------------------*/
 /* initAggregates - initialises aggregate variables with initv     */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
 /* initAggregates - initialises aggregate variables with initv     */
 /*-----------------------------------------------------------------*/

-ast * initAggregates (symbol * sym, initList * ival, ast * wid) {
+ast * initAggregates (symbol * sym, initList * ival, ast * wid)
+{

   ast *newAst = newAst_VALUE (symbolVal (sym));
   return createIval (newAst, sym->type, ival, wid, newAst);
 }
 
 /*-----------------------------------------------------------------*/
 /* gatherAutoInit - creates assignment expressions for initial     */
   ast *newAst = newAst_VALUE (symbolVal (sym));
   return createIval (newAst, sym->type, ival, wid, newAst);
 }
 
 /*-----------------------------------------------------------------*/
 /* gatherAutoInit - creates assignment expressions for initial     */

-/*    values                 */
+/*                  values                                         */

 /*-----------------------------------------------------------------*/
 static ast *
 gatherAutoInit (symbol * autoChain)
 /*-----------------------------------------------------------------*/
 static ast *
 gatherAutoInit (symbol * autoChain)


@@ -1237,7 +1298,6 @@ gatherAutoInit (symbol * autoChain)
   inInitMode = 1;
   for (sym = autoChain; sym; sym = sym->next)
     {
   inInitMode = 1;
   for (sym = autoChain; sym; sym = sym->next)
     {

-

       /* resolve the symbols in the ival */
       if (sym->ival)
         resolveIvalSym (sym->ival, sym->type);
       /* resolve the symbols in the ival */
       if (sym->ival)
         resolveIvalSym (sym->ival, sym->type);


@@ -1284,7 +1344,7 @@ gatherAutoInit (symbol * autoChain)
                             list2expr (sym->ival));
           }
 
                             list2expr (sym->ival));
           }
 

-          setAstLineno (work, sym->lineDef);
+          setAstFileLine (work, sym->fileDef, sym->lineDef);

 
           sym->ival = NULL;
           if (staticAutos)
 
           sym->ival = NULL;
           if (staticAutos)


@@ -1298,30 +1358,36 @@ gatherAutoInit (symbol * autoChain)
       /* if there is an initial value */
       if (sym->ival && SPEC_SCLS (sym->etype) != S_CODE)
         {
       /* if there is an initial value */
       if (sym->ival && SPEC_SCLS (sym->etype) != S_CODE)
         {

-          initList *ilist=sym->ival;
+          initList *ilist = sym->ival;

 
 

-          while (ilist->type == INIT_DEEP) {
-            ilist = ilist->init.deep;
-          }
+          while (ilist->type == INIT_DEEP)
+            {
+              ilist = ilist->init.deep;
+            }

 
           /* update lineno for error msg */
 
           /* update lineno for error msg */

+          filename = sym->fileDef;

           lineno = sym->lineDef;
           lineno = sym->lineDef;

-          setAstLineno (ilist->init.node, sym->lineDef);
+          setAstFileLine (ilist->init.node, sym->fileDef, sym->lineDef);

 
 

-          if (IS_AGGREGATE (sym->type)) {
-            work = initAggregates (sym, sym->ival, NULL);
-          } else {
-            if (getNelements(sym->type, sym->ival)>1) {
-              werrorfl (sym->fileDef, sym->lineDef,
-                        W_EXCESS_INITIALIZERS, "scalar",
-                        sym->name);
+          if (IS_AGGREGATE (sym->type))
+            {
+              work = initAggregates (sym, sym->ival, NULL);
+            }
+          else
+            {
+              if (getNelements(sym->type, sym->ival)>1)
+                {
+                  werrorfl (sym->fileDef, sym->lineDef,
+                            W_EXCESS_INITIALIZERS, "scalar",
+                            sym->name);
+                }
+              work = newNode ('=', newAst_VALUE (symbolVal (sym)),
+                              list2expr (sym->ival));

             }
             }

-            work = newNode ('=', newAst_VALUE (symbolVal (sym)),
-                            list2expr (sym->ival));
-          }

 
           // just to be sure
 
           // just to be sure

-          setAstLineno (work, sym->lineDef);
+          setAstFileLine (work, sym->fileDef, sym->lineDef);

 
           sym->ival = NULL;
           if (init)
 
           sym->ival = NULL;
           if (init)


@@ -1361,16 +1427,18 @@ stringToSymbol (value * val)
   unsigned int size;
 
   // have we heard this before?
   unsigned int size;
 
   // have we heard this before?

-  for (sp=statsg->syms; sp; sp=sp->next) {
-    sym=sp->item;
-    size = getSize (sym->type);
-    if (sym->isstrlit && size == getSize (val->type) &&
-        !memcmp(SPEC_CVAL(sym->etype).v_char, SPEC_CVAL(val->etype).v_char, size)) {
-      // yes, this is old news. Don't publish it again.
-      sym->isstrlit++; // but raise the usage count
-      return symbolVal(sym);
+  for (sp = statsg->syms; sp; sp = sp->next)
+    {
+      sym = sp->item;
+      size = getSize (sym->type);
+      if (sym->isstrlit && size == getSize (val->type) &&
+          !memcmp (SPEC_CVAL (sym->etype).v_char, SPEC_CVAL (val->etype).v_char, size))
+        {
+          // yes, this is old news. Don't publish it again.
+          sym->isstrlit++; // but raise the usage count
+          return symbolVal (sym);
+        }

     }
     }

-  }

 
   SNPRINTF (name, sizeof(name), "_str_%d", charLbl++);
   sym = newSymbol (name, 0);    /* make it @ level 0 */
 
   SNPRINTF (name, sizeof(name), "_str_%d", charLbl++);
   sym = newSymbol (name, 0);    /* make it @ level 0 */


@@ -1433,7 +1501,6 @@ processBlockVars (ast * tree, int *stack, int action)
   return tree;
 }
 
   return tree;
 }
 

-

 /*-------------------------------------------------------------*/
 /* constExprTree - returns TRUE if this tree is a constant     */
 /*                 expression                                  */
 /*-------------------------------------------------------------*/
 /* constExprTree - returns TRUE if this tree is a constant     */
 /*                 expression                                  */


@@ -1533,13 +1600,13 @@ constExprValue (ast * cexpr, int check)
           cexpr->opval.op == CAST &&
           IS_LITERAL (cexpr->right->ftype))
         {
           cexpr->opval.op == CAST &&
           IS_LITERAL (cexpr->right->ftype))
         {

-        return valCastLiteral (cexpr->ftype,
-                               floatFromVal (cexpr->right->opval.val));
+          return valCastLiteral (cexpr->ftype,
+                                 floatFromVal (cexpr->right->opval.val));

         }
 
       if (IS_AST_VALUE (cexpr))
         {
         }
 
       if (IS_AST_VALUE (cexpr))
         {

-        return cexpr->opval.val;
+          return cexpr->opval.val;

         }
 
       if (check)
         }
 
       if (check)


@@ -1553,7 +1620,7 @@ constExprValue (ast * cexpr, int check)
     {
       return cexpr->opval.val;
     }
     {
       return cexpr->opval.val;
     }

-   return NULL;
+  return NULL;

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -1572,7 +1639,6 @@ isLabelInAst (symbol * label, ast * tree)
 
   return isLabelInAst (label, tree->right) &&
     isLabelInAst (label, tree->left);
 
   return isLabelInAst (label, tree->right) &&
     isLabelInAst (label, tree->left);

-

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -1638,7 +1704,7 @@ isLoopCountable (ast * initExpr, ast * condExpr, ast * loopExpr,
             {
 
               *end = newNode ('+', condExpr->left->right,
             {
 
               *end = newNode ('+', condExpr->left->right,

-                              newAst_VALUE (constVal ("1")));
+                              newAst_VALUE (constCharVal (1)));

               break;
             }
           return FALSE;
               break;
             }
           return FALSE;


@@ -1685,7 +1751,7 @@ isLoopCountable (ast * initExpr, ast * condExpr, ast * loopExpr,
           if (IS_AST_SYM_VALUE (loopExpr->left) &&
               isSymbolEqual (*sym, AST_SYMBOL (loopExpr->left)) &&
               IS_AST_LIT_VALUE (loopExpr->right) &&
           if (IS_AST_SYM_VALUE (loopExpr->left) &&
               isSymbolEqual (*sym, AST_SYMBOL (loopExpr->left)) &&
               IS_AST_LIT_VALUE (loopExpr->right) &&

-              (int) AST_LIT_VALUE (loopExpr->right) != 1)
+              AST_ULONG_VALUE (loopExpr->right) != 1)

             return TRUE;
         }
     }
             return TRUE;
         }
     }


@@ -1773,8 +1839,8 @@ astHasDeref (ast * tree)
 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/

-/* isConformingBody - the loop body has to conform to a set of rules */
-/* for the loop to be considered reversible read on for rules      */
+/* isConformingBody - the loop body has to conform to a set of     */
+/* rules for the loop to be considered reversible read on for rules*/

 /*-----------------------------------------------------------------*/
 bool
 isConformingBody (ast * pbody, symbol * sym, ast * body)
 /*-----------------------------------------------------------------*/
 bool
 isConformingBody (ast * pbody, symbol * sym, ast * body)


@@ -1783,14 +1849,13 @@ isConformingBody (ast * pbody, symbol * sym, ast * body)
   /* we are going to do a pre-order traversal of the
      tree && check for the following conditions. (essentially
      a set of very shallow tests )
   /* we are going to do a pre-order traversal of the
      tree && check for the following conditions. (essentially
      a set of very shallow tests )

-     a) the sym passed does not participate in
-     any arithmetic operation
+     a) the sym passed does not participate in any arithmetic operation

      b) There are no function calls
      c) all jumps are within the body
      d) address of loop control variable not taken
      b) There are no function calls
      c) all jumps are within the body
      d) address of loop control variable not taken

-     e) if an assignment has a pointer on the
-     left hand side make sure right does not have
-     loop control variable */
+     e) if an assignment has a pointer on the left hand side make sure
+        right does not have loop control variable
+  */

 
   /* if we reach the end or a leaf then true */
   if (!pbody || IS_AST_LINK (pbody) || IS_AST_VALUE (pbody))
 
   /* if we reach the end or a leaf then true */
   if (!pbody || IS_AST_LINK (pbody) || IS_AST_VALUE (pbody))


@@ -1845,9 +1910,9 @@ isConformingBody (ast * pbody, symbol * sym, ast * body)
 
       /* if right is NULL then unary operation  */
 /*------------------------------------------------------------------*/
 
       /* if right is NULL then unary operation  */
 /*------------------------------------------------------------------*/

-/*----------------------------*/
+      /*----------------------------*/

       /*  address of                */
       /*  address of                */

-/*----------------------------*/
+      /*----------------------------*/

       if (!pbody->right)
         {
           if (IS_AST_SYM_VALUE (pbody->left) &&
       if (!pbody->right)
         {
           if (IS_AST_SYM_VALUE (pbody->left) &&


@@ -1947,7 +2012,8 @@ isConformingBody (ast * pbody, symbol * sym, ast * body)
       if (astHasVolatile (pbody->left))
         return FALSE;
 
       if (astHasVolatile (pbody->left))
         return FALSE;
 

-      if (astHasDeref(pbody->right)) return FALSE;
+      if (astHasDeref(pbody->right))
+        return FALSE;

 
       return isConformingBody (pbody->left, sym, body) &&
         isConformingBody (pbody->right, sym, body);
 
       return isConformingBody (pbody->left, sym, body) &&
         isConformingBody (pbody->right, sym, body);


@@ -1964,27 +2030,31 @@ isConformingBody (ast * pbody, symbol * sym, ast * body)
       assert ("Parser should not have generated this\n");
 
 /*------------------------------------------------------------------*/
       assert ("Parser should not have generated this\n");
 
 /*------------------------------------------------------------------*/

-/*----------------------------*/
+      /*----------------------------*/

       /*      comma operator        */
       /*      comma operator        */

-/*----------------------------*/
+      /*----------------------------*/

     case ',':
       return isConformingBody (pbody->left, sym, body) &&
         isConformingBody (pbody->right, sym, body);
 
 /*------------------------------------------------------------------*/
     case ',':
       return isConformingBody (pbody->left, sym, body) &&
         isConformingBody (pbody->right, sym, body);
 
 /*------------------------------------------------------------------*/

-/*----------------------------*/
+      /*----------------------------*/

       /*       function call        */
       /*       function call        */

-/*----------------------------*/
+      /*----------------------------*/

     case CALL:
     case CALL:

-        /* if local & not passed as paramater then ok */
-        if (sym->level && !astHasSymbol(pbody->right,sym))
+        /* if local & not passed as parameter &
+           not used to find the function then ok */
+        if (sym->level && !astHasSymbol (pbody->right, sym) &&
+            !astHasSymbol (pbody->left, sym))
+          {

             return TRUE;
             return TRUE;

+          }

       return FALSE;
 
 /*------------------------------------------------------------------*/
       return FALSE;
 
 /*------------------------------------------------------------------*/

-/*----------------------------*/
+      /*----------------------------*/

       /*     return statement       */
       /*     return statement       */

-/*----------------------------*/
+      /*----------------------------*/

     case RETURN:
       return FALSE;
 
     case RETURN:
       return FALSE;
 


@@ -2003,9 +2073,6 @@ isConformingBody (ast * pbody, symbol * sym, ast * body)
 
   return isConformingBody (pbody->left, sym, body) &&
     isConformingBody (pbody->right, sym, body);
 
   return isConformingBody (pbody->left, sym, body) &&
     isConformingBody (pbody->right, sym, body);

-
-
-

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -2059,7 +2126,7 @@ replLoopSym (ast * body, symbol * sym)
           body->type = EX_OP;
           body->opval.op = '-';
           body->left = newAst_VALUE (symbolVal (sym));
           body->type = EX_OP;
           body->opval.op = '-';
           body->left = newAst_VALUE (symbolVal (sym));

-          body->right = newAst_VALUE (constVal ("1"));
+          body->right = newAst_VALUE (constCharVal (1));

 
         }
 
 
         }
 


@@ -2099,7 +2166,7 @@ reverseLoop (ast * loop, symbol * sym, ast * init, ast * end)
                             end));
 
   replLoopSym (loop->left, sym);
                             end));
 
   replLoopSym (loop->left, sym);

-  setAstLineno (rloop, init->lineno);
+  setAstFileLine (rloop, init->filename, init->lineno);

 
   rloop = newNode (NULLOP,
                    newNode ('=',
 
   rloop = newNode (NULLOP,
                    newNode ('=',


@@ -2111,7 +2178,7 @@ reverseLoop (ast * loop, symbol * sym, ast * init, ast * end)
                                          newNode (NULLOP,
                                                   newNode (SUB_ASSIGN,
                                                            newAst_VALUE (symbolVal (sym)),
                                          newNode (NULLOP,
                                                   newNode (SUB_ASSIGN,
                                                            newAst_VALUE (symbolVal (sym)),

-                                                           newAst_VALUE (constVal ("1"))),
+                                                           newAst_VALUE (constCharVal (1))),

                                                   rloop))));
 
   rloop->lineno=init->lineno;
                                                   rloop))));
 
   rloop->lineno=init->lineno;


@@ -2262,6 +2329,7 @@ addCast (ast *tree, RESULT_TYPE resultType, bool promote)
     }
   tree->decorated = 0;
   tree = newNode (CAST, newAst_LINK (newLink), tree);
     }
   tree->decorated = 0;
   tree = newNode (CAST, newAst_LINK (newLink), tree);

+  tree->filename = tree->right->filename;

   tree->lineno = tree->right->lineno;
   /* keep unsigned type during cast to smaller type,
      but not when promoting from char to int */
   tree->lineno = tree->right->lineno;
   /* keep unsigned type during cast to smaller type,
      but not when promoting from char to int */


@@ -2280,17 +2348,22 @@ resultTypePropagate (ast *tree, RESULT_TYPE resultType)
     {
       case AND_OP:
       case OR_OP:
     {
       case AND_OP:
       case OR_OP:

-        return resultType;
+      case '!':

       case '=':
       case '?':
       case ':':
       case '|':
       case '^':
       case '~':
       case '=':
       case '?':
       case ':':
       case '|':
       case '^':
       case '~':

+      case LEFT_OP:
+      case LABEL:
+        return resultType;

       case '*':
       case '+':
       case '-':
       case '*':
       case '+':
       case '-':

-      case LABEL:
+        if ((IS_AST_VALUE (tree->left)  && !IS_INTEGRAL (tree->left->opval.val->etype)) ||
+            (IS_AST_VALUE (tree->right) && !IS_INTEGRAL (tree->right->opval.val->etype)))
+          return RESULT_TYPE_NONE;

         return resultType;
       case '&':
         if (!tree->right)
         return resultType;
       case '&':
         if (!tree->right)


@@ -2448,15 +2521,14 @@ decorateType (ast * tree, RESULT_TYPE resultType)
 /*----------------------------*/
 /*   leaf has been reached    */
 /*----------------------------*/
 /*----------------------------*/
 /*   leaf has been reached    */
 /*----------------------------*/

+  filename = tree->filename;

   lineno = tree->lineno;
   /* if this is of type value */
   /* just get the type        */
   if (tree->type == EX_VALUE)
     {
   lineno = tree->lineno;
   /* if this is of type value */
   /* just get the type        */
   if (tree->type == EX_VALUE)
     {

-

       if (IS_LITERAL (tree->opval.val->etype))
         {
       if (IS_LITERAL (tree->opval.val->etype))
         {

-

           /* if this is a character array then declare it */
           if (IS_ARRAY (tree->opval.val->type))
             tree->opval.val = stringToSymbol (tree->opval.val);
           /* if this is a character array then declare it */
           if (IS_ARRAY (tree->opval.val->type))
             tree->opval.val = stringToSymbol (tree->opval.val);


@@ -2534,7 +2606,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
        upon tree->opval.op, if resultType can be propagated */
     resultTypeProp = resultTypePropagate (tree, resultType);
 
        upon tree->opval.op, if resultType can be propagated */
     resultTypeProp = resultTypePropagate (tree, resultType);
 

-    if (tree->opval.op == '?')
+    if ((tree->opval.op == '?') && (resultTypeProp != RESULT_TYPE_BIT))

       dtl = decorateType (tree->left, RESULT_TYPE_IFX);
     else
       dtl = decorateType (tree->left, resultTypeProp);
       dtl = decorateType (tree->left, RESULT_TYPE_IFX);
     else
       dtl = decorateType (tree->left, resultTypeProp);


@@ -2623,7 +2695,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
 
       if (IS_LITERAL (RTYPE (tree)))
         {
 
       if (IS_LITERAL (RTYPE (tree)))
         {

-          int arrayIndex = (int) floatFromVal (valFromType (RETYPE (tree)));
+          int arrayIndex = (int) ulFromVal (valFromType (RETYPE (tree)));

           int arraySize = DCL_ELEM (LTYPE (tree));
           if (arraySize && arrayIndex >= arraySize)
             {
           int arraySize = DCL_ELEM (LTYPE (tree));
           if (arraySize && arrayIndex >= arraySize)
             {


@@ -3098,7 +3170,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
       /* rearrange the tree */
       if (IS_LITERAL (RTYPE (tree))
           /* avoid infinite loop */
       /* rearrange the tree */
       if (IS_LITERAL (RTYPE (tree))
           /* avoid infinite loop */

-          && (TYPE_TARGET_ULONG) floatFromVal (tree->right->opval.val) != 1)
+          && (TYPE_TARGET_ULONG) ulFromVal (tree->right->opval.val) != 1)

         {
           ast *parent;
           ast *litTree = searchLitOp (tree, &parent, "/");
         {
           ast *parent;
           ast *litTree = searchLitOp (tree, &parent, "/");


@@ -3111,9 +3183,10 @@ decorateType (ast * tree, RESULT_TYPE resultType)
                   litTree->right = newNode ('*',
                                             litTree->right,
                                             copyAst (tree->right));
                   litTree->right = newNode ('*',
                                             litTree->right,
                                             copyAst (tree->right));

+                  litTree->right->filename = tree->filename;

                   litTree->right->lineno = tree->lineno;
 
                   litTree->right->lineno = tree->lineno;
 

-                  tree->right->opval.val = constVal ("1");
+                  tree->right->opval.val = constCharVal (1);

                   decorateType (parent, resultType);
                 }
               else
                   decorateType (parent, resultType);
                 }
               else


@@ -3182,7 +3255,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
               werrorfl (tree->filename, tree->lineno, E_LVALUE_REQUIRED, "pointer deref");
               goto errorTreeReturn;
             }
               werrorfl (tree->filename, tree->lineno, E_LVALUE_REQUIRED, "pointer deref");
               goto errorTreeReturn;
             }

-          if (IS_ADDRESS_OF_OP(tree->left))
+          if (IS_ADDRESS_OF_OP (tree->left))

             {
               /* replace *&obj with obj */
               return tree->left->left;
             {
               /* replace *&obj with obj */
               return tree->left->left;


@@ -3272,8 +3345,8 @@ decorateType (ast * tree, RESULT_TYPE resultType)
         }
 
       LRVAL (tree) = RRVAL (tree) = 1;
         }
 
       LRVAL (tree) = RRVAL (tree) = 1;

-      tree->left  = addCast (tree->left,  resultType, FALSE);
-      tree->right = addCast (tree->right, resultType, FALSE);
+      tree->left  = addCast (tree->left,  resultTypeProp, FALSE);
+      tree->right = addCast (tree->right, resultTypeProp, FALSE);

       TETYPE (tree) = getSpec (TTYPE (tree) =
                                    computeType (LTYPE (tree),
                                                 RTYPE (tree),
       TETYPE (tree) = getSpec (TTYPE (tree) =
                                    computeType (LTYPE (tree),
                                                 RTYPE (tree),


@@ -3342,8 +3415,8 @@ decorateType (ast * tree, RESULT_TYPE resultType)
       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
         {
           tree->type = EX_VALUE;
       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
         {
           tree->type = EX_VALUE;

-          tree->left  = addCast (tree->left,  resultType, TRUE);
-          tree->right = addCast (tree->right, resultType, TRUE);
+          tree->left  = addCast (tree->left,  resultTypeProp, TRUE);
+          tree->right = addCast (tree->right, resultTypeProp, TRUE);

           tree->opval.val = valPlus (valFromType (LETYPE (tree)),
                                      valFromType (RETYPE (tree)));
           tree->right = tree->left = NULL;
           tree->opval.val = valPlus (valFromType (LETYPE (tree)),
                                      valFromType (RETYPE (tree)));
           tree->right = tree->left = NULL;


@@ -3413,8 +3486,8 @@ decorateType (ast * tree, RESULT_TYPE resultType)
                                  LTYPE (tree));
       else
         {
                                  LTYPE (tree));
       else
         {

-          tree->left  = addCast (tree->left,  resultType, TRUE);
-          tree->right = addCast (tree->right, resultType, TRUE);
+          tree->left  = addCast (tree->left,  resultTypeProp, TRUE);
+          tree->right = addCast (tree->right, resultTypeProp, TRUE);

           TETYPE (tree) = getSpec (TTYPE (tree) =
                                      computeType (LTYPE (tree),
                                                   RTYPE (tree),
           TETYPE (tree) = getSpec (TTYPE (tree) =
                                      computeType (LTYPE (tree),
                                                   RTYPE (tree),


@@ -3448,7 +3521,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
               TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
               return tree;
             }
               TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
               return tree;
             }

-          tree->left  = addCast (tree->left, resultType, TRUE);
+          tree->left  = addCast (tree->left, resultTypeProp, TRUE);

           TETYPE (tree) = getSpec (TTYPE (tree) =
                                      computeType (LTYPE (tree),
                                                   NULL,
           TETYPE (tree) = getSpec (TTYPE (tree) =
                                      computeType (LTYPE (tree),
                                                   NULL,


@@ -3492,8 +3565,8 @@ decorateType (ast * tree, RESULT_TYPE resultType)
       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
         {
           tree->type = EX_VALUE;
       if (IS_LITERAL (RTYPE (tree)) && IS_LITERAL (LTYPE (tree)))
         {
           tree->type = EX_VALUE;

-          tree->left  = addCast (tree->left,  resultType, TRUE);
-          tree->right = addCast (tree->right, resultType, TRUE);
+          tree->left  = addCast (tree->left,  resultTypeProp, TRUE);
+          tree->right = addCast (tree->right, resultTypeProp, TRUE);

           tree->opval.val = valMinus (valFromType (LETYPE (tree)),
                                       valFromType (RETYPE (tree)));
           tree->right = tree->left = NULL;
           tree->opval.val = valMinus (valFromType (LETYPE (tree)),
                                       valFromType (RETYPE (tree)));
           tree->right = tree->left = NULL;


@@ -3507,7 +3580,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
         {
           tree->type = EX_VALUE;
           tree->left = tree->right = NULL;
         {
           tree->type = EX_VALUE;
           tree->left = tree->right = NULL;

-          tree->opval.val = constVal ("0");
+          tree->opval.val = constCharVal (0);

           TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
           return tree;
         }
           TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
           return tree;
         }


@@ -3525,8 +3598,8 @@ decorateType (ast * tree, RESULT_TYPE resultType)
                                  LTYPE (tree));
       else
         {
                                  LTYPE (tree));
       else
         {

-          tree->left  = addCast (tree->left,  resultType, TRUE);
-          tree->right = addCast (tree->right, resultType, TRUE);
+          tree->left  = addCast (tree->left,  resultTypeProp, TRUE);
+          tree->right = addCast (tree->right, resultTypeProp, TRUE);

 
           TETYPE (tree) = getSpec (TTYPE (tree) =
                                      computeType (LTYPE (tree),
 
           TETYPE (tree) = getSpec (TTYPE (tree) =
                                      computeType (LTYPE (tree),


@@ -3542,7 +3615,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
       /* rearrange the tree */
       if (IS_LITERAL (RTYPE (tree))
           /* avoid infinite loop */
       /* rearrange the tree */
       if (IS_LITERAL (RTYPE (tree))
           /* avoid infinite loop */

-          && (TYPE_TARGET_ULONG) floatFromVal (tree->right->opval.val) != 0)
+          && (TYPE_TARGET_ULONG) ulFromVal (tree->right->opval.val) != 0)

         {
           ast *litTree, *litParent;
           litTree = searchLitOp (tree, &litParent, "+-");
         {
           ast *litTree, *litParent;
           litTree = searchLitOp (tree, &litParent, "+-");


@@ -3607,7 +3680,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
           tree->opval.val = valComplement (valFromType (LETYPE (tree)));
           tree->left = NULL;
           TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
           tree->opval.val = valComplement (valFromType (LETYPE (tree)));
           tree->left = NULL;
           TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;

-          return addCast (tree, resultType, TRUE);
+          return addCast (tree, resultTypeProp, TRUE);

         }
 
       if (resultType == RESULT_TYPE_BIT &&
         }
 
       if (resultType == RESULT_TYPE_BIT &&


@@ -3622,10 +3695,10 @@ decorateType (ast * tree, RESULT_TYPE resultType)
 
           /* optimize bit-result, even if we optimize a buggy source */
           tree->type = EX_VALUE;
 
           /* optimize bit-result, even if we optimize a buggy source */
           tree->type = EX_VALUE;

-          tree->opval.val = constVal ("1");
+          tree->opval.val = constCharVal (1);

         }
       else
         }
       else

-        tree->left = addCast (tree->left, resultType, TRUE);
+        tree->left = addCast (tree->left, resultTypeProp, TRUE);

       LRVAL (tree) = 1;
       COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree));
       return tree;
       LRVAL (tree) = 1;
       COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree));
       return tree;


@@ -3645,14 +3718,20 @@ decorateType (ast * tree, RESULT_TYPE resultType)
         }
 
       /* if left is another '!' */
         }
 
       /* if left is another '!' */

-      if (tree->left->opval.op == '!')
+      if (IS_AST_NOT_OPER (tree->left))

         {
         {

+          if ((resultType == RESULT_TYPE_IFX) || (resultType == RESULT_TYPE_BIT))
+            {
+              /* replace double '!!X' by 'X' */
+              return tree->left->left;
+            }

           /* remove double '!!X' by 'X ? 1 : 0' */
           tree->opval.op = '?';
           tree->left  = tree->left->left;
           tree->right = newNode (':',
           /* remove double '!!X' by 'X ? 1 : 0' */
           tree->opval.op = '?';
           tree->left  = tree->left->left;
           tree->right = newNode (':',

-                                  newAst_VALUE (constVal ("1")),
-                                  newAst_VALUE (constVal ("0")));
+                                  newAst_VALUE (constCharVal (1)),
+                                  newAst_VALUE (constCharVal (0)));
+          tree->right->filename = tree->filename;

           tree->right->lineno = tree->lineno;
           tree->decorated = 0;
           return decorateType (tree, resultType);
           tree->right->lineno = tree->lineno;
           tree->decorated = 0;
           return decorateType (tree, resultType);


@@ -3710,7 +3789,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
 
       /* make smaller type only if it's a LEFT_OP */
       if (tree->opval.op == LEFT_OP)
 
       /* make smaller type only if it's a LEFT_OP */
       if (tree->opval.op == LEFT_OP)

-        tree->left = addCast (tree->left, resultType, TRUE);
+        tree->left = addCast (tree->left, resultTypeProp, TRUE);

 
       /* if they are both literal then */
       /* rewrite the tree */
 
       /* if they are both literal then */
       /* rewrite the tree */


@@ -3764,7 +3843,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
       /* if only the right side is a literal & we are
          shifting more than size of the left operand then zero */
       if (IS_LITERAL (RTYPE (tree)) &&
       /* if only the right side is a literal & we are
          shifting more than size of the left operand then zero */
       if (IS_LITERAL (RTYPE (tree)) &&

-          ((TYPE_TARGET_ULONG) floatFromVal (valFromType (RETYPE (tree)))) >=
+          ((TYPE_TARGET_ULONG) ulFromVal (valFromType (RETYPE (tree)))) >=

           (getSize (TETYPE (tree)) * 8))
         {
           if (tree->opval.op==LEFT_OP ||
           (getSize (TETYPE (tree)) * 8))
         {
           if (tree->opval.op==LEFT_OP ||


@@ -3774,7 +3853,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
                       (tree->opval.op == LEFT_OP ? "left" : "right"));
               tree->type = EX_VALUE;
               tree->left = tree->right = NULL;
                       (tree->opval.op == LEFT_OP ? "left" : "right"));
               tree->type = EX_VALUE;
               tree->left = tree->right = NULL;

-              tree->opval.val = constVal ("0");
+              tree->opval.val = constCharVal (0);

               TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
               return tree;
             }
               TETYPE (tree) = TTYPE (tree) = tree->opval.val->type;
               return tree;
             }


@@ -3798,10 +3877,13 @@ decorateType (ast * tree, RESULT_TYPE resultType)
       changePointer(LTYPE(tree));
       checkTypeSanity(LETYPE(tree), "(cast)");
 
       changePointer(LTYPE(tree));
       checkTypeSanity(LETYPE(tree), "(cast)");
 

-      /* if 'from' and 'to' are the same remove the superfluous cast, */
-      /* this helps other optimizations */
+      /* if 'from' and 'to' are the same remove the superfluous cast,
+       * this helps other optimizations */

       if (compareTypeExact (LTYPE(tree), RTYPE(tree), -1) == 1)
         {
       if (compareTypeExact (LTYPE(tree), RTYPE(tree), -1) == 1)
         {

+          /* mark that the explicit cast has been removed,
+           * for proper processing (no integer promotion) of explicitly typecasted variable arguments */
+          tree->right->values.removedCast = 1;

           return tree->right;
         }
 
           return tree->right;
         }
 


@@ -3824,33 +3906,41 @@ decorateType (ast * tree, RESULT_TYPE resultType)
 
 #if 0
       /* if the right is a literal replace the tree */
 
 #if 0
       /* if the right is a literal replace the tree */

-      if (IS_LITERAL (RETYPE (tree))) {
-              if (!IS_PTR (LTYPE (tree))) {
-                      tree->type = EX_VALUE;
-                      tree->opval.val =
-                              valCastLiteral (LTYPE (tree),
-                                              floatFromVal (valFromType (RETYPE (tree))));
-                      tree->left = NULL;
-                      tree->right = NULL;
-                      TTYPE (tree) = tree->opval.val->type;
-                      tree->values.literalFromCast = 1;
-              } else if (IS_GENPTR(LTYPE(tree)) && !IS_PTR(RTYPE(tree)) &&
-                         ((int)floatFromVal(valFromType(RETYPE(tree)))) !=0 ) /* special case of NULL */  {
-                      sym_link *rest = LTYPE(tree)->next;
-                      werrorfl (tree->filename, tree->lineno, W_LITERAL_GENERIC);
-                      TTYPE(tree) = newLink(DECLARATOR);
-                      DCL_TYPE(TTYPE(tree)) = FPOINTER;
-                      TTYPE(tree)->next = rest;
-                      tree->left->opval.lnk = TTYPE(tree);
-                      LRVAL (tree) = 1;
-              } else {
-                      TTYPE (tree) = LTYPE (tree);
-                      LRVAL (tree) = 1;
-              }
-      } else {
+      if (IS_LITERAL (RETYPE (tree)))
+        {
+          if (!IS_PTR (LTYPE (tree)))
+            {
+              tree->type = EX_VALUE;
+              tree->opval.val =
+                      valCastLiteral (LTYPE (tree),
+                                      floatFromVal (valFromType (RETYPE (tree))));
+              tree->left = NULL;
+              tree->right = NULL;
+              TTYPE (tree) = tree->opval.val->type;
+              tree->values.literalFromCast = 1;
+            }
+          else if (IS_GENPTR(LTYPE(tree)) && !IS_PTR(RTYPE(tree)) &&
+                   ((int) ulFromVal(valFromType(RETYPE(tree)))) !=0 ) /* special case of NULL */
+            {
+              sym_link *rest = LTYPE(tree)->next;
+              werrorfl (tree->filename, tree->lineno, W_LITERAL_GENERIC);
+              TTYPE(tree) = newLink(DECLARATOR);
+              DCL_TYPE(TTYPE(tree)) = FPOINTER;
+              TTYPE(tree)->next = rest;
+              tree->left->opval.lnk = TTYPE(tree);
+              LRVAL (tree) = 1;
+            }
+          else
+            {

               TTYPE (tree) = LTYPE (tree);
               LRVAL (tree) = 1;
               TTYPE (tree) = LTYPE (tree);
               LRVAL (tree) = 1;

-      }
+            }
+        }
+      else
+        {
+          TTYPE (tree) = LTYPE (tree);
+          LRVAL (tree) = 1;
+        }

 #else
 #if 0 // this is already checked, now this could be explicit
       /* if pointer to struct then check names */
 #else
 #if 0 // this is already checked, now this could be explicit
       /* if pointer to struct then check names */


@@ -3864,49 +3954,47 @@ decorateType (ast * tree, RESULT_TYPE resultType)
 #endif
       if (IS_ADDRESS_OF_OP(tree->right)
           && IS_AST_SYM_VALUE (tree->right->left)
 #endif
       if (IS_ADDRESS_OF_OP(tree->right)
           && IS_AST_SYM_VALUE (tree->right->left)

-          && SPEC_ABSA (AST_SYMBOL (tree->right->left)->etype)) {
-
-        symbol * sym = AST_SYMBOL (tree->right->left);
-        unsigned int gptype = 0;
-        unsigned int addr = SPEC_ADDR (sym->etype);
+          && SPEC_ABSA (AST_SYMBOL (tree->right->left)->etype))
+        {
+          symbol * sym = AST_SYMBOL (tree->right->left);
+          unsigned int gptype = 0;
+          unsigned int addr = SPEC_ADDR (sym->etype);

 
 

-        if (IS_GENPTR (LTYPE (tree)) && ((GPTRSIZE > FPTRSIZE)
-                                        || TARGET_IS_PIC16) )
-          {
-            switch (SPEC_SCLS (sym->etype))
-              {
-              case S_CODE:
-                gptype = GPTYPE_CODE;
-                break;
-              case S_XDATA:
-                gptype = GPTYPE_FAR;
-                break;
-              case S_DATA:
-              case S_IDATA:
-                gptype = GPTYPE_NEAR;
-                break;
-              case S_PDATA:
-                gptype = GPTYPE_XSTACK;
-                break;
-              default:
-                gptype = 0;
+          if (IS_GENPTR (LTYPE (tree)) && ((GPTRSIZE > FPTRSIZE) || TARGET_IS_PIC16) )
+            {
+              switch (SPEC_SCLS (sym->etype))
+                {
+                case S_CODE:
+                  gptype = GPTYPE_CODE;
+                  break;
+                case S_XDATA:
+                  gptype = GPTYPE_FAR;
+                  break;
+                case S_DATA:
+                case S_IDATA:
+                  gptype = GPTYPE_NEAR;
+                  break;
+                case S_PDATA:
+                  gptype = GPTYPE_XSTACK;
+                  break;
+                default:
+                  gptype = 0;

 
 

-                if(TARGET_IS_PIC16 && (SPEC_SCLS(sym->etype) == S_FIXED))
-                    gptype = GPTYPE_NEAR;
-              }
-            addr |= gptype << (8*(GPTRSIZE - 1));
-          }
+                  if(TARGET_IS_PIC16 && (SPEC_SCLS(sym->etype) == S_FIXED))
+                      gptype = GPTYPE_NEAR;
+                }
+              addr |= gptype << (8*(GPTRSIZE - 1));
+            }

 
 

-        tree->type = EX_VALUE;
-        tree->opval.val =
-          valCastLiteral (LTYPE (tree), addr);
-        TTYPE (tree) = tree->opval.val->type;
-        TETYPE (tree) = getSpec (TTYPE (tree));
-        tree->left = NULL;
-        tree->right = NULL;
-        tree->values.literalFromCast = 1;
-        return tree;
-      }
+          tree->type = EX_VALUE;
+          tree->opval.val = valCastLiteral (LTYPE (tree), addr);
+          TTYPE (tree) = tree->opval.val->type;
+          TETYPE (tree) = getSpec (TTYPE (tree));
+          tree->left = NULL;
+          tree->right = NULL;
+          tree->values.literalFromCast = 1;
+          return tree;
+        }

 
       /* handle offsetof macro:            */
       /* #define offsetof(TYPE, MEMBER) \  */
 
       /* handle offsetof macro:            */
       /* #define offsetof(TYPE, MEMBER) \  */


@@ -3916,83 +4004,91 @@ decorateType (ast * tree, RESULT_TYPE resultType)
           && tree->right->left->opval.op == PTR_OP
           && IS_AST_OP (tree->right->left->left)
           && tree->right->left->left->opval.op == CAST
           && tree->right->left->opval.op == PTR_OP
           && IS_AST_OP (tree->right->left->left)
           && tree->right->left->left->opval.op == CAST

-          && IS_AST_LIT_VALUE(tree->right->left->left->right)) {
-
-        symbol *element = getStructElement (
-          SPEC_STRUCT (LETYPE(tree->right->left)),
-          AST_SYMBOL(tree->right->left->right)
-        );
-
-        if (element) {
-          tree->type = EX_VALUE;
-          tree->opval.val = valCastLiteral (
-            LTYPE (tree),
-            element->offset
-            + floatFromVal (valFromType (RTYPE (tree->right->left->left)))
+          && IS_AST_LIT_VALUE(tree->right->left->left->right))
+        {
+          symbol *element = getStructElement (
+            SPEC_STRUCT (LETYPE(tree->right->left)),
+            AST_SYMBOL(tree->right->left->right)

           );
 
           );
 

-          TTYPE (tree) = tree->opval.val->type;
-          TETYPE (tree) = getSpec (TTYPE (tree));
-          tree->left = NULL;
-          tree->right = NULL;
-          return tree;
-        }
+          if (element)
+            {
+              tree->type = EX_VALUE;
+              tree->opval.val = valCastLiteral (
+                LTYPE (tree),
+                element->offset
+                + floatFromVal (valFromType (RTYPE (tree->right->left->left)))
+              );
+
+            TTYPE (tree) = tree->opval.val->type;
+            TETYPE (tree) = getSpec (TTYPE (tree));
+            tree->left = NULL;
+            tree->right = NULL;
+            return tree;
+          }

       }
 
       /* if the right is a literal replace the tree */
       }
 
       /* if the right is a literal replace the tree */

-      if (IS_LITERAL (RETYPE (tree))) {
-        #if 0
-        if (IS_PTR (LTYPE (tree)) && !IS_GENPTR (LTYPE (tree)) ) {
-          /* rewrite      (type *)litaddr
-             as           &temp
-             and define   type at litaddr temp
-             (but only if type's storage class is not generic)
-          */
-          ast *newTree = newNode ('&', NULL, NULL);
-          symbol *sym;
-
-          TTYPE (newTree) = LTYPE (tree);
-          TETYPE (newTree) = getSpec(LTYPE (tree));
-
-          /* define a global symbol at the casted address*/
-          sym = newSymbol(genSymName (0), 0);
-          sym->type = LTYPE (tree)->next;
-          if (!sym->type)
-            sym->type = newLink (V_VOID);
-          sym->etype = getSpec(sym->type);
-          SPEC_SCLS (sym->etype) = sclsFromPtr (LTYPE (tree));
-          sym->lineDef = tree->lineno;
-          sym->cdef = 1;
-          sym->isref = 1;
-          SPEC_STAT (sym->etype) = 1;
-          SPEC_ADDR(sym->etype) = floatFromVal (valFromType (RTYPE (tree)));
-          SPEC_ABSA(sym->etype) = 1;
-          addSym (SymbolTab, sym, sym->name, 0, 0, 0);
-          allocGlobal (sym);
-
-          newTree->left = newAst_VALUE(symbolVal(sym));
-          newTree->left->lineno = tree->lineno;
-          LTYPE (newTree) = sym->type;
-          LETYPE (newTree) = sym->etype;
-          LLVAL (newTree) = 1;
-          LRVAL (newTree) = 0;
-          TLVAL (newTree) = 1;
-          return newTree;
-        }
-        #endif
-        if (!IS_PTR (LTYPE (tree))) {
-          tree->type = EX_VALUE;
-          tree->opval.val =
-          valCastLiteral (LTYPE (tree),
-                          floatFromVal (valFromType (RTYPE (tree))));
-          TTYPE (tree) = tree->opval.val->type;
-          tree->left = NULL;
-          tree->right = NULL;
-          tree->values.literalFromCast = 1;
-          TETYPE (tree) = getSpec (TTYPE (tree));
-          return tree;
+      if (IS_LITERAL (RETYPE (tree)))
+        {
+          #if 0
+          if (IS_PTR (LTYPE (tree)) && !IS_GENPTR (LTYPE (tree)) )
+            {
+              /* rewrite      (type *)litaddr
+                 as           &temp
+                 and define   type at litaddr temp
+                 (but only if type's storage class is not generic)
+              */
+              ast *newTree = newNode ('&', NULL, NULL);
+              symbol *sym;
+
+              TTYPE (newTree) = LTYPE (tree);
+              TETYPE (newTree) = getSpec(LTYPE (tree));
+
+              /* define a global symbol at the casted address*/
+              sym = newSymbol(genSymName (0), 0);
+              sym->type = LTYPE (tree)->next;
+              if (!sym->type)
+                sym->type = newLink (V_VOID);
+              sym->etype = getSpec(sym->type);
+              SPEC_SCLS (sym->etype) = sclsFromPtr (LTYPE (tree));
+              sym->lineDef = tree->lineno;
+              sym->cdef = 1;
+              sym->isref = 1;
+              SPEC_STAT (sym->etype) = 1;
+              SPEC_ADDR(sym->etype) = floatFromVal (valFromType (RTYPE (tree)));
+              SPEC_ABSA(sym->etype) = 1;
+              addSym (SymbolTab, sym, sym->name, 0, 0, 0);
+              allocGlobal (sym);
+
+              newTree->left = newAst_VALUE(symbolVal(sym));
+              newTree->left->filename = tree->filename;
+              newTree->left->lineno = tree->lineno;
+              LTYPE (newTree) = sym->type;
+              LETYPE (newTree) = sym->etype;
+              LLVAL (newTree) = 1;
+              LRVAL (newTree) = 0;
+              TLVAL (newTree) = 1;
+              return newTree;
+            }
+          #endif
+          if (!IS_PTR (LTYPE (tree)))
+            {
+              tree->type = EX_VALUE;
+              tree->opval.val =
+                valCastLiteral (LTYPE (tree), floatFromVal (valFromType (RTYPE (tree))));
+              TTYPE (tree) = tree->opval.val->type;
+              tree->left = NULL;
+              tree->right = NULL;
+              tree->values.literalFromCast = 1;
+              TETYPE (tree) = getSpec (TTYPE (tree));
+              return tree;
+            }
+        }
+      if (IS_GENPTR (LTYPE (tree)) && IS_PTR (RTYPE (tree)) && !IS_GENPTR (RTYPE (tree)) && (resultType != RESULT_TYPE_GPTR))
+        {
+          DCL_TYPE (LTYPE (tree)) = DCL_TYPE (RTYPE (tree));

         }
         }

-      }

       TTYPE (tree) = LTYPE (tree);
       LRVAL (tree) = 1;
 
       TTYPE (tree) = LTYPE (tree);
       LRVAL (tree) = 1;
 


@@ -4116,9 +4212,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
                 if (!options.lessPedantic)
                   werrorfl (tree->filename, tree->lineno, W_COMP_RANGE,
                           ccr_result == CCR_ALWAYS_TRUE ? "true" : "false");
                 if (!options.lessPedantic)
                   werrorfl (tree->filename, tree->lineno, W_COMP_RANGE,
                           ccr_result == CCR_ALWAYS_TRUE ? "true" : "false");

-                return decorateType (newAst_VALUE (constVal (
-                                   ccr_result == CCR_ALWAYS_TRUE ? "1" : "0")),
-                                                   resultType);
+                return decorateType (newAst_VALUE (constCharVal ((unsigned char)(ccr_result == CCR_ALWAYS_TRUE))), resultType);

               case CCR_OK:
               default:
                 break;
               case CCR_OK:
               default:
                 break;


@@ -4129,9 +4223,9 @@ decorateType (ast * tree, RESULT_TYPE resultType)
       if (tree->opval.op == '>' &&
           SPEC_USIGN(LETYPE(tree)) &&
           IS_LITERAL(RTYPE(tree))  &&
       if (tree->opval.op == '>' &&
           SPEC_USIGN(LETYPE(tree)) &&
           IS_LITERAL(RTYPE(tree))  &&

-          ((int) floatFromVal (valFromType (RETYPE (tree)))) == 0)
+          ((int) ulFromVal (valFromType (RETYPE (tree)))) == 0)

         {
         {

-          if (resultType == RESULT_TYPE_IFX)
+          if ((resultType == RESULT_TYPE_IFX) || (resultType == RESULT_TYPE_BIT))

             {
               /* the parent is an ifx: */
               /* if (unsigned value) */
             {
               /* the parent is an ifx: */
               /* if (unsigned value) */


@@ -4141,9 +4235,11 @@ decorateType (ast * tree, RESULT_TYPE resultType)
           /* (unsigned value) ? 1 : 0 */
           tree->opval.op = '?';
           tree->right = newNode (':',
           /* (unsigned value) ? 1 : 0 */
           tree->opval.op = '?';
           tree->right = newNode (':',

-                                  newAst_VALUE (constVal ("1")),
+                                  newAst_VALUE (constCharVal (1)),

                                   tree->right); /* val 0 */
                                   tree->right); /* val 0 */

+          tree->right->filename = tree->filename;

           tree->right->lineno = tree->lineno;
           tree->right->lineno = tree->lineno;

+          tree->right->left->filename = tree->filename;

           tree->right->left->lineno = tree->lineno;
           tree->decorated = 0;
           return decorateType (tree, resultType);
           tree->right->left->lineno = tree->lineno;
           tree->decorated = 0;
           return decorateType (tree, resultType);


@@ -4153,7 +4249,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
       if (IS_LITERAL(RTYPE(tree))  &&
           floatFromVal (valFromType (RETYPE (tree))) == 0 &&
           tree->opval.op == EQ_OP &&
       if (IS_LITERAL(RTYPE(tree))  &&
           floatFromVal (valFromType (RETYPE (tree))) == 0 &&
           tree->opval.op == EQ_OP &&

-          resultType == RESULT_TYPE_IFX)
+          (resultType == RESULT_TYPE_IFX || resultType == RESULT_TYPE_BIT))

         {
           tree->opval.op = '!';
           tree->right = NULL;
         {
           tree->opval.op = '!';
           tree->right = NULL;


@@ -4188,14 +4284,14 @@ decorateType (ast * tree, RESULT_TYPE resultType)
           if (IS_LITERAL (RTYPE (tree)) && IS_UNSIGNED (RTYPE (tree)) &&
               /* the value range of a 'unsigned char' is 0...255;
                  if the actual value is < 128 it can be changed to signed */
           if (IS_LITERAL (RTYPE (tree)) && IS_UNSIGNED (RTYPE (tree)) &&
               /* the value range of a 'unsigned char' is 0...255;
                  if the actual value is < 128 it can be changed to signed */

-              (int) floatFromVal (valFromType (RETYPE (tree))) < 128)
+              (int) ulFromVal (valFromType (RETYPE (tree))) < 128)

             {
               /* now we've got 2 'signed char'! */
               SPEC_USIGN (RETYPE (tree)) = 0;
             }
                    /* same test for the left operand: */
           else if (IS_LITERAL (LTYPE (tree)) && IS_UNSIGNED (LTYPE (tree)) &&
             {
               /* now we've got 2 'signed char'! */
               SPEC_USIGN (RETYPE (tree)) = 0;
             }
                    /* same test for the left operand: */
           else if (IS_LITERAL (LTYPE (tree)) && IS_UNSIGNED (LTYPE (tree)) &&

-              (int) floatFromVal (valFromType (LETYPE (tree))) < 128)
+              (int) ulFromVal (valFromType (LETYPE (tree))) < 128)

             {
               SPEC_USIGN (LETYPE (tree)) = 0;
             }
             {
               SPEC_USIGN (LETYPE (tree)) = 0;
             }


@@ -4208,7 +4304,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
         }
 
       LRVAL (tree) = RRVAL (tree) = 1;
         }
 
       LRVAL (tree) = RRVAL (tree) = 1;

-      TTYPE (tree) = TETYPE (tree) = newBoolLink ();
+      TTYPE (tree) = TETYPE (tree) = (resultType == RESULT_TYPE_BIT) ? newBoolLink() :newCharLink();

 
       /* condition transformations */
       {
 
       /* condition transformations */
       {


@@ -4248,6 +4344,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
             tree->opval.op = transformedOp;
             tree->decorated = 0;
             tree = newNode ('!', tree, NULL);
             tree->opval.op = transformedOp;
             tree->decorated = 0;
             tree = newNode ('!', tree, NULL);

+            tree->filename = tree->left->filename;

             tree->lineno = tree->left->lineno;
             return decorateType (tree, resultType);
           }
             tree->lineno = tree->left->lineno;
             return decorateType (tree, resultType);
           }


@@ -4362,21 +4459,55 @@ decorateType (ast * tree, RESULT_TYPE resultType)
     case '?':
       /* the type is value of the colon operator (on the right) */
       assert (IS_COLON_OP (tree->right));
     case '?':
       /* the type is value of the colon operator (on the right) */
       assert (IS_COLON_OP (tree->right));

-      /* if already known then replace the tree : optimizer will do it
-         but faster to do it here */
+
+      /* If already known then replace the tree : optimizer will do it
+         but faster to do it here. If done before decorating tree->right
+         this can save generating unused const strings. */

       if (IS_LITERAL (LTYPE (tree)))
         {
       if (IS_LITERAL (LTYPE (tree)))
         {

-          if (((int) floatFromVal (valFromType (LETYPE (tree)))) != 0)
+          if (((int) ulFromVal (valFromType (LETYPE (tree)))) != 0)

             return decorateType (tree->right->left, resultTypeProp);
           else
             return decorateType (tree->right->right, resultTypeProp);
         }
             return decorateType (tree->right->left, resultTypeProp);
           else
             return decorateType (tree->right->right, resultTypeProp);
         }

-      else
+
+      tree->right = decorateType (tree->right,  resultTypeProp);
+
+      if (IS_AST_LIT_VALUE (tree->right->left) && IS_AST_LIT_VALUE (tree->right->right) &&
+          ((resultType == RESULT_TYPE_IFX) || (resultType == RESULT_TYPE_BIT)))

         {
         {

-          tree->right = decorateType (tree->right, resultTypeProp);
-          TTYPE (tree) = RTYPE (tree);
-          TETYPE (tree) = getSpec (TTYPE (tree));
+          double valTrue = AST_FLOAT_VALUE (tree->right->left);
+          double valFalse = AST_FLOAT_VALUE (tree->right->right);
+
+          if ((valTrue != 0) && (valFalse == 0))
+            {
+              /* assign cond to result */
+              tree->left->decorated = 0;
+              return decorateType (tree->left, resultTypeProp);
+            }
+          else if ((valTrue == 0) && (valFalse != 0))
+            {
+              /* assign !cond to result */
+              tree->opval.op = '!';
+              tree->decorated = 0;
+              tree->right = NULL;
+              return decorateType (tree, resultTypeProp);
+            }
+          else
+            {
+              /* they have the same boolean value, make them equal */
+              tree->right->left = tree->right->right;
+            }

         }
         }

+
+      /* if they are equal then replace the tree */
+      if (isAstEqual (tree->right->left, tree->right->right))
+        {
+          return tree->right->left;
+        }
+
+      TTYPE (tree) = RTYPE (tree);
+      TETYPE (tree) = getSpec (TTYPE (tree));

       return tree;
 
     case ':':
       return tree;
 
     case ':':


@@ -4560,8 +4691,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
           printFromToType(RTYPE(tree), LTYPE(tree));
         }
 
           printFromToType(RTYPE(tree), LTYPE(tree));
         }
 

-      TETYPE (tree) = getSpec (TTYPE (tree) =
-                               LTYPE (tree));
+      TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree));

       RRVAL (tree) = 1;
       LLVAL (tree) = 1;
       if (!tree->initMode ) {
       RRVAL (tree) = 1;
       LLVAL (tree) = 1;
       if (!tree->initMode ) {


@@ -4667,7 +4797,7 @@ decorateType (ast * tree, RESULT_TYPE resultType)
             decorateType (newNode (CAST,
                           newAst_LINK (copyLinkChain (currFunc->type->next)),
                                         tree->right),
             decorateType (newNode (CAST,
                           newAst_LINK (copyLinkChain (currFunc->type->next)),
                                         tree->right),

-                          RESULT_TYPE_NONE);
+                          IS_GENPTR (currFunc->type->next) ? RESULT_TYPE_GPTR : RESULT_TYPE_NONE);

         }
 
       RRVAL (tree) = 1;
         }
 
       RRVAL (tree) = 1;


@@ -4908,6 +5038,7 @@ createBlock (symbol * decl, ast * body)
   ex->values.sym = decl;
 
   ex->level++;
   ex->values.sym = decl;
 
   ex->level++;

+  ex->filename = NULL;

   ex->lineno = 0;
   return ex;
 }
   ex->lineno = 0;
   return ex;
 }


@@ -4944,6 +5075,7 @@ createLabel (symbol * label, ast * stmnt)
   label->islbl = 1;
   label->key = labelKey++;
   rValue = newNode (LABEL, newAst_VALUE (symbolVal (label)), stmnt);
   label->islbl = 1;
   label->key = labelKey++;
   rValue = newNode (LABEL, newAst_VALUE (symbolVal (label)), stmnt);

+  rValue->filename = NULL;

   rValue->lineno = 0;
 
   return rValue;
   rValue->lineno = 0;
 
   return rValue;


@@ -4989,8 +5121,8 @@ createCase (ast * swStat, ast * caseVal, ast * stmnt)
     {
       /* also order the cases according to value */
       value *pval = NULL;
     {
       /* also order the cases according to value */
       value *pval = NULL;

-      int cVal = (int) floatFromVal (caseVal->opval.val);
-      while (val && (int) floatFromVal (val) < cVal)
+      int cVal = (int) ulFromVal (caseVal->opval.val);
+      while (val && (int) ulFromVal (val) < cVal)

         {
           pval = val;
           val = val->next;
         {
           pval = val;
           val = val->next;


@@ -5001,7 +5133,7 @@ createCase (ast * swStat, ast * caseVal, ast * stmnt)
         {
           pval->next = caseVal->opval.val;
         }
         {
           pval->next = caseVal->opval.val;
         }

-      else if ((int) floatFromVal (val) == cVal)
+      else if ((int) ulFromVal (val) == cVal)

         {
           werrorfl (caseVal->filename, caseVal->lineno, E_DUPLICATE_LABEL,
                     "case");
         {
           werrorfl (caseVal->filename, caseVal->lineno, E_DUPLICATE_LABEL,
                     "case");


@@ -5028,9 +5160,10 @@ createCase (ast * swStat, ast * caseVal, ast * stmnt)
   SNPRINTF(caseLbl, sizeof(caseLbl),
            "_case_%d_%d",
            swStat->values.switchVals.swNum,
   SNPRINTF(caseLbl, sizeof(caseLbl),
            "_case_%d_%d",
            swStat->values.switchVals.swNum,

-           (int) floatFromVal (caseVal->opval.val));
+           (int) ulFromVal (caseVal->opval.val));

 
   rexpr = createLabel (newSymbol (caseLbl, 0), stmnt);
 
   rexpr = createLabel (newSymbol (caseLbl, 0), stmnt);

+  rexpr->filename = 0;

   rexpr->lineno = 0;
   return rexpr;
 }
   rexpr->lineno = 0;
   return rexpr;
 }


@@ -5266,10 +5399,12 @@ createWhile (symbol * trueLabel, symbol * continueLabel,
   /* put the continue label */
   condExpr = backPatchLabels (condExpr, trueLabel, falseLabel);
   condExpr = createLabel (continueLabel, condExpr);
   /* put the continue label */
   condExpr = backPatchLabels (condExpr, trueLabel, falseLabel);
   condExpr = createLabel (continueLabel, condExpr);

+  condExpr->filename = NULL;

   condExpr->lineno = 0;
 
   /* put the body label in front of the body */
   whileBody = createLabel (trueLabel, whileBody);
   condExpr->lineno = 0;
 
   /* put the body label in front of the body */
   whileBody = createLabel (trueLabel, whileBody);

+  whileBody->filename = NULL;

   whileBody->lineno = 0;
   /* put a jump to continue at the end of the body */
   /* and put break label at the end of the body */
   whileBody->lineno = 0;
   /* put a jump to continue at the end of the body */
   /* and put break label at the end of the body */


@@ -5332,7 +5467,7 @@ isBitAndPow2 (ast * tree)
   if (!IS_AST_LIT_VALUE (tree->right))
     return -1;
 
   if (!IS_AST_LIT_VALUE (tree->right))
     return -1;
 

-  return powof2 ((TYPE_TARGET_ULONG)AST_LIT_VALUE (tree->right));
+  return powof2 (AST_ULONG_VALUE (tree->right));

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -5341,14 +5476,14 @@ isBitAndPow2 (ast * tree)
 ast *
 optimizeGetHbit (ast * tree, RESULT_TYPE resultType)
 {
 ast *
 optimizeGetHbit (ast * tree, RESULT_TYPE resultType)
 {

-  int i, j;
+  unsigned int i, j;

   ast * expr;
 
   expr = isShiftRightLitVal_BitAndLitVal(tree);
   if (expr)
     {
   ast * expr;
 
   expr = isShiftRightLitVal_BitAndLitVal(tree);
   if (expr)
     {

-      if ((AST_LIT_VALUE (tree->right) != 1) ||
-          ((i = (int) AST_LIT_VALUE (tree->left->right)) !=
+      if ((AST_ULONG_VALUE (tree->right) != 1) ||
+          ((i = AST_ULONG_VALUE (tree->left->right)) !=

           (j = (getSize (TTYPE (expr)) * 8 - 1))))
         expr = NULL;
     }
           (j = (getSize (TTYPE (expr)) * 8 - 1))))
         expr = NULL;
     }


@@ -5381,7 +5516,7 @@ optimizeGetAbit (ast * tree, RESULT_TYPE resultType)
   expr = isShiftRightLitVal_BitAndLitVal(tree);
   if (expr)
     {
   expr = isShiftRightLitVal_BitAndLitVal(tree);
   if (expr)
     {

-  if (AST_LIT_VALUE (tree->right) != 1)
+  if (AST_ULONG_VALUE (tree->right) != 1)

         expr = NULL;
       count = tree->left->right;
     }
         expr = NULL;
       count = tree->left->right;
     }


@@ -5419,9 +5554,9 @@ optimizeGetByte (ast * tree, RESULT_TYPE resultType)
   expr = isShiftRightLitVal_BitAndLitVal(tree);
   if (expr)
     {
   expr = isShiftRightLitVal_BitAndLitVal(tree);
   if (expr)
     {

-      i = (unsigned int) AST_LIT_VALUE (tree->left->right);
+      i = AST_ULONG_VALUE (tree->left->right);

       count = tree->left->right;
       count = tree->left->right;

-      if (AST_LIT_VALUE (tree->right) != 0xFF)
+      if (AST_ULONG_VALUE (tree->right) != 0xFF)

         expr = NULL;
     }
   if (!expr && resultType == RESULT_TYPE_CHAR)
         expr = NULL;
     }
   if (!expr && resultType == RESULT_TYPE_CHAR)


@@ -5429,7 +5564,7 @@ optimizeGetByte (ast * tree, RESULT_TYPE resultType)
       /* if this is a right shift over a multiple of 8 */
       if (IS_RIGHT_OP (tree) && IS_AST_LIT_VALUE (tree->right))
         {
       /* if this is a right shift over a multiple of 8 */
       if (IS_RIGHT_OP (tree) && IS_AST_LIT_VALUE (tree->right))
         {

-          i = (unsigned int) AST_LIT_VALUE (tree->right);
+          i = AST_ULONG_VALUE (tree->right);

           count = tree->right;
             expr = tree->left;
         }
           count = tree->right;
             expr = tree->left;
         }


@@ -5458,9 +5593,9 @@ optimizeGetWord (ast * tree, RESULT_TYPE resultType)
   expr = isShiftRightLitVal_BitAndLitVal(tree);
   if (expr)
     {
   expr = isShiftRightLitVal_BitAndLitVal(tree);
   if (expr)
     {

-      i = (unsigned int) AST_LIT_VALUE (tree->left->right);
+      i = AST_ULONG_VALUE (tree->left->right);

       count = tree->left->right;
       count = tree->left->right;

-      if (AST_LIT_VALUE (tree->right) != 0xFFFF)
+      if (AST_ULONG_VALUE (tree->right) != 0xFFFF)

         expr = NULL;
     }
   if (!expr && resultType == RESULT_TYPE_INT)
         expr = NULL;
     }
   if (!expr && resultType == RESULT_TYPE_INT)


@@ -5468,7 +5603,7 @@ optimizeGetWord (ast * tree, RESULT_TYPE resultType)
       /* if this is a right shift over a multiple of 8 */
       if (IS_RIGHT_OP (tree) && IS_AST_LIT_VALUE (tree->right))
         {
       /* if this is a right shift over a multiple of 8 */
       if (IS_RIGHT_OP (tree) && IS_AST_LIT_VALUE (tree->right))
         {

-          i = (unsigned int) AST_LIT_VALUE (tree->right);
+          i = AST_ULONG_VALUE (tree->right);

           count = tree->right;
             expr = tree->left;
         }
           count = tree->right;
             expr = tree->left;
         }


@@ -5524,10 +5659,10 @@ optimizeRRCRLC (ast * root)
                        root->right->left))
         goto tryNext0;
 
                        root->right->left))
         goto tryNext0;
 

-      if (AST_LIT_VALUE (root->left->right) != 1)
+      if (AST_ULONG_VALUE (root->left->right) != 1)

         goto tryNext0;
 
         goto tryNext0;
 

-      if (AST_LIT_VALUE (root->right->right) !=
+      if (AST_ULONG_VALUE (root->right->right) !=

           (getSize (TTYPE (root->left->left)) * 8 - 1))
         goto tryNext0;
 
           (getSize (TTYPE (root->left->left)) * 8 - 1))
         goto tryNext0;
 


@@ -5559,10 +5694,10 @@ tryNext0:
                        root->right->left))
         goto tryNext1;
 
                        root->right->left))
         goto tryNext1;
 

-      if (AST_LIT_VALUE (root->right->right) != 1)
+      if (AST_ULONG_VALUE (root->right->right) != 1)

         goto tryNext1;
 
         goto tryNext1;
 

-      if (AST_LIT_VALUE (root->left->right) !=
+      if (AST_ULONG_VALUE (root->left->right) !=

           (getSize (TTYPE (root->left->left)) * 8 - 1))
         goto tryNext1;
 
           (getSize (TTYPE (root->left->left)) * 8 - 1))
         goto tryNext1;
 


@@ -5595,10 +5730,10 @@ tryNext1:
                        root->right->left))
         goto tryNext2;
 
                        root->right->left))
         goto tryNext2;
 

-      if (AST_LIT_VALUE (root->left->right) != 1)
+      if (AST_ULONG_VALUE (root->left->right) != 1)

         goto tryNext2;
 
         goto tryNext2;
 

-      if (AST_LIT_VALUE (root->right->right) !=
+      if (AST_ULONG_VALUE (root->right->right) !=

           (getSize (TTYPE (root->left->left)) * 8 - 1))
         goto tryNext2;
 
           (getSize (TTYPE (root->left->left)) * 8 - 1))
         goto tryNext2;
 


@@ -5630,10 +5765,10 @@ tryNext2:
                        root->right->left))
         return root;
 
                        root->right->left))
         return root;
 

-      if (AST_LIT_VALUE (root->right->right) != 1)
+      if (AST_ULONG_VALUE (root->right->right) != 1)

         return root;
 
         return root;
 

-      if (AST_LIT_VALUE (root->left->right) !=
+      if (AST_ULONG_VALUE (root->left->right) !=

           (getSize (TTYPE (root->left->left)) * 8 - 1))
         return root;
 
           (getSize (TTYPE (root->left->left)) * 8 - 1))
         return root;
 


@@ -5684,11 +5819,11 @@ optimizeSWAP (ast * root)
                        root->right->left))
         return root;
 
                        root->right->left))
         return root;
 

-      if (AST_LIT_VALUE (root->left->right) !=
+      if (AST_ULONG_VALUE (root->left->right) !=

           (getSize (TTYPE (root->left->left)) * 4))
         return root;
 
           (getSize (TTYPE (root->left->left)) * 4))
         return root;
 

-      if (AST_LIT_VALUE (root->right->right) !=
+      if (AST_ULONG_VALUE (root->right->right) !=

           (getSize (TTYPE (root->left->left)) * 4))
         return root;
 
           (getSize (TTYPE (root->left->left)) * 4))
         return root;
 


@@ -5738,12 +5873,12 @@ optimizeCompare (ast * root)
         case '>':
         case '<':
         case NE_OP:
         case '>':
         case '<':
         case NE_OP:

-          optExpr = newAst_VALUE (constVal ("0"));
+          optExpr = newAst_VALUE (constCharVal (0));

           break;
         case GE_OP:
         case LE_OP:
         case EQ_OP:
           break;
         case GE_OP:
         case LE_OP:
         case EQ_OP:

-          optExpr = newAst_VALUE (constVal ("1"));
+          optExpr = newAst_VALUE (constCharVal (1));

           break;
         }
 
           break;
         }
 


@@ -5757,8 +5892,8 @@ optimizeCompare (ast * root)
             root->right->opval.val : NULL);
 
   /* if left is a BITVAR in BITSPACE */
             root->right->opval.val : NULL);
 
   /* if left is a BITVAR in BITSPACE */

-  /* and right is a LITERAL then opt- */
-  /* imize else do nothing       */
+  /* and right is a LITERAL then     */
+  /* optimize else do nothing        */

   if (vleft && vright &&
       IS_BITVAR (vleft->etype) &&
       IN_BITSPACE (SPEC_OCLS (vleft->etype)) &&
   if (vleft && vright &&
       IS_BITVAR (vleft->etype) &&
       IN_BITSPACE (SPEC_OCLS (vleft->etype)) &&


@@ -5766,7 +5901,7 @@ optimizeCompare (ast * root)
     {
 
       /* if right side > 1 then comparison may never succeed */
     {
 
       /* if right side > 1 then comparison may never succeed */

-      if ((litValue = (int) floatFromVal (vright)) > 1)
+      if ((litValue = (int) ulFromVal (vright)) > 1)

         {
           werror (W_BAD_COMPARE);
           goto noOptimize;
         {
           werror (W_BAD_COMPARE);
           goto noOptimize;


@@ -5882,8 +6017,6 @@ DEFSETFUNC (resetParmKey)
   return 1;
 }
 
   return 1;
 }
 

-
-

 /*------------------------------------------------------------------*/
 /* fixupInlineLabel - change a label in an inlined function so that */
 /*                    it is always unique no matter how many times  */
 /*------------------------------------------------------------------*/
 /* fixupInlineLabel - change a label in an inlined function so that */
 /*                    it is always unique no matter how many times  */


@@ -5893,12 +6026,11 @@ static void
 fixupInlineLabel (symbol * sym)
 {
   char name[SDCC_NAME_MAX + 1];
 fixupInlineLabel (symbol * sym)
 {
   char name[SDCC_NAME_MAX + 1];

-  
+

   SNPRINTF(name, sizeof(name), "%s_%d", sym->name, inlineState.count);
   strcpy (sym->name, name);
 }
 
   SNPRINTF(name, sizeof(name), "%s_%d", sym->name, inlineState.count);
   strcpy (sym->name, name);
 }
 

-

 /*------------------------------------------------------------------*/
 /* copyAstLoc - copy location information (file, line, block, etc.) */
 /*              from one ast node to another                        */
 /*------------------------------------------------------------------*/
 /* copyAstLoc - copy location information (file, line, block, etc.) */
 /*              from one ast node to another                        */


@@ -5906,15 +6038,13 @@ fixupInlineLabel (symbol * sym)
 static void
 copyAstLoc (ast * dest, ast * src)
 {
 static void
 copyAstLoc (ast * dest, ast * src)
 {

-  dest->lineno = src->lineno;

   dest->filename = src->filename;
   dest->filename = src->filename;

+  dest->lineno = src->lineno;

   dest->level = src->level;
   dest->block = src->block;
   dest->seqPoint = src->seqPoint;
   dest->level = src->level;
   dest->block = src->block;
   dest->seqPoint = src->seqPoint;

-  

 }
 
 }
 

-

 /*-----------------------------------------------------------------*/
 /* fixupInline - perform various fixups on an inline function tree */
 /*               to take into account that it is no longer a       */
 /*-----------------------------------------------------------------*/
 /* fixupInline - perform various fixups on an inline function tree */
 /*               to take into account that it is no longer a       */


@@ -5923,13 +6053,13 @@ copyAstLoc (ast * dest, ast * src)
 static void
 fixupInline (ast * tree, int level)
 {
 static void
 fixupInline (ast * tree, int level)
 {

-  tree->block = currBlockno;
+  int savedBlockno = currBlockno;

 
   if (IS_AST_OP (tree) && (tree->opval.op == BLOCK))
     {
       symbol * decls;
 
 
   if (IS_AST_OP (tree) && (tree->opval.op == BLOCK))
     {
       symbol * decls;
 

-      currBlockno++;
+      currBlockno = ++blockNo;

       level++;
 
       /* Add any declared variables back into the symbol table */
       level++;
 
       /* Add any declared variables back into the symbol table */


@@ -5944,6 +6074,7 @@ fixupInline (ast * tree, int level)
     }
 
   tree->level = level;
     }
 
   tree->level = level;

+  tree->block = currBlockno;

 
   /* Update symbols */
   if (IS_AST_VALUE (tree) &&
 
   /* Update symbols */
   if (IS_AST_VALUE (tree) &&


@@ -5954,6 +6085,10 @@ fixupInline (ast * tree, int level)
       sym->level = level;
       sym->block = currBlockno;
 
       sym->level = level;
       sym->block = currBlockno;
 

+      sym->reqv = NULL;
+      SYM_SPIL_LOC (sym) = NULL;
+      sym->key = 0;
+

       /* If the symbol is a label, we need to renumber it */
       if (sym->islbl)
         fixupInlineLabel (sym);
       /* If the symbol is a label, we need to renumber it */
       if (sym->islbl)
         fixupInlineLabel (sym);


@@ -5993,10 +6128,10 @@ fixupInline (ast * tree, int level)
       tree->right = gotoTree;
     }
 
       tree->right = gotoTree;
     }
 

-   /* Update any children */
-   if (tree->left)
+  /* Update any children */
+  if (tree->left)

       fixupInline (tree->left, level);
       fixupInline (tree->left, level);

-   if (tree->right)
+  if (tree->right)

       fixupInline (tree->right, level);
 
   if (IS_AST_OP (tree) && (tree->opval.op == LABEL))
       fixupInline (tree->right, level);
 
   if (IS_AST_OP (tree) && (tree->opval.op == LABEL))


@@ -6008,10 +6143,10 @@ fixupInline (ast * tree, int level)
       addSym (LabelTab, label, label->name, label->level, 0, 0);
     }
 
       addSym (LabelTab, label, label->name, label->level, 0, 0);
     }
 

-

   if (IS_AST_OP (tree) && (tree->opval.op == BLOCK))
     {
       level--;
   if (IS_AST_OP (tree) && (tree->opval.op == BLOCK))
     {
       level--;

+      currBlockno = savedBlockno;

     }
 }
 
     }
 }
 


@@ -6023,6 +6158,9 @@ fixupInline (ast * tree, int level)
 static void
 inlineAddDecl (symbol * sym, ast * block, int addSymTab)
 {
 static void
 inlineAddDecl (symbol * sym, ast * block, int addSymTab)
 {

+  sym->reqv = NULL;
+  SYM_SPIL_LOC (sym) = NULL;
+  sym->key = 0;

   if (block != NULL)
     {
       symbol **decl = &(block->values.sym);
   if (block != NULL)
     {
       symbol **decl = &(block->values.sym);


@@ -6045,7 +6183,6 @@ inlineAddDecl (symbol * sym, ast * block, int addSymTab)
     }
 }
 
     }
 }
 

-

 /*-----------------------------------------------------------------*/
 /* inlineTempVar - create a temporary variable for inlining        */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
 /* inlineTempVar - create a temporary variable for inlining        */
 /*-----------------------------------------------------------------*/


@@ -6070,7 +6207,6 @@ inlineTempVar (sym_link * type, int level)
   return sym;
 }
 
   return sym;
 }
 

-

 /*-----------------------------------------------------------------*/
 /* inlineFindParmRecurse - recursive function for inlineFindParm   */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
 /* inlineFindParmRecurse - recursive function for inlineFindParm   */
 /*-----------------------------------------------------------------*/


@@ -6097,7 +6233,6 @@ inlineFindParmRecurse (ast * parms, int *index)
   return NULL;
 }
 
   return NULL;
 }
 

-

 /*-----------------------------------------------------------------*/
 /* inlineFindParm - search an ast tree of parameters to find one   */
 /*                  at a particular index (0=first parameter).     */
 /*-----------------------------------------------------------------*/
 /* inlineFindParm - search an ast tree of parameters to find one   */
 /*                  at a particular index (0=first parameter).     */


@@ -6109,7 +6244,6 @@ inlineFindParm (ast * parms, int index)
   return inlineFindParmRecurse (parms, &index);
 }
 
   return inlineFindParmRecurse (parms, &index);
 }
 

-

 /*-----------------------------------------------------------------*/
 /* expandInlineFuncs - replace calls to inline functions with the  */
 /*                     function itself                             */
 /*-----------------------------------------------------------------*/
 /* expandInlineFuncs - replace calls to inline functions with the  */
 /*                     function itself                             */


@@ -6169,19 +6303,13 @@ expandInlineFuncs (ast * tree, ast * block)
           /* during the function call. For example, a function         */
           /* declared as func(int x, int y) but called as func(y,x).   */
           /* { //inlinetree block                                      */
           /* during the function call. For example, a function         */
           /* declared as func(int x, int y) but called as func(y,x).   */
           /* { //inlinetree block                                      */

-          /*   type1 temparg1;                                         */
+          /*   type1 temparg1 = argument1;                             */

           /*   ...                                                     */
           /*   ...                                                     */

-          /*   typen tempargn;                                         */
-          /*   temparg1 = argument1;                                   */
-          /*   ...                                                     */
-          /*   tempargn = argumentn;                                   */
+          /*   typen tempargn = argumentn;                             */

           /*   { //inlinetree2 block                                   */
           /*   { //inlinetree2 block                                   */

-          /*     type1 param1;                                         */
-          /*     ...                                                   */
-          /*     typen paramn;                                         */
-          /*     param1 = temparg1;                                    */
+          /*     type1 param1 = temparg1;                              */

           /*     ...                                                   */
           /*     ...                                                   */

-          /*     paramn = tempargn;                                    */
+          /*     typen paramn = tempargn;                              */

           /*     inline_function_code;                                 */
           /*     retlab:                                               */
           /*   }                                                       */
           /*     inline_function_code;                                 */
           /*     retlab:                                               */
           /*   }                                                       */


@@ -6191,32 +6319,39 @@ expandInlineFuncs (ast * tree, ast * block)
           while (args)
             {
               symbol * temparg;
           while (args)
             {
               symbol * temparg;

-              ast * passedarg;

               ast * assigntree;
               ast * assigntree;

-              symbol * parm = copySymbol (args->sym);
+              symbol * parm;
+              ast * passedarg = inlineFindParm (tree->right, argIndex);
+
+              if (!passedarg)
+                {
+                  werror(E_TOO_FEW_PARMS);
+                  break;
+                }

 
               temparg = inlineTempVar (args->sym->type, tree->level+1);
               inlineAddDecl (temparg, inlinetree, FALSE);
 
 
               temparg = inlineTempVar (args->sym->type, tree->level+1);
               inlineAddDecl (temparg, inlinetree, FALSE);
 

-              passedarg = inlineFindParm (tree->right, argIndex);

               assigntree = newNode ('=',
                                     newAst_VALUE (symbolVal (temparg)),
                                     passedarg);
               assigntree = newNode ('=',
                                     newAst_VALUE (symbolVal (temparg)),
                                     passedarg);

+              assigntree->initMode=1; // tell that assignment is initializer

               inlinetree->right = newNode (NULLOP,
                                            assigntree,
                                            inlinetree->right);
 
               inlinetree->right = newNode (NULLOP,
                                            assigntree,
                                            inlinetree->right);
 

+              parm = copySymbol (args->sym);

               inlineAddDecl (parm, inlinetree2, FALSE);
               parm->_isparm = 0;
 
               assigntree = newNode ('=',
                                     newAst_VALUE (symbolVal (parm)),
                                     newAst_VALUE (symbolVal (temparg)));
               inlineAddDecl (parm, inlinetree2, FALSE);
               parm->_isparm = 0;
 
               assigntree = newNode ('=',
                                     newAst_VALUE (symbolVal (parm)),
                                     newAst_VALUE (symbolVal (temparg)));

+              assigntree->initMode=1; // tell that assignment is initializer

               inlinetree2->right = newNode (NULLOP,
                                            assigntree,
                                            inlinetree2->right);
 
               inlinetree2->right = newNode (NULLOP,
                                            assigntree,
                                            inlinetree2->right);
 

-

               args = args->next;
               argIndex++;
             }
               args = args->next;
               argIndex++;
             }


@@ -6256,7 +6391,6 @@ expandInlineFuncs (ast * tree, ast * block)
           fixupInline (inlinetree, inlinetree->level);
           inlineState.count++;
         }
           fixupInline (inlinetree, inlinetree->level);
           inlineState.count++;
         }

-

     }
 
   /* Recursively continue to search for functions to inline. */
     }
 
   /* Recursively continue to search for functions to inline. */


@@ -6272,7 +6406,6 @@ expandInlineFuncs (ast * tree, ast * block)
     }
 }
 
     }
 }
 

-

 /*-----------------------------------------------------------------*/
 /* createFunction - This is the key node that calls the iCode for  */
 /*                  generating the code for a function. Note code  */
 /*-----------------------------------------------------------------*/
 /* createFunction - This is the key node that calls the iCode for  */
 /*                  generating the code for a function. Note code  */


@@ -6383,9 +6516,16 @@ createFunction (symbol * name, ast * body)
   if (fatalError)
     goto skipall;
 
   if (fatalError)
     goto skipall;
 

-  /* Do not generate code for inline functions unless extern also */
+  /* Do not generate code for inline functions unless extern also. */
+#if 0

   if (FUNC_ISINLINE (name->type) && !IS_EXTERN (fetype))
     goto skipall;
   if (FUNC_ISINLINE (name->type) && !IS_EXTERN (fetype))
     goto skipall;

+#else
+  /* Temporary hack: always generate code for static inline functions. */
+  /* Ideally static inline functions should only be generated if needed. */
+  if (FUNC_ISINLINE (name->type) && !IS_EXTERN (fetype) && !IS_STATIC (fetype))
+    goto skipall;
+#endif

 
   /* create the node & generate intermediate code */
   GcurMemmap = code;
 
   /* create the node & generate intermediate code */
   GcurMemmap = code;


@@ -6420,7 +6560,8 @@ skipall:
 
   /* we are done freeup memory & cleanup */
   noLineno--;
 
   /* we are done freeup memory & cleanup */
   noLineno--;

-  if (port->reset_labelKey) labelKey = 1;
+  if (port->reset_labelKey)
+    labelKey = 1;

   name->key = 0;
   FUNC_HASBODY(name->type) = 1;
   addSet (&operKeyReset, name);
   name->key = 0;
   FUNC_HASBODY(name->type) = 1;
   addSet (&operKeyReset, name);


@@ -6524,10 +6665,10 @@ void ast_print (ast * tree, FILE *outfile, int indent)
     if (IS_LITERAL (tree->opval.val->etype)) {
       fprintf(outfile,"CONSTANT (%p) value = ", tree);
       if (SPEC_USIGN (tree->opval.val->etype))
     if (IS_LITERAL (tree->opval.val->etype)) {
       fprintf(outfile,"CONSTANT (%p) value = ", tree);
       if (SPEC_USIGN (tree->opval.val->etype))

-        fprintf(outfile,"%u", (TYPE_TARGET_ULONG) floatFromVal(tree->opval.val));
+        fprintf(outfile,"%u", (TYPE_TARGET_ULONG) ulFromVal(tree->opval.val));

       else
       else

-        fprintf(outfile,"%d", (TYPE_TARGET_LONG) floatFromVal(tree->opval.val));
-      fprintf(outfile,", 0x%x, %f", (TYPE_TARGET_ULONG) floatFromVal(tree->opval.val),
+        fprintf(outfile,"%d", (TYPE_TARGET_LONG) ulFromVal(tree->opval.val));
+      fprintf(outfile,", 0x%x, %f", (TYPE_TARGET_ULONG) ulFromVal(tree->opval.val),

         floatFromVal(tree->opval.val));
     } else if (tree->opval.val->sym) {
       /* if the undefined flag is set then give error message */
         floatFromVal(tree->opval.val));
     } else if (tree->opval.val->sym) {
       /* if the undefined flag is set then give error message */


@@ -7092,9 +7233,9 @@ void ast_print (ast * tree, FILE *outfile, int indent)
       for (val = tree->values.switchVals.swVals; val ; val = val->next) {
         INDENT(indent+2,outfile);
         fprintf(outfile,"CASE 0x%x GOTO _case_%d_%d\n",
       for (val = tree->values.switchVals.swVals; val ; val = val->next) {
         INDENT(indent+2,outfile);
         fprintf(outfile,"CASE 0x%x GOTO _case_%d_%d\n",

-          (int) floatFromVal(val),
+          (int) ulFromVal(val),

           tree->values.switchVals.swNum,
           tree->values.switchVals.swNum,

-          (int) floatFromVal(val));
+          (int) ulFromVal(val));

       }
       ast_print(tree->right,outfile,indent);
     }
       }
       ast_print(tree->right,outfile,indent);
     }