ex = Safe_alloc ( sizeof (ast));
ex->type = type;
- ex->lineno = (noLineno ? oldLineno : yylineno);
+ ex->lineno = (noLineno ? oldLineno : mylineno);
ex->filename = currFname;
ex->level = NestLevel;
ex->block = currBlockno;
return ex;
}
-ast *
-newAst_STMNT (unsigned val)
-{
- ast *ex = newAst_ (EX_STMNT);
- ex->opval.stmnt = val;
- return ex;
-}
-
/*-----------------------------------------------------------------*/
/* newNode - creates a new node */
/*-----------------------------------------------------------------*/
return tree;
}
+
/*-------------------------------------------------------------*/
/* constExprTree - returns TRUE if this tree is a constant */
/* expression */
}
cexpr = decorateType (resolveSymbols (cexpr));
-
+
switch (cexpr->type)
{
case EX_VALUE:
IN_CODESPACE(SPEC_OCLS(AST_SYMBOL(cexpr)->etype))) {
// a symbol in code space will never change
// This is only for the 'char *s="hallo"' case and will have to leave
+ //printf(" code space symbol");
return TRUE;
}
return FALSE;
if (constExprTree(cexpr->left) && constExprTree(cexpr->right)) {
return TRUE;
}
+ return FALSE;
+ case EX_OPERAND:
+ return IS_CONSTANT(operandType(cexpr->opval.oprnd));
}
return FALSE;
-}
+}
/*-----------------------------------------------------------------*/
/* constExprValue - returns the value of a constant expression */
if (IS_AST_OP (cexpr) &&
cexpr->opval.op == CAST &&
IS_LITERAL (cexpr->right->ftype))
+ {
return valCastLiteral (cexpr->ftype,
floatFromVal (cexpr->right->opval.val));
+ }
if (IS_AST_VALUE (cexpr))
+ {
return cexpr->opval.val;
+ }
if (check)
werror (E_CONST_EXPECTED, "found expression");
return FALSE;
// if the loopvar is used in another (maybe conditional) block
if (astHasSymbol (pbody->right, sym) &&
- (pbody->level > body->level)) {
+ (pbody->level >= body->level)) {
return FALSE;
}
}
tree->left = dtl;
if (dtr != tree->right)
tree->right = dtr;
+ if ((dtl && dtl->isError) || (dtr && dtr->isError))
+ return tree;
if (IS_AST_OP(tree) &&
(tree->opval.op == CAST || tree->opval.op == '=') &&
(getSize(LTYPE(tree)) > getSize(RTYPE(tree))) &&
- (getSize(RTYPE(tree)) < INTSIZE)) {
+ (getSize(RTYPE(tree)) < (unsigned) INTSIZE)) {
// this is a cast/assign to a bigger type
if (IS_AST_OP(tree->right) &&
IS_INTEGRAL(tree->right->ftype) &&
}
RRVAL (tree) = 1;
COPYTYPE (TTYPE (tree), TETYPE (tree), LTYPE (tree)->next);
- if (IS_PTR(LTYPE(tree))) {
- SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree));
- }
return tree;
/*------------------------------------------------------------------*/
case FUNCTION:
break;
}
+
+ if (IS_ADDRESS_OF_OP (tree->left) && IS_AST_SYM_VALUE(tree->left->left)
+ && SPEC_ABSA (AST_SYMBOL (tree->left->left)->etype))
+ {
+ /* If defined struct type at addr var
+ then rewrite (&struct var)->member
+ as temp
+ and define membertype at (addr+offsetof(struct var,member)) temp
+ */
+ symbol *sym;
+ symbol *element = getStructElement (SPEC_STRUCT (LETYPE(tree)),
+ AST_SYMBOL(tree->right));
+
+ sym = newSymbol(genSymName (0), 0);
+ sym->type = TTYPE (tree);
+ sym->etype = getSpec(sym->type);
+ sym->lineDef = tree->lineno;
+ sym->cdef = 1;
+ sym->isref = 1;
+ SPEC_STAT (sym->etype) = 1;
+ SPEC_ADDR (sym->etype) = SPEC_ADDR (AST_SYMBOL (tree->left->left)->etype)
+ + element->offset;
+ SPEC_ABSA(sym->etype) = 1;
+ addSym (SymbolTab, sym, sym->name, 0, 0, 0);
+ allocGlobal (sym);
+
+ AST_VALUE (tree) = symbolVal(sym);
+ TLVAL (tree) = 1;
+ TRVAL (tree) = 0;
+ tree->type = EX_VALUE;
+ tree->left = NULL;
+ tree->right = NULL;
+ }
return tree;
/*----------------------------*/
/* ++/-- operation */
/*----------------------------*/
- case INC_OP: /* incerement operator unary so left only */
+ case INC_OP: /* increment operator unary so left only */
case DEC_OP:
{
sym_link *ltc = (tree->right ? RTYPE (tree) : LTYPE (tree));
COPYTYPE (TTYPE (tree), TETYPE (tree), ltc);
- if (!tree->initMode && IS_CONSTANT(TETYPE(tree)))
+ if (!tree->initMode && IS_CONSTANT(TTYPE(tree)))
werror (E_CODE_WRITE, tree->opval.op==INC_OP ? "++" : "--");
if (tree->right)
goto errorTreeReturn;
}
if (SPEC_SCLS (tree->left->etype) == S_CODE)
- {
- DCL_TYPE (p) = CPOINTER;
- DCL_PTR_CONST (p) = port->mem.code_ro;
- }
+ DCL_TYPE (p) = CPOINTER;
else if (SPEC_SCLS (tree->left->etype) == S_XDATA)
DCL_TYPE (p) = FPOINTER;
else if (SPEC_SCLS (tree->left->etype) == S_XSTACK)
p->next = LTYPE (tree);
TTYPE (tree) = p;
TETYPE (tree) = getSpec (TTYPE (tree));
- DCL_PTR_CONST (p) = SPEC_CONST (TETYPE (tree));
- DCL_PTR_VOLATILE (p) = SPEC_VOLATILE (TETYPE (tree));
LLVAL (tree) = 1;
TLVAL (tree) = 1;
+
+ #if 0
+ if (IS_AST_OP (tree->left) && tree->left->opval.op == PTR_OP
+ && IS_AST_VALUE (tree->left->left) && !IS_AST_SYM_VALUE (tree->left->left))
+ {
+ symbol *element = getStructElement (SPEC_STRUCT (LETYPE(tree->left)),
+ AST_SYMBOL(tree->left->right));
+ AST_VALUE(tree) = valPlus(AST_VALUE(tree->left->left),
+ valueFromLit(element->offset));
+ tree->left = NULL;
+ tree->right = NULL;
+ tree->type = EX_VALUE;
+ tree->values.literalFromCast = 1;
+ }
+ #endif
+
return tree;
/*------------------------------------------------------------------*/
werror (E_LVALUE_REQUIRED, "pointer deref");
goto errorTreeReturn;
}
- TTYPE (tree) = copyLinkChain (LTYPE (tree)->next);
- TETYPE (tree) = getSpec (TTYPE (tree));
- SPEC_CONST (TETYPE (tree)) = DCL_PTR_CONST (LTYPE(tree));
+ if (IS_ADDRESS_OF_OP(tree->left))
+ {
+ /* replace *&obj with obj */
+ return tree->left->left;
+ }
+ TTYPE (tree) = copyLinkChain (LTYPE (tree)->next);
+ TETYPE (tree) = getSpec (TTYPE (tree));
return tree;
}
tree->right = NULL;
TTYPE (tree) = tree->opval.val->type;
tree->values.literalFromCast = 1;
- } else if (IS_GENPTR(LTYPE(tree)) && !IS_PTR(RTYPE(tree)) &&
+ } 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;
- werror(W_LITERAL_GENERIC);
+ werror(W_LITERAL_GENERIC);
TTYPE(tree) = newLink(DECLARATOR);
DCL_TYPE(TTYPE(tree)) = FPOINTER;
TTYPE(tree)->next = rest;
/* if pointer to struct then check names */
if (IS_PTR(LTYPE(tree)) && IS_STRUCT(LTYPE(tree)->next) &&
IS_PTR(RTYPE(tree)) && IS_STRUCT(RTYPE(tree)->next) &&
- strcmp(SPEC_STRUCT(LETYPE(tree))->tag,SPEC_STRUCT(RETYPE(tree))->tag))
+ strcmp(SPEC_STRUCT(LETYPE(tree))->tag,SPEC_STRUCT(RETYPE(tree))->tag))
{
werror(W_CAST_STRUCT_PTR,SPEC_STRUCT(RETYPE(tree))->tag,
SPEC_STRUCT(LETYPE(tree))->tag);
}
#endif
- /* if the right is a literal replace the tree */
- if (IS_LITERAL (RETYPE (tree)) && !IS_PTR (LTYPE (tree))) {
- tree->type = EX_VALUE;
+ if (IS_ADDRESS_OF_OP(tree->right)
+ && IS_AST_SYM_VALUE (tree->right->left)
+ && SPEC_ABSA (AST_SYMBOL (tree->right->left)->etype)) {
+
+ tree->type = EX_VALUE;
tree->opval.val =
valCastLiteral (LTYPE (tree),
- floatFromVal (valFromType (RETYPE (tree))));
+ SPEC_ADDR (AST_SYMBOL (tree->right->left)->etype));
+ TTYPE (tree) = tree->opval.val->type;
+ TETYPE (tree) = getSpec (TTYPE (tree));
tree->left = NULL;
tree->right = NULL;
- TTYPE (tree) = tree->opval.val->type;
tree->values.literalFromCast = 1;
- } else {
- TTYPE (tree) = LTYPE (tree);
- LRVAL (tree) = 1;
+ return tree;
+ }
+
+ /* handle offsetof macro: */
+ /* #define offsetof(TYPE, MEMBER) \ */
+ /* ((unsigned) &((TYPE *)0)->MEMBER) */
+ if (IS_ADDRESS_OF_OP(tree->right)
+ && IS_AST_OP (tree->right->left)
+ && 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 (RETYPE (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 (IS_LITERAL (RETYPE (tree))) {
+ 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 (RETYPE (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;
+ }
+ if (!IS_PTR (LTYPE (tree))) {
+ tree->type = EX_VALUE;
+ tree->opval.val =
+ valCastLiteral (LTYPE (tree),
+ floatFromVal (valFromType (RETYPE (tree))));
+ TTYPE (tree) = tree->opval.val->type;
+ tree->left = NULL;
+ tree->right = NULL;
+ tree->values.literalFromCast = 1;
+ TETYPE (tree) = getSpec (TTYPE (tree));
+ return tree;
+ }
}
+ TTYPE (tree) = LTYPE (tree);
+ LRVAL (tree) = 1;
+
#endif
TETYPE (tree) = getSpec (TTYPE (tree));
case V_STRUCT:
typeofv = TYPEOF_STRUCT;
break;
+ case V_BITFIELD:
+ typeofv = TYPEOF_BITFIELD;
+ break;
case V_BIT:
typeofv = TYPEOF_BIT;
break;
{
werror (E_TYPE_MISMATCH, "assignment", " ");
printFromToType(RTYPE(tree),LTYPE(tree));
- //goto errorTreeReturn;
}
/* if the left side of the tree is of type void
RRVAL (tree) = 1;
LLVAL (tree) = 1;
if (!tree->initMode ) {
- if ((IS_SPEC(LETYPE(tree)) && IS_CONSTANT (LETYPE (tree))))
+ if (IS_CONSTANT(LTYPE(tree)))
werror (E_CODE_WRITE, "=");
}
if (LRVAL (tree))
if ((options.stackAuto || IFFUNC_ISREENT (LTYPE (tree))) &&
!IFFUNC_ISBUILTIN(LTYPE(tree)))
{
- //FUNC_ARGS(tree->left->ftype) =
- //reverseVal (FUNC_ARGS(tree->left->ftype));
reverseParms (tree->right);
}
- TETYPE (tree) = getSpec (TTYPE (tree) = LTYPE (tree)->next);
+ if (IS_CODEPTR(LTYPE(tree))) {
+ TTYPE(tree) = LTYPE(tree)->next->next;
+ } else {
+ TTYPE(tree) = LTYPE(tree)->next;
+ }
+ TETYPE (tree) = getSpec (TTYPE (tree));
return tree;
/*------------------------------------------------------------------*/
addSymChain (name);
allocVariables (name);
}
- name->lastLine = yylineno;
+ name->lastLine = mylineno;
currFunc = name;
/* set the stack pointer */
/* just get the type */
if (tree->type == EX_VALUE) {
- if (IS_LITERAL (tree->opval.val->etype)) {
- fprintf(outfile,"CONSTANT (%p) value = %d, 0x%x, %g", tree,
- (int) floatFromVal(tree->opval.val),
- (int) floatFromVal(tree->opval.val),
- floatFromVal(tree->opval.val));
+ if (IS_LITERAL (tree->opval.val->etype)) {
+ fprintf(outfile,"CONSTANT (%p) value = ", tree);
+ if (SPEC_USIGN (tree->opval.val->etype))
+ fprintf(outfile,"%u", (TYPE_UDWORD) floatFromVal(tree->opval.val));
+ else
+ fprintf(outfile,"%d", (TYPE_DWORD) floatFromVal(tree->opval.val));
+ fprintf(outfile,", 0x%x, %g", (TYPE_UDWORD) floatFromVal(tree->opval.val),
+ floatFromVal(tree->opval.val));
} else if (tree->opval.val->sym) {
/* if the undefined flag is set then give error message */
if (tree->opval.val->sym->undefined) {
projects / fw / sdcc / blobdiff