From 0e486caba2e97c32e1bf2030d45dddce103beae4 Mon Sep 17 00:00:00 2001 From: kvigor Date: Thu, 14 Dec 2000 01:07:24 +0000 Subject: [PATCH] Change struct link to struct sym_link to avoid conflict with struct link in unistd.h git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@517 4a8a32a2-be11-0410-ad9d-d568d2c75423 --- src/SDCC.y | 16 ++--- src/SDCCast.c | 32 +++++----- src/SDCCast.h | 12 ++-- src/SDCCcse.c | 6 +- src/SDCCglue.c | 22 ++++--- src/SDCCicode.c | 150 ++++++++++++++++++++++----------------------- src/SDCCicode.h | 16 ++--- src/SDCClrange.c | 4 +- src/SDCCopt.c | 8 +-- src/SDCCsymt.c | 92 +++++++++++++-------------- src/SDCCsymt.h | 66 ++++++++++---------- src/SDCCval.c | 14 ++--- src/SDCCval.h | 12 ++-- src/avr/gen.c | 58 +++++++++--------- src/avr/main.c | 2 +- src/avr/ralloc.c | 12 ++-- src/ds390/gen.c | 76 +++++++++++------------ src/ds390/main.c | 2 +- src/ds390/ralloc.c | 12 ++-- src/mcs51/gen.c | 72 +++++++++++----------- src/mcs51/main.c | 2 +- src/mcs51/ralloc.c | 16 ++--- src/pic/gen.c | 68 ++++++++++---------- src/pic/glue.c | 32 +++++----- src/pic/main.c | 2 +- src/pic/ralloc.c | 12 ++-- src/port.h | 2 +- src/z80/gen.c | 26 ++++---- src/z80/main.c | 2 +- src/z80/ralloc.c | 4 +- 30 files changed, 427 insertions(+), 423 deletions(-) diff --git a/src/SDCC.y b/src/SDCC.y index 927a4ad7..64fc3594 100644 --- a/src/SDCC.y +++ b/src/SDCC.y @@ -60,7 +60,7 @@ value *cenum = NULL ; /* current enumeration type chain*/ symbol *sym ; /* symbol table pointer */ structdef *sdef; /* structure definition */ char yychar[SDCC_NAME_MAX+1]; - link *lnk ; /* declarator or specifier */ + sym_link *lnk ; /* declarator or specifier */ int yyint; /* integer value returned */ value *val ; /* for integer constant */ initList *ilist; /* initial list */ @@ -454,7 +454,7 @@ declaration symbol *sym , *sym1; for (sym1 = sym = reverseSyms($2);sym != NULL;sym = sym->next) { - link *lnk = copyLinkChain($1); + sym_link *lnk = copyLinkChain($1); /* do the pointer stuff */ pointerTypes(sym->type,lnk); addDecl (sym,0,lnk) ; @@ -470,7 +470,7 @@ declaration_specifiers /* if the decl $2 is not a specifier */ /* find the spec and replace it */ if ( !IS_SPEC($2)) { - link *lnk = $2 ; + sym_link *lnk = $2 ; while (lnk && !IS_SPEC(lnk->next)) lnk = lnk->next; lnk->next = mergeSpec($1,lnk->next); @@ -484,7 +484,7 @@ declaration_specifiers /* if the decl $2 is not a specifier */ /* find the spec and replace it */ if ( !IS_SPEC($2)) { - link *lnk = $2 ; + sym_link *lnk = $2 ; while (lnk && !IS_SPEC(lnk->next)) lnk = lnk->next; lnk->next = mergeSpec($1,lnk->next); @@ -650,7 +650,7 @@ type_specifier2 | TYPE_NAME { symbol *sym; - link *p ; + sym_link *p ; sym = findSym(TypedefTab,NULL,$1) ; $$ = p = copyLinkChain(sym->type); @@ -875,7 +875,7 @@ declarator2 | '(' declarator ')' { $$ = $2; } | declarator2 '[' ']' { - link *p; + sym_link *p; p = newLink (); DCL_TYPE(p) = ARRAY ; @@ -884,7 +884,7 @@ declarator2 } | declarator2 '[' constant_expr ']' { - link *p ; + sym_link *p ; value *tval; p = (tval = constExprValue($3,TRUE))->etype; @@ -1046,7 +1046,7 @@ type_name | type_specifier_list abstract_declarator { /* go to the end of the list */ - link *p; + sym_link *p; pointerTypes($2,$1); for ( p = $2 ; p->next ; p=p->next); p->next = $1 ; diff --git a/src/SDCCast.c b/src/SDCCast.c index c8610e92..847bc6f5 100644 --- a/src/SDCCast.c +++ b/src/SDCCast.c @@ -49,8 +49,8 @@ char buffer[1024]; int noLineno = 0; int noAlloc = 0 ; symbol *currFunc ; -ast *createIval (ast *, link *, initList *, ast *); -ast *createIvalCharPtr (ast *, link *, ast *); +ast *createIval (ast *, sym_link *, initList *, ast *); +ast *createIvalCharPtr (ast *, sym_link *, ast *); ast *optimizeRRCRLC ( ast * ); ast *optimizeGetHbit(ast *); ast *backPatchLabels (ast *,symbol *,symbol *); @@ -89,7 +89,7 @@ ast *newAst (int type, void *op ) ex->opval.op = (long) op ; break ; case EX_LINK : - ex->opval.lnk = (link *) op; + ex->opval.lnk = (sym_link *) op; break ; case EX_STMNT : ex->opval.stmnt= (unsigned) op; @@ -129,7 +129,7 @@ ast* newAst_OP(unsigned op) return ex; } -ast* newAst_LINK(link*val) +ast* newAst_LINK(sym_link*val) { ast* ex = newAst_(EX_LINK); ex->opval.lnk = val; @@ -490,7 +490,7 @@ value *resolveFromTable (value *val) /*-----------------------------------------------------------------*/ /* funcOfType :- function of type with name */ /*-----------------------------------------------------------------*/ -symbol *funcOfType (char *name, link *type, link *argType, +symbol *funcOfType (char *name, sym_link *type, sym_link *argType, int nArgs , int rent) { symbol *sym; @@ -559,7 +559,7 @@ int processParms (ast *func, value *defParm, ast *actParm, int *parmNumber) { - link *fetype = func->etype; + sym_link *fetype = func->etype; /* if none of them exist */ if ( !defParm && !actParm) @@ -635,7 +635,7 @@ int processParms (ast *func, value *defParm, /*-----------------------------------------------------------------*/ /* createIvalType - generates ival for basic types */ /*-----------------------------------------------------------------*/ -ast *createIvalType ( ast *sym,link *type, initList *ilist) +ast *createIvalType ( ast *sym,sym_link *type, initList *ilist) { ast *iExpr; @@ -650,7 +650,7 @@ ast *createIvalType ( ast *sym,link *type, initList *ilist) /*-----------------------------------------------------------------*/ /* createIvalStruct - generates initial value for structures */ /*-----------------------------------------------------------------*/ -ast *createIvalStruct (ast *sym,link *type,initList *ilist) +ast *createIvalStruct (ast *sym,sym_link *type,initList *ilist) { ast *rast = NULL ; symbol *sflds ; @@ -682,7 +682,7 @@ ast *createIvalStruct (ast *sym,link *type,initList *ilist) /*-----------------------------------------------------------------*/ /* createIvalArray - generates code for array initialization */ /*-----------------------------------------------------------------*/ -ast *createIvalArray (ast *sym, link *type, initList *ilist) +ast *createIvalArray (ast *sym, sym_link *type, initList *ilist) { ast *rast = NULL; initList *iloop ; @@ -739,7 +739,7 @@ ast *createIvalArray (ast *sym, link *type, initList *ilist) /*-----------------------------------------------------------------*/ /* createIvalCharPtr - generates initial values for char pointers */ /*-----------------------------------------------------------------*/ -ast *createIvalCharPtr (ast *sym, link *type, ast *iexpr) +ast *createIvalCharPtr (ast *sym, sym_link *type, ast *iexpr) { ast *rast = NULL ; @@ -786,7 +786,7 @@ ast *createIvalCharPtr (ast *sym, link *type, ast *iexpr) /*-----------------------------------------------------------------*/ /* createIvalPtr - generates initial value for pointers */ /*-----------------------------------------------------------------*/ -ast *createIvalPtr (ast *sym,link *type,initList *ilist) +ast *createIvalPtr (ast *sym,sym_link *type,initList *ilist) { ast *rast; ast *iexpr ; @@ -808,7 +808,7 @@ ast *createIvalPtr (ast *sym,link *type,initList *ilist) /*-----------------------------------------------------------------*/ /* createIval - generates code for initial value */ /*-----------------------------------------------------------------*/ -ast *createIval (ast *sym, link *type, initList *ilist, ast *wid) +ast *createIval (ast *sym, sym_link *type, initList *ilist, ast *wid) { ast *rast = NULL; @@ -1514,7 +1514,7 @@ ast *reverseLoop (ast *loop, symbol *sym, ast *init, ast *end) ast *decorateType (ast *tree) { int parmNumber ; - link *p; + sym_link *p; if ( ! tree ) return tree ; @@ -1703,7 +1703,7 @@ ast *decorateType (ast *tree) case INC_OP: /* incerement operator unary so left only */ case DEC_OP: { - link *ltc = (tree->right ? RTYPE(tree) : LTYPE(tree) ); + sym_link *ltc = (tree->right ? RTYPE(tree) : LTYPE(tree) ); COPYTYPE(TTYPE(tree),TETYPE(tree),ltc); if (!tree->initMode && IS_CONSTANT(TETYPE(tree))) werror(E_CODE_WRITE,"++/--"); @@ -2752,7 +2752,7 @@ ast *decorateType (ast *tree) /*-----------------------------------------------------------------*/ /* sizeofOp - processes size of operation */ /*-----------------------------------------------------------------*/ -value *sizeofOp( link *type) +value *sizeofOp( sym_link *type) { char buff[10]; @@ -3565,7 +3565,7 @@ ast *createFunction (symbol *name, ast *body ) ast *ex ; symbol *csym; int stack = 0 ; - link *fetype; + sym_link *fetype; iCode *piCode = NULL; /* if check function return 0 then some problem */ diff --git a/src/SDCCast.h b/src/SDCCast.h index dbb49ab3..7af66517 100644 --- a/src/SDCCast.h +++ b/src/SDCCast.h @@ -52,7 +52,7 @@ typedef struct ast { /* union of values expression can have */ union { value *val ; /* value if type = EX_VALUE */ - link *lnk ; /* link * if type= EX_LINK */ + sym_link *lnk ; /* sym_link * if type= EX_LINK */ struct operand *oprnd; /* used only for side effecting function calls */ unsigned stmnt ; /* statement if type=EX_STMNT */ unsigned op ; /* operator if type= EX_OP */ @@ -84,8 +84,8 @@ typedef struct ast { int lineno ; /* source file line number */ char *filename ; /* filename of the source file */ - link *ftype ; /* start of type chain for this subtree */ - link *etype ; /* end of type chain for this subtree */ + sym_link *ftype ; /* start of type chain for this subtree */ + sym_link *etype ; /* end of type chain for this subtree */ symbol *argSym ; /* argument symbols */ value *args ; /* args of a function */ @@ -157,13 +157,13 @@ extern FILE *codeOutFile; /* forward definitions for functions */ ast* newAst_VALUE(value*val); ast* newAst_OP (unsigned op); -ast* newAst_LINK (link*val); +ast* newAst_LINK (sym_link*val); ast* newAst_STMNT(unsigned val); void initAst ( ); ast *newNode (long ,ast * ,ast * ); ast *copyAst (ast * ); -value *sizeofOp (link * ); +value *sizeofOp (sym_link * ); value *evalStmnt (ast * ); ast *createFunction(symbol *,ast * ); ast *createBlock (symbol *,ast * ); @@ -181,7 +181,7 @@ ast *createDo (symbol *,symbol *,symbol *,ast *,ast *); ast *createFor (symbol *,symbol *,symbol *,symbol *,ast *,ast *,ast *, ast *); void eval2icode (ast *); value *constExprValue (ast *,int); -symbol *funcOfType (char *,link *,link *,int,int); +symbol *funcOfType (char *,sym_link *,sym_link *,int,int); ast *initAggregates ( symbol *,initList *, ast *); bool hasSEFcalls ( ast *); void addSymToBlock (symbol *, ast *) ; diff --git a/src/SDCCcse.c b/src/SDCCcse.c index f0859751..ba572b6a 100644 --- a/src/SDCCcse.c +++ b/src/SDCCcse.c @@ -202,7 +202,7 @@ DEFSETFUNC(removeFromInExprs) /*-----------------------------------------------------------------*/ static bool isGlobalInNearSpace (operand *op) { - link *type = getSpec(operandType(op)); + sym_link *type = getSpec(operandType(op)); /* this is 8051 specific: optimization suggested by Jean-Louis VERN, with 8051s we have no advantage of putting variables in near space into @@ -792,7 +792,7 @@ void algebraicOpts (iCode *ic) void updateSpillLocation ( iCode *ic) { - link *setype; + sym_link *setype; if (POINTER_SET(ic)) return; @@ -1124,7 +1124,7 @@ DEFSETFUNC(delGetPointerSucc) /*-----------------------------------------------------------------*/ static void fixUpTypes(iCode *ic) { - link *t1 = operandType(IC_LEFT(ic)) ,*t2; + sym_link *t1 = operandType(IC_LEFT(ic)) ,*t2; if (IS_DS390_PORT) { diff --git a/src/SDCCglue.c b/src/SDCCglue.c index 686b67be..bb7ef5e9 100644 --- a/src/SDCCglue.c +++ b/src/SDCCglue.c @@ -27,17 +27,21 @@ #include #ifndef __BORLANDC__ +#if 0 /* This should no longer be necessary. */ // This is a bit messy because we define link ourself #define link NoLiNk #include #undef link #else +#include +#endif +#else // No unistd.h in Borland C++ #endif symbol *interrupts[256]; -void printIval (symbol *, link *, initList *, FILE *); +void printIval (symbol *, sym_link *, initList *, FILE *); set *publics = NULL; /* public variables */ set *externs = NULL; /* Varibles that are declared as extern */ @@ -446,7 +450,7 @@ void printGPointerType(FILE *oFile, const char *name, /*-----------------------------------------------------------------*/ /* printIvalType - generates ival for int/char */ /*-----------------------------------------------------------------*/ -void printIvalType (link * type, initList * ilist, FILE * oFile) +void printIvalType (sym_link * type, initList * ilist, FILE * oFile) { value *val; @@ -487,7 +491,7 @@ void printIvalType (link * type, initList * ilist, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIvalStruct - generates initial value for structures */ /*-----------------------------------------------------------------*/ -void printIvalStruct (symbol * sym,link * type, +void printIvalStruct (symbol * sym,sym_link * type, initList * ilist, FILE * oFile) { symbol *sflds; @@ -510,7 +514,7 @@ void printIvalStruct (symbol * sym,link * type, /*-----------------------------------------------------------------*/ /* printIvalChar - generates initital value for character array */ /*-----------------------------------------------------------------*/ -int printIvalChar (link * type, initList * ilist, FILE * oFile, char *s) +int printIvalChar (sym_link * type, initList * ilist, FILE * oFile, char *s) { value *val; int remain; @@ -546,7 +550,7 @@ int printIvalChar (link * type, initList * ilist, FILE * oFile, char *s) /*-----------------------------------------------------------------*/ /* printIvalArray - generates code for array initialization */ /*-----------------------------------------------------------------*/ -void printIvalArray (symbol * sym, link * type, initList * ilist, +void printIvalArray (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) { initList *iloop; @@ -597,7 +601,7 @@ void printIvalArray (symbol * sym, link * type, initList * ilist, /*-----------------------------------------------------------------*/ /* printIvalFuncPtr - generate initial value for function pointers */ /*-----------------------------------------------------------------*/ -void printIvalFuncPtr (link * type, initList * ilist, FILE * oFile) +void printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) { value *val; int dLvl = 0; @@ -636,7 +640,7 @@ void printIvalFuncPtr (link * type, initList * ilist, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIvalCharPtr - generates initial values for character pointers */ /*-----------------------------------------------------------------*/ -int printIvalCharPtr (symbol * sym, link * type, value * val, FILE * oFile) +int printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) { int size = 0; @@ -709,7 +713,7 @@ int printIvalCharPtr (symbol * sym, link * type, value * val, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIvalPtr - generates initial value for pointers */ /*-----------------------------------------------------------------*/ -void printIvalPtr (symbol * sym, link * type, initList * ilist, FILE * oFile) +void printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) { value *val; int size; @@ -778,7 +782,7 @@ void printIvalPtr (symbol * sym, link * type, initList * ilist, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIval - generates code for initial value */ /*-----------------------------------------------------------------*/ -void printIval (symbol * sym, link * type, initList * ilist, FILE * oFile) +void printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) { if (!ilist) return; diff --git a/src/SDCCicode.c b/src/SDCCicode.c index 47d68744..d2ca13ec 100644 --- a/src/SDCCicode.c +++ b/src/SDCCicode.c @@ -116,7 +116,7 @@ iCodeTable codeTable[] = { /*-----------------------------------------------------------------*/ int printOperand (operand *op, FILE *file) { - link *opetype; + sym_link *opetype; int pnl = 0; if (!op) @@ -602,11 +602,11 @@ iCodeTable *getTableEntry (int oper ) /*-----------------------------------------------------------------*/ /* newiTempOperand - new intermediate temp operand */ /*-----------------------------------------------------------------*/ -operand *newiTempOperand (link *type, char throwType) +operand *newiTempOperand (sym_link *type, char throwType) { symbol *itmp; operand *op = newOperand(); - link *etype; + sym_link *etype; op->type = SYMBOL ; itmp = newiTemp(NULL); @@ -633,7 +633,7 @@ operand *newiTempOperand (link *type, char throwType) /*-----------------------------------------------------------------*/ /* operandType - returns the type chain for an operand */ /*-----------------------------------------------------------------*/ -link *operandType (operand *op) +sym_link *operandType (operand *op) { /* depending on type of operand */ switch (op->type) { @@ -651,7 +651,7 @@ link *operandType (operand *op) " operand type not known "); assert (0) ; /* should never come here */ /* Just to keep the compiler happy */ - return (link *)0; + return (sym_link *)0; } } @@ -697,8 +697,8 @@ int isOperandGlobal ( operand *op ) /*-----------------------------------------------------------------*/ int isOperandVolatile ( operand *op , bool chkTemp) { - link *optype ; - link *opetype ; + sym_link *optype ; + sym_link *opetype ; if (IS_ITEMP(op) && !chkTemp) return 0; @@ -718,7 +718,7 @@ int isOperandVolatile ( operand *op , bool chkTemp) /*-----------------------------------------------------------------*/ int isOperandLiteral ( operand *op ) { - link *opetype ; + sym_link *opetype ; if (!op) return 0; @@ -735,7 +735,7 @@ int isOperandLiteral ( operand *op ) /*-----------------------------------------------------------------*/ bool isOperandInFarSpace (operand *op) { - link *etype; + sym_link *etype; if (!op) return FALSE; @@ -761,7 +761,7 @@ bool isOperandInFarSpace (operand *op) /*-----------------------------------------------------------------*/ bool isOperandOnStack(operand *op) { - link *etype; + sym_link *etype; if (!op) return FALSE; @@ -788,7 +788,7 @@ double operandLitValue ( operand *op ) /* operandOperation - perforoms operations on operands */ /*-----------------------------------------------------------------*/ operand *operandOperation (operand *left,operand *right, - int op, link *type) + int op, sym_link *type) { operand *retval = (operand *)0; @@ -1191,11 +1191,11 @@ operand *operandFromValue (value *val) /*-----------------------------------------------------------------*/ /* operandFromLink - operand from typeChain */ /*-----------------------------------------------------------------*/ -operand *operandFromLink (link *type) +operand *operandFromLink (sym_link *type) { operand *op ; - /* operand from link */ + /* operand from sym_link */ if ( ! type ) return NULL ; @@ -1244,7 +1244,7 @@ operand *operandFromAst ( ast *tree ) /*-----------------------------------------------------------------*/ /* setOperandType - sets the operand's type to the given type */ /*-----------------------------------------------------------------*/ -void setOperandType (operand *op, link *type) +void setOperandType (operand *op, sym_link *type) { /* depending on the type of operand */ switch (op->type) { @@ -1279,8 +1279,8 @@ void setOperandType (operand *op, link *type) operand *geniCodeRValue (operand *op, bool force) { iCode *ic ; - link *type = operandType(op); - link *etype= getSpec(type); + sym_link *type = operandType(op); + sym_link *etype= getSpec(type); /* if this is an array & already */ /* an address then return this */ @@ -1333,12 +1333,12 @@ operand *geniCodeRValue (operand *op, bool force) /*-----------------------------------------------------------------*/ /* geniCodeCast - changes the value from one type to another */ /*-----------------------------------------------------------------*/ -operand *geniCodeCast (link *type, operand *op, bool implicit) +operand *geniCodeCast (sym_link *type, operand *op, bool implicit) { iCode *ic ; - link *optype ; - link *opetype = getSpec(optype = operandType(op)); - link *restype ; + sym_link *optype ; + sym_link *opetype = getSpec(optype = operandType(op)); + sym_link *restype ; /* one of them has size zero then error */ if (IS_VOID(optype)) { @@ -1426,7 +1426,7 @@ operand *geniCodeMultiply (operand *left, operand *right) { iCode *ic ; int p2 = 0; - link *resType ; + sym_link *resType ; LRTYPE ; /* if they are both literal then we know the result */ @@ -1463,11 +1463,11 @@ operand *geniCodeDivision (operand *left, operand *right) { iCode *ic ; int p2 = 0; - link *resType; - link *rtype = operandType(right); - link *retype= getSpec(rtype); - link *ltype = operandType(left); - link *letype= getSpec(ltype); + sym_link *resType; + sym_link *rtype = operandType(right); + sym_link *retype= getSpec(rtype); + sym_link *ltype = operandType(left); + sym_link *letype= getSpec(ltype); resType = computeType (ltype,rtype) ; left = geniCodeCast(resType,left,TRUE); @@ -1497,7 +1497,7 @@ operand *geniCodeDivision (operand *left, operand *right) operand *geniCodeModulus (operand *left, operand *right) { iCode *ic ; - link *resType; + sym_link *resType; LRTYPE ; /* if they are both literal then we know the result */ @@ -1554,7 +1554,7 @@ operand *geniCodeSubtract (operand *left, operand *right) { iCode *ic ; int isarray= 0; - link *resType; + sym_link *resType; LRTYPE ; /* if they both pointers then */ @@ -1600,7 +1600,7 @@ operand *geniCodeSubtract (operand *left, operand *right) operand *geniCodeAdd (operand *left, operand *right ) { iCode *ic ; - link *resType ; + sym_link *resType ; operand *size ; int isarray = 0; LRTYPE ; @@ -1663,10 +1663,10 @@ operand *geniCodeAdd (operand *left, operand *right ) /*-----------------------------------------------------------------*/ /* aggrToPtr - changes an aggregate to pointer to an aggregate */ /*-----------------------------------------------------------------*/ -link *aggrToPtr ( link *type, bool force) +sym_link *aggrToPtr ( sym_link *type, bool force) { - link *etype ; - link *ptype ; + sym_link *etype ; + sym_link *ptype ; if (IS_PTR(type) && !force) @@ -1696,8 +1696,8 @@ link *aggrToPtr ( link *type, bool force) /*-----------------------------------------------------------------*/ operand *geniCodeArray2Ptr (operand *op) { - link *optype = operandType(op); - link *opetype = getSpec(optype); + sym_link *optype = operandType(op); + sym_link *opetype = getSpec(optype); /* set the pointer depending on the storage class */ if ((DCL_TYPE(optype) = PTR_TYPE(SPEC_OCLS(opetype))) == CPOINTER) @@ -1722,7 +1722,7 @@ operand *geniCodeArray2Ptr (operand *op) operand *geniCodeArray (operand *left,operand *right) { iCode *ic; - link *ltype = operandType(left); + sym_link *ltype = operandType(left); if (IS_PTR(ltype)) { if (IS_PTR(ltype->next) && left->isaddr) @@ -1768,9 +1768,9 @@ operand *geniCodeArray (operand *left,operand *right) operand *geniCodeStruct (operand *left, operand *right, bool islval) { iCode *ic ; - link *type = operandType(left); - link *etype = getSpec(type); - link *retype ; + sym_link *type = operandType(left); + sym_link *etype = getSpec(type); + sym_link *retype ; symbol *element = getStructElement(SPEC_STRUCT(etype), right->operand.symOperand); @@ -1803,12 +1803,12 @@ operand *geniCodePostInc (operand *op) { iCode *ic ; operand *rOp ; - link *optype = operandType(op); + sym_link *optype = operandType(op); operand *result ; operand *rv = (IS_ITEMP(op) ? geniCodeRValue(op,(IS_PTR(optype) ? TRUE : FALSE)) : op); - link *rvtype = operandType(rv); + sym_link *rvtype = operandType(rv); int size = 0; /* if this is not an address we have trouble */ @@ -1842,11 +1842,11 @@ operand *geniCodePostInc (operand *op) operand *geniCodePreInc (operand *op) { iCode *ic ; - link *optype = operandType(op); + sym_link *optype = operandType(op); operand *rop = (IS_ITEMP(op) ? geniCodeRValue (op,(IS_PTR(optype) ? TRUE : FALSE)) : op); - link *roptype = operandType(rop); + sym_link *roptype = operandType(rop); operand *result; int size = 0; @@ -1872,12 +1872,12 @@ operand *geniCodePostDec (operand *op) { iCode *ic ; operand *rOp ; - link *optype = operandType(op); + sym_link *optype = operandType(op); operand *result ; operand *rv = (IS_ITEMP(op) ? geniCodeRValue(op,(IS_PTR(optype) ? TRUE : FALSE)) : op); - link *rvtype = operandType(rv); + sym_link *rvtype = operandType(rv); int size = 0; /* if this is not an address we have trouble */ @@ -1911,11 +1911,11 @@ operand *geniCodePostDec (operand *op) operand *geniCodePreDec (operand *op) { iCode *ic ; - link *optype = operandType(op); + sym_link *optype = operandType(op); operand *rop = (IS_ITEMP(op) ? geniCodeRValue (op,(IS_PTR(optype) ? TRUE : FALSE)) : op); - link *roptype = operandType(rop); + sym_link *roptype = operandType(rop); operand *result; int size = 0; @@ -1939,7 +1939,7 @@ operand *geniCodePreDec (operand *op) /* geniCodeBitwise - gen int code for bitWise operators */ /*-----------------------------------------------------------------*/ operand *geniCodeBitwise (operand *left, operand *right, - int oper, link *resType) + int oper, sym_link *resType) { iCode *ic; @@ -1959,9 +1959,9 @@ operand *geniCodeBitwise (operand *left, operand *right, operand *geniCodeAddressOf (operand *op) { iCode *ic; - link *p ; - link *optype = operandType(op); - link *opetype= getSpec(optype); + sym_link *p ; + sym_link *optype = operandType(op); + sym_link *opetype= getSpec(optype); /* lvalue check already done in decorateType */ /* this must be a lvalue */ @@ -2003,7 +2003,7 @@ operand *geniCodeAddressOf (operand *op) /*-----------------------------------------------------------------*/ /* setOClass - sets the output class depending on the pointer type */ /*-----------------------------------------------------------------*/ -void setOClass (link *ptr, link *spec) +void setOClass (sym_link *ptr, sym_link *spec) { switch (DCL_TYPE(ptr)) { case POINTER: @@ -2045,8 +2045,8 @@ void setOClass (link *ptr, link *spec) /*-----------------------------------------------------------------*/ operand *geniCodeDerefPtr (operand *op) { - link *rtype , *retype ; - link *optype = operandType(op); + sym_link *rtype , *retype ; + sym_link *optype = operandType(op); /* if this is a pointer then generate the rvalue */ if (IS_PTR(optype)) { @@ -2099,7 +2099,7 @@ operand *geniCodeDerefPtr (operand *op) operand *geniCodeUnaryMinus (operand *op) { iCode *ic ; - link *optype = operandType(op); + sym_link *optype = operandType(op); if (IS_LITERAL(optype)) return operandFromLit(- floatFromVal(op->operand.valOperand)); @@ -2116,7 +2116,7 @@ operand *geniCodeUnaryMinus (operand *op) operand *geniCodeLeftShift (operand *left, operand *right) { iCode *ic; - link *ltype = operandType(left); + sym_link *ltype = operandType(left); ic = newiCode(LEFT_OP,left,right); IC_RESULT(ic) = newiTempOperand(ltype,0); @@ -2130,7 +2130,7 @@ operand *geniCodeLeftShift (operand *left, operand *right) operand *geniCodeRightShift (operand *left, operand *right) { iCode *ic; - link *ltype = operandType(left); + sym_link *ltype = operandType(left); ic = newiCode(RIGHT_OP,left,right); IC_RESULT(ic) = newiTempOperand(ltype,0); @@ -2150,9 +2150,9 @@ operand *geniCodeRightShift (operand *left, operand *right) operand *geniCodeLogic (operand *left, operand *right, int op ) { iCode *ic ; - link *ctype; - link *rtype = operandType(right); - link *ltype = operandType(left); + sym_link *ctype; + sym_link *rtype = operandType(right); + sym_link *ltype = operandType(left); /* left is integral type and right is literal then check if the literal value is within bounds */ @@ -2239,8 +2239,8 @@ operand *geniCodeConditional (ast *tree) operand *geniCodeAssign (operand *left, operand *right, int nosupdate) { iCode *ic ; - link *ltype = operandType(left); - link *rtype = operandType(right); + sym_link *ltype = operandType(left); + sym_link *rtype = operandType(right); if (!left->isaddr && !IS_ITEMP(left)) { werror(E_LVALUE_REQUIRED,"assignment"); @@ -2335,7 +2335,7 @@ static void geniCodeSEParms (ast *parms) /*-----------------------------------------------------------------*/ /* geniCodeParms - generates parameters */ /*-----------------------------------------------------------------*/ -static void geniCodeParms ( ast *parms , int *stack, link *fetype, symbol *func) +static void geniCodeParms ( ast *parms , int *stack, sym_link *fetype, symbol *func) { iCode *ic ; operand *pval ; @@ -2382,7 +2382,7 @@ static void geniCodeParms ( ast *parms , int *stack, link *fetype, symbol *func) geniCodeAssign(top,pval,1); } else { - link *p = operandType(pval); + sym_link *p = operandType(pval); /* push */ ic = newiCode(IPUSH,pval,NULL); ic->parmPush = 1; @@ -2401,7 +2401,7 @@ operand *geniCodeCall (operand *left, ast *parms) { iCode *ic ; operand *result ; - link *type, *etype; + sym_link *type, *etype; int stack = 0 ; /* take care of parameters with side-effecting @@ -2481,7 +2481,7 @@ void geniCodeFunctionBody (ast *tree) { iCode *ic ; operand *func ; - link *fetype ; + sym_link *fetype ; int savelineno ; /* reset the auto generation */ @@ -2546,7 +2546,7 @@ void geniCodeIfx (ast *tree) { iCode *ic; operand *condition = ast2iCode(tree->left); - link *cetype; + sym_link *cetype; /* if condition is null then exit */ if (!condition) @@ -2649,7 +2649,7 @@ int geniCodeJumpTable (operand *cond, value *caseVals, ast *tree) /* first we rule out the boundary conditions */ /* if only optimization says so */ if ( ! optimize.noJTabBoundary ) { - link *cetype = getSpec(operandType(cond)); + sym_link *cetype = getSpec(operandType(cond)); /* no need to check the lower bound if the condition is unsigned & minimum value is zero */ if (!( min == 0 && SPEC_USIGN(cetype))) { @@ -2820,7 +2820,7 @@ operand *ast2iCode (ast *tree) case '[' : /* array operation */ { - link *ltype = operandType(left); + sym_link *ltype = operandType(left); left= geniCodeRValue (left,IS_PTR(ltype->next) ? TRUE : FALSE); right=geniCodeRValue (right,TRUE); } @@ -2837,7 +2837,7 @@ operand *ast2iCode (ast *tree) case PTR_OP: /* structure pointer dereference */ { - link *pType; + sym_link *pType; pType = operandType(left); left = geniCodeRValue(left,TRUE); @@ -2943,8 +2943,8 @@ operand *ast2iCode (ast *tree) case '=' : { - link *rtype = operandType(right); - link *ltype = operandType(left); + sym_link *rtype = operandType(right); + sym_link *ltype = operandType(left); if (IS_PTR(rtype) && IS_ITEMP(right) && right->isaddr && checkType(rtype->next,ltype)==1) right = geniCodeRValue(right,TRUE); @@ -2975,8 +2975,8 @@ operand *ast2iCode (ast *tree) geniCodeRValue(right,FALSE)),0); case ADD_ASSIGN: { - link *rtype = operandType(right); - link *ltype = operandType(left); + sym_link *rtype = operandType(right); + sym_link *ltype = operandType(left); if (IS_PTR(rtype) && IS_ITEMP(right) && right->isaddr && checkType(rtype->next,ltype)==1) right = geniCodeRValue(right,TRUE); @@ -2991,8 +2991,8 @@ operand *ast2iCode (ast *tree) } case SUB_ASSIGN: { - link *rtype = operandType(right); - link *ltype = operandType(left); + sym_link *rtype = operandType(right); + sym_link *ltype = operandType(left); if (IS_PTR(rtype) && IS_ITEMP(right) && right->isaddr && checkType(rtype->next,ltype)==1) { right = geniCodeRValue(right,TRUE); diff --git a/src/SDCCicode.h b/src/SDCCicode.h index b394c56d..62ea5b41 100644 --- a/src/SDCCicode.h +++ b/src/SDCCicode.h @@ -47,9 +47,9 @@ typedef enum { #define IS_SYMOP(op) (op && op->type == SYMBOL) #define ADDTOCHAIN(x) addSetHead(&iCodeChain,x) -#define LRFTYPE link *ltype = operandType(left), \ +#define LRFTYPE sym_link *ltype = operandType(left), \ *rtype = operandType(right) ; -#define LRETYPE link *letype= getSpec(ltype) , \ +#define LRETYPE sym_link *letype= getSpec(ltype) , \ *retype= getSpec(rtype); #define LRTYPE LRFTYPE LRETYPE #define IS_ITEMP(op) (IS_SYMOP(op) && op->operand.symOperand->isitmp == 1) @@ -86,7 +86,7 @@ typedef struct operand { union { struct symbol *symOperand ; /* operand is of type symbol */ struct value *valOperand ; /* operand is of type value */ - struct link *typeOperand; /* operand is of type typechain */ + struct sym_link *typeOperand; /* operand is of type typechain */ } operand ; bitVect *usesDefs; /* which definitions are used by this */ @@ -250,7 +250,7 @@ int isOperandVolatile (operand *,bool); int isOperandGlobal (operand *); void printiCChain ( iCode * , FILE *); operand *ast2iCode ( ast *); -operand *geniCodeCast ( link *, operand *,bool); +operand *geniCodeCast ( sym_link *, operand *,bool); operand *geniCodePtrPtrSubtract (operand *, operand *); void initiCode (); iCode *iCodeFromAst ( ast * ); @@ -258,7 +258,7 @@ int isiCodeEqual ( iCode *,iCode *) ; int isOperandEqual ( operand *, operand *); iCodeTable *getTableEntry (int ); int isOperandLiteral (operand *); -operand *operandOperation (operand *,operand *,int,link *); +operand *operandOperation (operand *,operand *,int,sym_link *); double operandLitValue ( operand * ); operand *operandFromLit (float); operand *operandFromOperand(operand *); @@ -268,13 +268,13 @@ symbol *newiTemp(char *); symbol *newiTempLabel (char *); symbol *newiTempPreheaderLabel (); iCode *newiCode (int, operand *, operand *); -link *operandType(operand *); +sym_link *operandType(operand *); operand *operandFromValue (value *); operand *operandFromSymbol(symbol *); -link *aggrToPtr ( link *, bool); +sym_link *aggrToPtr ( sym_link *, bool); int piCode (void *, FILE * ); int printOperand (operand *,FILE *); -void setOperandType (operand *, link *); +void setOperandType (operand *, sym_link *); bool isOperandInFarSpace (operand *); operand *opFromOpWithDU (operand *,bitVect *,bitVect *); iCode *copyiCode (iCode *); diff --git a/src/SDCClrange.c b/src/SDCClrange.c index 7e6ea7c0..daca5285 100644 --- a/src/SDCClrange.c +++ b/src/SDCClrange.c @@ -295,8 +295,8 @@ operand *operandLUse (operand *op, eBBlock **ebbs, if (!OP_SYMBOL(op)->udChked) { - link *type = operandType(op); - link *etype = getSpec(type); + sym_link *type = operandType(op); + sym_link *etype = getSpec(type); OP_SYMBOL(op)->udChked = 1; /* good place to check if unintialised */ diff --git a/src/SDCCopt.c b/src/SDCCopt.c index 7905af2a..1f12948b 100644 --- a/src/SDCCopt.c +++ b/src/SDCCopt.c @@ -158,7 +158,7 @@ static void cnvToFloatCast (iCode *ic, eBBlock *ebp) { iCode *ip, *newic; symbol *func; - link *type = operandType(IC_RIGHT(ic)); + sym_link *type = operandType(IC_RIGHT(ic)); int linenno = ic->lineno; int bwd, su; @@ -217,7 +217,7 @@ static void cnvFromFloatCast (iCode *ic, eBBlock *ebp) { iCode *ip, *newic; symbol *func; - link *type = operandType(IC_LEFT(ic)); + sym_link *type = operandType(IC_LEFT(ic)); int lineno = ic->lineno ; int bwd, su; @@ -274,7 +274,7 @@ static void cnvFromFloatCast (iCode *ic, eBBlock *ebp) /*-----------------------------------------------------------------*/ /* convilong - converts int or long mults or divs to fcalls */ /*-----------------------------------------------------------------*/ -static void convilong (iCode *ic, eBBlock *ebp, link *type, int op) +static void convilong (iCode *ic, eBBlock *ebp, sym_link *type, int op) { symbol *func = NULL; iCode *ip = ic->next; @@ -393,7 +393,7 @@ static void convertToFcall (eBBlock **ebbs, int count) /* if long / int mult or divide or mod */ if (ic->op == '*' || ic->op == '/' || ic->op == '%' ) { - link *type = operandType(IC_LEFT(ic)); + sym_link *type = operandType(IC_LEFT(ic)); if (IS_INTEGRAL(type) && getSize(type) > port->muldiv.native_below) convilong (ic,ebbs[i],type,ic->op); } diff --git a/src/SDCCsymt.c b/src/SDCCsymt.c index 7820297e..0e3880b4 100644 --- a/src/SDCCsymt.c +++ b/src/SDCCsymt.c @@ -233,11 +233,11 @@ symbol *newSymbol (char *name, int scope ) /*------------------------------------------------------------------*/ /* newLink - creates a new link (declarator,specifier) */ /*------------------------------------------------------------------*/ -link *newLink () +sym_link *newLink () { - link *p ; + sym_link *p ; - ALLOC(p,sizeof(link)); + ALLOC(p,sizeof(sym_link)); return p; } @@ -258,7 +258,7 @@ structdef *newStruct ( char *tag ) /*------------------------------------------------------------------*/ /* pointerTypes - do the computation for the pointer types */ /*------------------------------------------------------------------*/ -void pointerTypes (link *ptr, link *type) +void pointerTypes (sym_link *ptr, sym_link *type) { if (IS_SPEC(ptr)) return ; @@ -328,11 +328,11 @@ void pointerTypes (link *ptr, link *type) /*------------------------------------------------------------------*/ /* addDecl - adds a declarator @ the end of a chain */ /*------------------------------------------------------------------*/ -void addDecl ( symbol *sym, int type , link *p ) +void addDecl ( symbol *sym, int type , sym_link *p ) { - link *head; - link *tail; - link *t ; + sym_link *head; + sym_link *tail; + sym_link *t ; /* if we are passed a link then set head & tail */ if ( p ) { @@ -390,7 +390,7 @@ void addDecl ( symbol *sym, int type , link *p ) /*------------------------------------------------------------------*/ /* mergeSpec - merges two specifiers and returns the new one */ /*------------------------------------------------------------------*/ -link *mergeSpec ( link *dest, link *src ) +sym_link *mergeSpec ( sym_link *dest, sym_link *src ) { /* if noun different then src overrides */ if ( SPEC_NOUN(dest) != SPEC_NOUN(src) && !SPEC_NOUN(dest)) @@ -427,16 +427,16 @@ link *mergeSpec ( link *dest, link *src ) /*------------------------------------------------------------------*/ /* cloneSpec - copies the entire spec and returns a new spec */ /*------------------------------------------------------------------*/ -link *cloneSpec ( link *src ) +sym_link *cloneSpec ( sym_link *src ) { - link *spec ; + sym_link *spec ; /* go thru chain till we find the specifier */ while ( src && src->class != SPECIFIER ) src = src->next ; spec = newLink() ; - memcpy (spec,src,sizeof(link)); + memcpy (spec,src,sizeof(sym_link)); return spec ; } @@ -455,9 +455,9 @@ char *genSymName ( int level ) /*------------------------------------------------------------------*/ /* getSpec - returns the specifier part from a declaration chain */ /*------------------------------------------------------------------*/ -link *getSpec ( link *p ) +sym_link *getSpec ( sym_link *p ) { - link *loop ; + sym_link *loop ; loop = p ; while ( p && ! (IS_SPEC(p))) @@ -469,9 +469,9 @@ link *getSpec ( link *p ) /*------------------------------------------------------------------*/ /* newCharLink() - creates an int type */ /*------------------------------------------------------------------*/ -link *newCharLink() +sym_link *newCharLink() { - link *p; + sym_link *p; p = newLink(); p->class = SPECIFIER ; @@ -483,9 +483,9 @@ link *newCharLink() /*------------------------------------------------------------------*/ /* newFloatLink - a new Float type */ /*------------------------------------------------------------------*/ -link *newFloatLink() +sym_link *newFloatLink() { - link *p; + sym_link *p; p = newLink(); p->class = SPECIFIER ; @@ -497,9 +497,9 @@ link *newFloatLink() /*------------------------------------------------------------------*/ /* newLongLink() - new long type */ /*------------------------------------------------------------------*/ -link *newLongLink() +sym_link *newLongLink() { - link *p; + sym_link *p; p = newLink(); p->class = SPECIFIER ; @@ -512,9 +512,9 @@ link *newLongLink() /*------------------------------------------------------------------*/ /* newIntLink() - creates an int type */ /*------------------------------------------------------------------*/ -link *newIntLink() +sym_link *newIntLink() { - link *p; + sym_link *p; p = newLink(); p->class = SPECIFIER ; @@ -526,7 +526,7 @@ link *newIntLink() /*------------------------------------------------------------------*/ /* getSize - returns size of a type chain in bits */ /*------------------------------------------------------------------*/ -unsigned int getSize ( link *p ) +unsigned int getSize ( sym_link *p ) { /* if nothing return 0 */ if ( ! p ) @@ -579,7 +579,7 @@ unsigned int getSize ( link *p ) /*------------------------------------------------------------------*/ /* bitsForType - returns # of bits required to store this type */ /*------------------------------------------------------------------*/ -unsigned int bitsForType ( link *p ) +unsigned int bitsForType ( sym_link *p ) { /* if nothing return 0 */ if ( ! p ) @@ -698,9 +698,9 @@ symbol *reverseSyms ( symbol *sym) /*------------------------------------------------------------------*/ /* reverseLink - reverses the links for a type chain */ /*------------------------------------------------------------------*/ -link *reverseLink ( link *type) +sym_link *reverseLink ( sym_link *type) { - link *prev , *curr, *next ; + sym_link *prev , *curr, *next ; if (!type) return NULL ; @@ -770,7 +770,7 @@ void addSymChain ( symbol *symHead ) /*------------------------------------------------------------------*/ /* funcInChain - DCL Type 'FUNCTION' found in type chain */ /*------------------------------------------------------------------*/ -int funcInChain (link *lnk) +int funcInChain (sym_link *lnk) { while (lnk) { if (IS_FUNC(lnk)) @@ -783,11 +783,11 @@ int funcInChain (link *lnk) /*------------------------------------------------------------------*/ /* structElemType - returns the type info of a sturct member */ /*------------------------------------------------------------------*/ -link *structElemType (link *stype, value *id ,value **argsp) +sym_link *structElemType (sym_link *stype, value *id ,value **argsp) { symbol *fields = (SPEC_STRUCT(stype) ? SPEC_STRUCT(stype)->fields : NULL); - link *type, *etype; - link *petype = getSpec(stype); + sym_link *type, *etype; + sym_link *petype = getSpec(stype); if ( ! fields || ! id) return NULL ; @@ -1037,7 +1037,7 @@ static void checkSClass ( symbol *sym ) /*------------------------------------------------------------------*/ void changePointer (symbol *sym) { - link *p ; + sym_link *p ; /* go thru the chain of declarations */ /* if we find a pointer to a function */ @@ -1071,14 +1071,14 @@ int checkDecl ( symbol *sym ) /*------------------------------------------------------------------*/ /* copyLinkChain - makes a copy of the link chain & rets ptr 2 head */ /*------------------------------------------------------------------*/ -link *copyLinkChain ( link *p) +sym_link *copyLinkChain ( sym_link *p) { - link *head, *curr , *loop; + sym_link *head, *curr , *loop; curr = p ; head = loop = ( curr ? newLink() : (void *) NULL) ; while (curr) { - memcpy(loop,curr,sizeof(link)) ; /* copy it */ + memcpy(loop,curr,sizeof(sym_link)) ; /* copy it */ loop->next = (curr->next ? newLink() : (void *) NULL) ; loop = loop->next ; curr = curr->next ; @@ -1129,12 +1129,12 @@ void cleanUpLevel (bucket **table, int level ) /*------------------------------------------------------------------*/ /* computeType - computes the resultant type from two types */ /*------------------------------------------------------------------*/ -link *computeType ( link *type1, link *type2) +sym_link *computeType ( sym_link *type1, sym_link *type2) { - link *rType ; - link *reType; - link *etype1 = getSpec(type1); - link *etype2 = getSpec(type2); + sym_link *rType ; + sym_link *reType; + sym_link *etype1 = getSpec(type1); + sym_link *etype2 = getSpec(type2); /* if one of them is a float then result is a float */ /* here we assume that the types passed are okay */ @@ -1180,7 +1180,7 @@ link *computeType ( link *type1, link *type2) /*------------------------------------------------------------------*/ /* checkType - will do type check return 1 if match */ /*------------------------------------------------------------------*/ -int checkType ( link *dest, link *src ) +int checkType ( sym_link *dest, sym_link *src ) { if ( !dest && !src) return 1; @@ -1437,7 +1437,7 @@ void processFuncArgs (symbol *func, int ignoreName) /* then we need to add a new link */ if (IS_STRUCT(val->type)) { /* first lets add DECLARATOR type */ - link *p = val->type ; + sym_link *p = val->type ; werror(W_STRUCT_AS_ARG,val->name); val->type = newLink(); @@ -1547,7 +1547,7 @@ int isSymbolEqual (symbol *dest, symbol *src) /*-----------------------------------------------------------------*/ /* printTypeChain - prints the type chain in human readable form */ /*-----------------------------------------------------------------*/ -void printTypeChain (link *type, FILE *of) +void printTypeChain (sym_link *type, FILE *of) { int nlr = 0; @@ -1662,7 +1662,7 @@ void printTypeChain (link *type, FILE *of) /*-----------------------------------------------------------------*/ /* cdbTypeInfo - print the type information for debugger */ /*-----------------------------------------------------------------*/ -void cdbTypeInfo (link *type,FILE *of) +void cdbTypeInfo (sym_link *type,FILE *of) { fprintf(of,"{%d}",getSize(type)); while (type) { @@ -1878,11 +1878,11 @@ symbol *__fsgteq; /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */ symbol *__muldiv[3][3][2]; /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */ -link *__multypes[3][2]; +sym_link *__multypes[3][2]; /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */ symbol *__conv[2][3][2]; -link *floatType; +sym_link *floatType; static void _makeRegParam(symbol *sym) { @@ -1919,7 +1919,7 @@ void initCSupport () floatType= newFloatLink(); for (bwd = 0; bwd < 3; bwd++) { - link *l; + sym_link *l; switch (bwd) { case 0: l = newCharLink(); diff --git a/src/SDCCsymt.h b/src/SDCCsymt.h index 1829a3bf..9cad165d 100644 --- a/src/SDCCsymt.h +++ b/src/SDCCsymt.h @@ -141,13 +141,13 @@ typedef struct declarator { unsigned int num_elem; /* # of elems if type==array */ short ptr_const :1; /* pointer is constant */ short ptr_volatile:1; /* pointer is volatile */ - struct link *tspec; /* pointer type specifier */ + struct sym_link *tspec; /* pointer type specifier */ } declarator ; #define DECLARATOR 0 #define SPECIFIER 1 -typedef struct link { +typedef struct sym_link { unsigned class : 1 ; /* DECLARATOR or SPECIFIER */ unsigned tdef : 1 ; /* current link created by */ /* typedef if this flag is set*/ @@ -156,8 +156,8 @@ typedef struct link { declarator d ; /* if CLASS == DECLARATOR */ } select ; - struct link *next ; /* next element on the chain */ -} link ; + struct sym_link *next ; /* next element on the chain */ +} sym_link ; typedef struct symbol { char name [SDCC_NAME_MAX+1] ; /* Input Variable Name */ @@ -230,12 +230,12 @@ typedef struct symbol { int lineDef ; /* defined line number */ int lastLine ; /* for functions the last line*/ - struct link *type ; /* 1st link to declator chain */ - struct link *etype ; /* last link to declarator chn*/ + struct sym_link *type ; /* 1st link to declator chain */ + struct sym_link *etype ; /* last link to declarator chn*/ struct value *args ; /* arguments if function */ struct symbol *next ; /* crosslink to next symbol */ struct symbol *localof ; /* local variable of which function */ - struct initList *ival ; /* ptr to initializer if any */ + struct initList *ival ; /* ptr to initializer if any */ struct bitVect *defs ; /* bit vector for definitions */ struct bitVect *uses ; /* bit vector for uses */ struct bitVect *regsUsed ; /* for functions registers used */ @@ -352,7 +352,7 @@ extern symbol *__fsgteq; /* Dims: mul/div/mod, BYTE/WORD/DWORD, SIGNED/UNSIGNED */ extern symbol *__muldiv[3][3][2]; /* Dims: BYTE/WORD/DWORD SIGNED/UNSIGNED */ -extern link *__multypes[3][2]; +extern sym_link *__multypes[3][2]; /* Dims: to/from float, BYTE/WORD/DWORD, SIGNED/USIGNED */ extern symbol *__conv[2][3][2]; @@ -360,56 +360,56 @@ extern symbol *__conv[2][3][2]; #define INTTYPE __multypes[1][0] #define UCHARTYPE __multypes[0][1] -extern link *floatType; +extern sym_link *floatType; #include "SDCCval.h" /* forward definitions for the symbol table related functions */ void initSymt ( ); symbol *newSymbol ( char *, int ); -link *newLink ( ); +sym_link *newLink ( ); structdef *newStruct ( char * ); -void addDecl ( symbol *, int , link * ); -link *mergeSpec ( link *, link * ); -link *cloneSpec ( link * ); -symbol *reverseSyms ( symbol * ); -link *reverseLink ( link * ); +void addDecl ( symbol *, int , sym_link * ); +sym_link *mergeSpec ( sym_link *, sym_link * ); +sym_link *cloneSpec ( sym_link * ); +symbol *reverseSyms ( symbol * ); +sym_link *reverseLink ( sym_link * ); symbol *copySymbol ( symbol * ); symbol *copySymbolChain ( symbol * ); void printSymChain ( symbol *, int ); void printStruct ( structdef *, int ); char *genSymName ( int ); -link *getSpec ( link * ); +sym_link *getSpec ( sym_link * ); char *genSymName ( int ); int compStructSize ( int ,structdef * ); -link *copyLinkChain ( link * ); +sym_link *copyLinkChain ( sym_link * ); int checkDecl ( symbol * ); -void checkBasic ( link *, link * ); -value *checkPointerIval ( link *, value * ); +void checkBasic ( sym_link *, sym_link * ); +value *checkPointerIval ( sym_link *, value * ); value *checkStructIval ( symbol *, value * ); -value *checkArrayIval ( link *, value * ); -value *checkIval ( link *, value * ); -unsigned int getSize ( link * ); -unsigned int bitsForType ( link * ); -link *newIntLink ( ); -link *newCharLink ( ); -link *newLongLink ( ); -int checkType ( link *, link * ); +value *checkArrayIval ( sym_link *, value * ); +value *checkIval ( sym_link *, value * ); +unsigned int getSize ( sym_link * ); +unsigned int bitsForType ( sym_link * ); +sym_link *newIntLink ( ); +sym_link *newCharLink ( ); +sym_link *newLongLink ( ); +int checkType ( sym_link *, sym_link * ); int checkFunction ( symbol * ); void cleanUpLevel ( bucket **,int ); void cleanUpBlock ( bucket **,int ); -int funcInChain ( link * ); +int funcInChain ( sym_link * ); void addSymChain ( symbol * ); -link *structElemType ( link *, value * , value ** ); +sym_link *structElemType ( sym_link *, value * , value ** ); symbol *getStructElement ( structdef *, symbol *) ; -link *computeType ( link *, link *); +sym_link *computeType ( sym_link *, sym_link *); void processFuncArgs (symbol *,int); int isSymbolEqual (symbol *, symbol *); int powof2 (unsigned long ); -void printTypeChain (link *,FILE *); +void printTypeChain (sym_link *,FILE *); void initCSupport (); -void pointerTypes (link *, link * ); -void cdbTypeInfo (link *,FILE *); +void pointerTypes (sym_link *, sym_link * ); +void cdbTypeInfo (sym_link *,FILE *); void cdbSymbol (symbol *,FILE *,int,int); void cdbStructBlock (int ,FILE *); void initHashT ( ); diff --git a/src/SDCCval.c b/src/SDCCval.c index 69e9a53b..001e1210 100644 --- a/src/SDCCval.c +++ b/src/SDCCval.c @@ -413,8 +413,8 @@ value *strVal ( char *s ) /*------------------------------------------------------------------*/ value *reverseValWithType ( value *val ) { - link *type ; - link *etype; + sym_link *type ; + sym_link *etype; if (!val) return NULL ; @@ -562,7 +562,7 @@ value *charVal ( char *s ) /*------------------------------------------------------------------*/ /* valFromType - creates a value from type given */ /*------------------------------------------------------------------*/ -value *valFromType ( link *type) +value *valFromType ( sym_link *type) { value *val = newValue(); val->type = copyLinkChain(type); @@ -1082,7 +1082,7 @@ value *valLogicAndOr (value *lval, value *rval, int op) /*------------------------------------------------------------------*/ /* valCastLiteral - casts a literal value to another type */ /*------------------------------------------------------------------*/ -value *valCastLiteral (link *dtype, double fval) +value *valCastLiteral (sym_link *dtype, double fval) { value *val ; @@ -1121,9 +1121,9 @@ value *valCastLiteral (link *dtype, double fval) /*------------------------------------------------------------------*/ /* getNelements - determines # of elements from init list */ /*------------------------------------------------------------------*/ -int getNelements (link *type,initList *ilist) +int getNelements (sym_link *type,initList *ilist) { - link *etype = getSpec(type); + sym_link *etype = getSpec(type); int i; if (! ilist) @@ -1295,7 +1295,7 @@ value *valForStructElem(ast *structT, ast *elemT) /* valForCastAggr - will return value for a cast of an aggregate */ /* plus minus a constant */ /*-----------------------------------------------------------------*/ -value *valForCastAggr (ast *aexpr, link *type, ast *cnst, int op) +value *valForCastAggr (ast *aexpr, sym_link *type, ast *cnst, int op) { value *val; diff --git a/src/SDCCval.h b/src/SDCCval.h index 3751bc6d..018213d4 100644 --- a/src/SDCCval.h +++ b/src/SDCCval.h @@ -27,8 +27,8 @@ /* value wrapper */ typedef struct value { char name[ SDCC_NAME_MAX + 1 ]; /* operand accessing this value */ - link *type ; /* start of type chain */ - link *etype; /* end of type chain */ + sym_link *type ; /* start of type chain */ + sym_link *etype; /* end of type chain */ symbol *sym ; /* Original Symbol */ struct value *next ; /* used in initializer list*/ unsigned vArgs : 1 ; /* arg list ended with variable arg */ @@ -81,7 +81,7 @@ value *valShift (value *, value *,int); value *valCompare (value *, value *,int); value *valBitwise (value *, value *,int); value *valLogicAndOr (value *, value *,int); -value *valCastLiteral (link *, double ); +value *valCastLiteral (sym_link *, double ); value *valueFromLit (float ); initList *newiList (int , void * ); initList *revinit (initList * ); @@ -90,10 +90,10 @@ double list2int (initList * ); value *list2val (initList * ); struct ast *list2expr (initList * ); void resolveIvalSym (initList * ); -value *valFromType (link * ); +value *valFromType (sym_link * ); value *constFloatVal (char * ); -int getNelements (link *, initList * ); +int getNelements (sym_link *, initList * ); value *valForArray (struct ast * ); value *valForStructElem (struct ast *, struct ast *); -value *valForCastAggr (struct ast *, link *, struct ast *, int ) ; +value *valForCastAggr (struct ast *, sym_link *, struct ast *, int ) ; #endif diff --git a/src/avr/gen.c b/src/avr/gen.c index 3f53aebd..2f815ffd 100644 --- a/src/avr/gen.c +++ b/src/avr/gen.c @@ -242,7 +242,7 @@ static asmop *newAsmop (short type) /*-----------------------------------------------------------------*/ /* pointerCode - returns the code for a pointer type */ /*-----------------------------------------------------------------*/ -static int pointerCode (link *etype) +static int pointerCode (sym_link *etype) { return PTR_TYPE(SPEC_OCLS(etype)); @@ -958,7 +958,7 @@ static void genNotFloat (operand *op, operand *res) /*-----------------------------------------------------------------*/ static int opIsGptr(operand *op) { - link *type = operandType(op); + sym_link *type = operandType(op); if ((AOP_SIZE(op) == GPTRSIZE) && IS_GENPTR(type)) { @@ -976,7 +976,7 @@ static int getDataSize(operand *op) size = AOP_SIZE(op); if (size == GPTRSIZE) { - link *type = operandType(op); + sym_link *type = operandType(op); if (IS_GENPTR(type)) { /* generic pointer; arithmetic operations @@ -1035,7 +1035,7 @@ static void toBoolean(operand *oper, char *r, bool clr) static void genNot (iCode *ic) { symbol *tlbl; - link *optype = operandType(IC_LEFT(ic)); + sym_link *optype = operandType(IC_LEFT(ic)); int size, offset = 1; /* assign asmOps to operand & result */ @@ -1138,7 +1138,7 @@ static void genUminusFloat(operand *op,operand *result) static void genUminus (iCode *ic) { int offset ,size ; - link *optype, *rtype; + sym_link *optype, *rtype; int samer ; /* assign asmops */ @@ -1471,7 +1471,7 @@ static bool inExcludeList(char *s) static void genFunction (iCode *ic) { symbol *sym; - link *fetype; + sym_link *fetype; int i = 0; _G.nRegsSaved = 0; @@ -1949,7 +1949,7 @@ static void genMultOneByte (operand *left, operand *right, operand *result) { - link *opetype = operandType(result); + sym_link *opetype = operandType(result); symbol *lbl ; int size,offset; @@ -2093,7 +2093,7 @@ static void genBranch (iCode *ifx, int br_type, int sign) static void genCmp (iCode *ic, iCode *ifx, int br_type) { operand *left, *right, *result; - link *letype , *retype; + sym_link *letype , *retype; symbol *lbl; int sign, size, offset =0; @@ -2908,7 +2908,7 @@ static void genShiftRightLit (iCode *ic) ,*result=IC_RESULT(ic); int size , shCount, offset =0; int hByteZ=0; - link *letype = getSpec(operandType(left)); + sym_link *letype = getSpec(operandType(left)); int sign = !SPEC_USIGN(letype); right = IC_RIGHT(ic); @@ -3109,7 +3109,7 @@ static void genShiftRightLit (iCode *ic) static void genRightShift (iCode *ic) { operand *right, *left, *result; - link *letype ; + sym_link *letype ; int size, offset; int sign = 0, first =1; symbol *tlbl; @@ -3211,7 +3211,7 @@ static void genUnpackBits (operand *result, char *rname, int ptype) { int shCnt ; int rlen = 0 ; - link *etype; + sym_link *etype; int offset = 0 ; etype = getSpec(operandType(result)); @@ -3327,8 +3327,8 @@ static void genNearPointerGet (operand *left, asmop *aop = NULL; regs *preg = NULL ; char *rname ; - link *rtype, *retype; - link *ltype = operandType(left); + sym_link *rtype, *retype; + sym_link *ltype = operandType(left); char buffer[80]; rtype = operandType(result); @@ -3421,7 +3421,7 @@ static void genPagedPointerGet (operand *left, asmop *aop = NULL; regs *preg = NULL ; char *rname ; - link *rtype, *retype; + sym_link *rtype, *retype; rtype = operandType(result); retype= getSpec(rtype); @@ -3497,7 +3497,7 @@ static void genFarPointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(result)); aopOp(left,ic,FALSE); @@ -3545,7 +3545,7 @@ static void emitcodePointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(result)); aopOp(left,ic,FALSE); @@ -3594,7 +3594,7 @@ static void genGenPointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(result)); aopOp(left,ic,FALSE); @@ -3648,7 +3648,7 @@ static void genGenPointerGet (operand *left, static void genPointerGet (iCode *ic) { operand *left, *result ; - link *type, *etype; + sym_link *type, *etype; int p_type; left = IC_LEFT(ic); @@ -3712,7 +3712,7 @@ static void genPointerGet (iCode *ic) /*-----------------------------------------------------------------*/ /* genPackBits - generates code for packed bit storage */ /*-----------------------------------------------------------------*/ -static void genPackBits (link *etype , +static void genPackBits (sym_link *etype , operand *right , char *rname, int p_type) { @@ -3902,8 +3902,8 @@ static void genNearPointerSet (operand *right, asmop *aop = NULL; regs *preg = NULL ; char *rname , *l; - link *retype; - link *ptype = operandType(result); + sym_link *retype; + sym_link *ptype = operandType(result); retype= getSpec(operandType(right)); @@ -3991,7 +3991,7 @@ static void genPagedPointerSet (operand *right, asmop *aop = NULL; regs *preg = NULL ; char *rname , *l; - link *retype; + sym_link *retype; retype= getSpec(operandType(right)); @@ -4067,7 +4067,7 @@ static void genFarPointerSet (operand *right, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(right)); + sym_link *retype = getSpec(operandType(right)); aopOp(result,ic,FALSE); @@ -4116,7 +4116,7 @@ static void genGenPointerSet (operand *right, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(right)); + sym_link *retype = getSpec(operandType(right)); aopOp(result,ic,FALSE); @@ -4171,7 +4171,7 @@ static void genGenPointerSet (operand *right, static void genPointerSet (iCode *ic) { operand *right, *result ; - link *type, *etype; + sym_link *type, *etype; int p_type; right = IC_RIGHT(ic); @@ -4489,8 +4489,8 @@ static void genJumpTab (iCode *ic) static void genCast (iCode *ic) { operand *result = IC_RESULT(ic); - link *ctype = operandType(IC_LEFT(ic)); - link *rtype = operandType(IC_RIGHT(ic)); + sym_link *ctype = operandType(IC_LEFT(ic)); + sym_link *rtype = operandType(IC_RIGHT(ic)); operand *right = IC_RIGHT(ic); int size, offset ; @@ -4551,8 +4551,8 @@ static void genCast (iCode *ic) if (IS_PTR(ctype)) { int p_type; - link *type = operandType(right); - link *etype = getSpec(type); + sym_link *type = operandType(right); + sym_link *etype = getSpec(type); /* pointer to generic pointer */ if (IS_GENPTR(ctype)) { diff --git a/src/avr/main.c b/src/avr/main.c index 15fd03ac..808ac5ce 100644 --- a/src/avr/main.c +++ b/src/avr/main.c @@ -46,7 +46,7 @@ static void _avr_reset_regparm() regParmFlg = 0; } -static int _avr_regparm( link *l) +static int _avr_regparm( sym_link *l) { /* the first eight bytes will be passed in registers r16-r23. but we won't split variables diff --git a/src/avr/ralloc.c b/src/avr/ralloc.c index b4ce4512..3b33a9d6 100644 --- a/src/avr/ralloc.c +++ b/src/avr/ralloc.c @@ -527,7 +527,7 @@ static symbol *createStackSpil (symbol *sym) /*-----------------------------------------------------------------*/ static bool isSpiltOnStack (symbol *sym) { - link *etype; + sym_link *etype; if (!sym) return FALSE ; @@ -1668,7 +1668,7 @@ static int packRegsForSupport (iCode *ic, eBBlock *ebp) /* if this is a subtraction & the result is a true symbol in far space then don't pack */ if (ic->op == '-' && IS_TRUE_SYMOP(IC_RESULT(dic))) { - link *etype =getSpec(operandType(IC_RESULT(dic))); + sym_link *etype =getSpec(operandType(IC_RESULT(dic))); if (IN_FARSPACE(SPEC_OCLS(etype))) return change ; } @@ -1810,8 +1810,8 @@ static iCode *packRegsForOneuse (iCode *ic, operand *op , eBBlock *ebp) /*-----------------------------------------------------------------*/ static bool isBitwiseOptimizable (iCode *ic) { - link *ltype = getSpec(operandType(IC_LEFT(ic))); - link *rtype = getSpec(operandType(IC_RIGHT(ic))); + sym_link *ltype = getSpec(operandType(IC_LEFT(ic))); + sym_link *rtype = getSpec(operandType(IC_RIGHT(ic))); /* bitwise operations are considered optimizable under the following conditions (Jean-Louis VERN) @@ -1977,8 +1977,8 @@ static void packRegisters (eBBlock *ebp) the result of that arithmetic operation with this result and get rid of the cast */ if (ic->op == CAST) { - link *fromType = operandType(IC_RIGHT(ic)); - link *toType = operandType(IC_LEFT(ic)); + sym_link *fromType = operandType(IC_RIGHT(ic)); + sym_link *toType = operandType(IC_LEFT(ic)); if (IS_INTEGRAL(fromType) && IS_INTEGRAL(toType) && getSize(fromType) != getSize(toType) && diff --git a/src/ds390/gen.c b/src/ds390/gen.c index 12f23409..3dd76255 100644 --- a/src/ds390/gen.c +++ b/src/ds390/gen.c @@ -349,7 +349,7 @@ static void _endLazyDPSEvaluation(void) /*-----------------------------------------------------------------*/ /* pointerCode - returns the code for a pointer type */ /*-----------------------------------------------------------------*/ -static int pointerCode (link *etype) +static int pointerCode (sym_link *etype) { return PTR_TYPE(SPEC_OCLS(etype)); @@ -1318,7 +1318,7 @@ static void genNotFloat (operand *op, operand *res) /*-----------------------------------------------------------------*/ static int opIsGptr(operand *op) { - link *type = operandType(op); + sym_link *type = operandType(op); if ((AOP_SIZE(op) == GPTRSIZE) && IS_GENPTR(type)) { @@ -1336,7 +1336,7 @@ static int getDataSize(operand *op) size = AOP_SIZE(op); if (size == GPTRSIZE) { - link *type = operandType(op); + sym_link *type = operandType(op); if (IS_GENPTR(type)) { /* generic pointer; arithmetic operations @@ -1437,7 +1437,7 @@ static void toBoolean(operand *oper) static void genNot (iCode *ic) { symbol *tlbl; - link *optype = operandType(IC_LEFT(ic)); + sym_link *optype = operandType(IC_LEFT(ic)); D(emitcode(";", "genNot ");); @@ -1550,7 +1550,7 @@ static void genUminusFloat(operand *op,operand *result) static void genUminus (iCode *ic) { int offset ,size ; - link *optype, *rtype; + sym_link *optype, *rtype; D(emitcode(";", "genUminus ");); @@ -1623,7 +1623,7 @@ static void saveRegisters(iCode *lic) int i; iCode *ic; bitVect *rsave; - link *detype; + sym_link *detype; /* look for call */ for (ic = lic ; ic ; ic = ic->next) @@ -1980,7 +1980,7 @@ static void saverbank (int bank, iCode *ic, bool pushPsw) /*-----------------------------------------------------------------*/ static void genCall (iCode *ic) { - link *detype; + sym_link *detype; D(emitcode(";", "genCall ");); @@ -2154,7 +2154,7 @@ static void genCall (iCode *ic) /*-----------------------------------------------------------------*/ static void genPcall (iCode *ic) { - link *detype; + sym_link *detype; symbol *rlbl = newiTempLabel(NULL); D(emitcode(";", "genPcall ");); @@ -2317,7 +2317,7 @@ static bool inExcludeList(char *s) static void genFunction (iCode *ic) { symbol *sym; - link *fetype; + sym_link *fetype; D(emitcode(";", "genFunction ");); @@ -3433,7 +3433,7 @@ static void genMultOneByte (operand *left, operand *right, operand *result) { - link *opetype = operandType(result); + sym_link *opetype = operandType(result); char *l ; symbol *lbl ; int size,offset; @@ -3578,7 +3578,7 @@ static void genDivOneByte (operand *left, operand *right, operand *result) { - link *opetype = operandType(result); + sym_link *opetype = operandType(result); char *l ; symbol *lbl ; int size,offset; @@ -3720,7 +3720,7 @@ static void genModOneByte (operand *left, operand *right, operand *result) { - link *opetype = operandType(result); + sym_link *opetype = operandType(result); char *l ; symbol *lbl ; @@ -4034,7 +4034,7 @@ release: static void genCmpGt (iCode *ic, iCode *ifx) { operand *left, *right, *result; - link *letype , *retype; + sym_link *letype , *retype; int sign ; D(emitcode(";", "genCmpGt ");); @@ -4067,7 +4067,7 @@ static void genCmpGt (iCode *ic, iCode *ifx) static void genCmpLt (iCode *ic, iCode *ifx) { operand *left, *right, *result; - link *letype , *retype; + sym_link *letype , *retype; int sign ; D(emitcode(";", "genCmpLt ");); @@ -6501,7 +6501,7 @@ release: static void genRightShift (iCode *ic) { operand *right, *left, *result; - link *retype ; + sym_link *retype ; int size, offset; char *l; symbol *tlbl, *tlbl1 ; @@ -6620,7 +6620,7 @@ static void genUnpackBits (operand *result, char *rname, int ptype) { int shCnt ; int rlen = 0 ; - link *etype; + sym_link *etype; int offset = 0 ; D(emitcode(";", "genUnpackBits ");); @@ -6760,8 +6760,8 @@ static void genNearPointerGet (operand *left, asmop *aop = NULL; regs *preg = NULL ; char *rname ; - link *rtype, *retype, *letype; - link *ltype = operandType(left); + sym_link *rtype, *retype, *letype; + sym_link *ltype = operandType(left); char buffer[80]; rtype = operandType(result); @@ -6856,7 +6856,7 @@ static void genPagedPointerGet (operand *left, asmop *aop = NULL; regs *preg = NULL ; char *rname; - link *rtype, *retype, *letype; + sym_link *rtype, *retype, *letype; rtype = operandType(result); retype= getSpec(rtype); @@ -6932,8 +6932,8 @@ static void genFarPointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); - link *letype = getSpec(operandType(left)); + sym_link *retype = getSpec(operandType(result)); + sym_link *letype = getSpec(operandType(left)); D(emitcode(";", "genFarPointerGet");); aopOp(left,ic,FALSE, FALSE); @@ -7005,7 +7005,7 @@ static void emitcodePointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(result)); aopOp(left,ic,FALSE, FALSE); @@ -7075,8 +7075,8 @@ static void genGenPointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); - link *letype = getSpec(operandType(left)); + sym_link *retype = getSpec(operandType(result)); + sym_link *letype = getSpec(operandType(left)); aopOp(left,ic,FALSE, TRUE); @@ -7125,7 +7125,7 @@ static void genGenPointerGet (operand *left, static void genPointerGet (iCode *ic) { operand *left, *result ; - link *type, *etype; + sym_link *type, *etype; int p_type; D(emitcode(";", "genPointerGet ");); @@ -7176,7 +7176,7 @@ static void genPointerGet (iCode *ic) /*-----------------------------------------------------------------*/ /* genPackBits - generates code for packed bit storage */ /*-----------------------------------------------------------------*/ -static void genPackBits (link *etype , +static void genPackBits (sym_link *etype , operand *right , char *rname, int p_type) { @@ -7366,8 +7366,8 @@ static void genNearPointerSet (operand *right, asmop *aop = NULL; regs *preg = NULL ; char *rname , *l; - link *retype, *letype; - link *ptype = operandType(result); + sym_link *retype, *letype; + sym_link *ptype = operandType(result); retype= getSpec(operandType(right)); letype= getSpec(ptype); @@ -7457,7 +7457,7 @@ static void genPagedPointerSet (operand *right, asmop *aop = NULL; regs *preg = NULL ; char *rname , *l; - link *retype, *letype; + sym_link *retype, *letype; retype= getSpec(operandType(right)); letype= getSpec(operandType(result)); @@ -7534,8 +7534,8 @@ static void genFarPointerSet (operand *right, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(right)); - link *letype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(right)); + sym_link *letype = getSpec(operandType(result)); aopOp(result,ic,FALSE, FALSE); @@ -7604,8 +7604,8 @@ static void genGenPointerSet (operand *right, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(right)); - link *letype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(right)); + sym_link *letype = getSpec(operandType(result)); aopOp(result,ic,FALSE, TRUE); @@ -7661,7 +7661,7 @@ static void genGenPointerSet (operand *right, static void genPointerSet (iCode *ic) { operand *right, *result ; - link *type, *etype; + sym_link *type, *etype; int p_type; D(emitcode(";", "genPointerSet ");); @@ -8046,8 +8046,8 @@ static void genJumpTab (iCode *ic) static void genCast (iCode *ic) { operand *result = IC_RESULT(ic); - link *ctype = operandType(IC_LEFT(ic)); - link *rtype = operandType(IC_RIGHT(ic)); + sym_link *ctype = operandType(IC_LEFT(ic)); + sym_link *rtype = operandType(IC_RIGHT(ic)); operand *right = IC_RIGHT(ic); int size, offset ; @@ -8112,7 +8112,7 @@ static void genCast (iCode *ic) if (IS_PTR(ctype)) { int p_type; - link *type = operandType(right); + sym_link *type = operandType(right); /* pointer to generic pointer */ if (IS_GENPTR(ctype)) { @@ -8144,7 +8144,7 @@ static void genCast (iCode *ic) * * char _generic *gp = (char _xdata *)(intVar); */ - link *etype = getSpec(type); + sym_link *etype = getSpec(type); /* we have to go by the storage class */ if (SPEC_OCLS(etype) != generic) diff --git a/src/ds390/main.c b/src/ds390/main.c index aee3b03c..68e24823 100644 --- a/src/ds390/main.c +++ b/src/ds390/main.c @@ -56,7 +56,7 @@ static void _ds390_reset_regparm() regParmFlg = 0; } -static int _ds390_regparm( link *l) +static int _ds390_regparm( sym_link *l) { /* for this processor it is simple can pass only the first parameter in a register */ diff --git a/src/ds390/ralloc.c b/src/ds390/ralloc.c index cb306261..9fdc64c5 100644 --- a/src/ds390/ralloc.c +++ b/src/ds390/ralloc.c @@ -517,7 +517,7 @@ static symbol *createStackSpil (symbol *sym) /*-----------------------------------------------------------------*/ static bool isSpiltOnStack (symbol *sym) { - link *etype; + sym_link *etype; if (!sym) return FALSE ; @@ -1692,7 +1692,7 @@ static int packRegsForSupport (iCode *ic, eBBlock *ebp) /* if this is a subtraction & the result is a true symbol in far space then don't pack */ if (ic->op == '-' && IS_TRUE_SYMOP(IC_RESULT(dic))) { - link *etype =getSpec(operandType(IC_RESULT(dic))); + sym_link *etype =getSpec(operandType(IC_RESULT(dic))); if (IN_FARSPACE(SPEC_OCLS(etype))) return change ; } @@ -1853,8 +1853,8 @@ static iCode *packRegsForOneuse (iCode *ic, operand *op , eBBlock *ebp) /*-----------------------------------------------------------------*/ static bool isBitwiseOptimizable (iCode *ic) { - link *ltype = getSpec(operandType(IC_LEFT(ic))); - link *rtype = getSpec(operandType(IC_RIGHT(ic))); + sym_link *ltype = getSpec(operandType(IC_LEFT(ic))); + sym_link *rtype = getSpec(operandType(IC_RIGHT(ic))); /* bitwise operations are considered optimizable under the following conditions (Jean-Louis VERN) @@ -2196,8 +2196,8 @@ static void packRegisters (eBBlock *ebp) the result of that arithmetic operation with this result and get rid of the cast */ if (ic->op == CAST) { - link *fromType = operandType(IC_RIGHT(ic)); - link *toType = operandType(IC_LEFT(ic)); + sym_link *fromType = operandType(IC_RIGHT(ic)); + sym_link *toType = operandType(IC_LEFT(ic)); if (IS_INTEGRAL(fromType) && IS_INTEGRAL(toType) && getSize(fromType) != getSize(toType) && diff --git a/src/mcs51/gen.c b/src/mcs51/gen.c index 7f8edba1..04e3e392 100644 --- a/src/mcs51/gen.c +++ b/src/mcs51/gen.c @@ -251,7 +251,7 @@ static void genSetDPTR(int n) /*-----------------------------------------------------------------*/ /* pointerCode - returns the code for a pointer type */ /*-----------------------------------------------------------------*/ -static int pointerCode (link *etype) +static int pointerCode (sym_link *etype) { return PTR_TYPE(SPEC_OCLS(etype)); @@ -1153,7 +1153,7 @@ static void genNotFloat (operand *op, operand *res) /*-----------------------------------------------------------------*/ static int opIsGptr(operand *op) { - link *type = operandType(op); + sym_link *type = operandType(op); if ((AOP_SIZE(op) == GPTRSIZE) && IS_GENPTR(type)) { @@ -1171,7 +1171,7 @@ static int getDataSize(operand *op) size = AOP_SIZE(op); if (size == GPTRSIZE) { - link *type = operandType(op); + sym_link *type = operandType(op); if (IS_GENPTR(type)) { /* generic pointer; arithmetic operations @@ -1235,7 +1235,7 @@ static void toBoolean(operand *oper) static void genNot (iCode *ic) { symbol *tlbl; - link *optype = operandType(IC_LEFT(ic)); + sym_link *optype = operandType(IC_LEFT(ic)); /* assign asmOps to operand & result */ aopOp (IC_LEFT(ic),ic,FALSE); @@ -1339,7 +1339,7 @@ static void genUminusFloat(operand *op,operand *result) static void genUminus (iCode *ic) { int offset ,size ; - link *optype, *rtype; + sym_link *optype, *rtype; /* assign asmops */ @@ -1409,7 +1409,7 @@ static void saveRegisters(iCode *lic) int i; iCode *ic; bitVect *rsave; - link *detype; + sym_link *detype; /* look for call */ for (ic = lic ; ic ; ic = ic->next) @@ -1746,7 +1746,7 @@ static void saverbank (int bank, iCode *ic, bool pushPsw) /*-----------------------------------------------------------------*/ static void genCall (iCode *ic) { - link *detype; + sym_link *detype; /* if caller saves & we have not saved then */ if (!ic->regsSaved) @@ -1835,7 +1835,7 @@ static void genCall (iCode *ic) /*-----------------------------------------------------------------*/ static void genPcall (iCode *ic) { - link *detype; + sym_link *detype; symbol *rlbl = newiTempLabel(NULL); @@ -1989,7 +1989,7 @@ static bool inExcludeList(char *s) static void genFunction (iCode *ic) { symbol *sym; - link *fetype; + sym_link *fetype; _G.nRegsSaved = 0; /* create the function header */ @@ -2947,7 +2947,7 @@ static void genMultOneByte (operand *left, operand *right, operand *result) { - link *opetype = operandType(result); + sym_link *opetype = operandType(result); char *l ; symbol *lbl ; int size,offset; @@ -3091,7 +3091,7 @@ static void genDivOneByte (operand *left, operand *right, operand *result) { - link *opetype = operandType(result); + sym_link *opetype = operandType(result); char *l ; symbol *lbl ; int size,offset; @@ -3233,7 +3233,7 @@ static void genModOneByte (operand *left, operand *right, operand *result) { - link *opetype = operandType(result); + sym_link *opetype = operandType(result); char *l ; symbol *lbl ; @@ -3461,7 +3461,7 @@ release: static void genCmpGt (iCode *ic, iCode *ifx) { operand *left, *right, *result; - link *letype , *retype; + sym_link *letype , *retype; int sign ; left = IC_LEFT(ic); @@ -3489,7 +3489,7 @@ static void genCmpGt (iCode *ic, iCode *ifx) static void genCmpLt (iCode *ic, iCode *ifx) { operand *left, *right, *result; - link *letype , *retype; + sym_link *letype , *retype; int sign ; left = IC_LEFT(ic); @@ -5747,7 +5747,7 @@ release: static void genRightShift (iCode *ic) { operand *right, *left, *result; - link *retype ; + sym_link *retype ; int size, offset; char *l; symbol *tlbl, *tlbl1 ; @@ -5858,7 +5858,7 @@ static void genUnpackBits (operand *result, char *rname, int ptype) { int shCnt ; int rlen = 0 ; - link *etype; + sym_link *etype; int offset = 0 ; int rsize ; @@ -6002,8 +6002,8 @@ static void genNearPointerGet (operand *left, asmop *aop = NULL; regs *preg = NULL ; char *rname ; - link *rtype, *retype; - link *ltype = operandType(left); + sym_link *rtype, *retype; + sym_link *ltype = operandType(left); char buffer[80]; rtype = operandType(result); @@ -6096,7 +6096,7 @@ static void genPagedPointerGet (operand *left, asmop *aop = NULL; regs *preg = NULL ; char *rname ; - link *rtype, *retype; + sym_link *rtype, *retype; rtype = operandType(result); retype= getSpec(rtype); @@ -6172,7 +6172,7 @@ static void genFarPointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(result)); aopOp(left,ic,FALSE); @@ -6220,7 +6220,7 @@ static void emitcodePointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(result)); aopOp(left,ic,FALSE); @@ -6269,7 +6269,7 @@ static void genGenPointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(result)); aopOp(left,ic,FALSE); @@ -6323,7 +6323,7 @@ static void genGenPointerGet (operand *left, static void genPointerGet (iCode *ic) { operand *left, *result ; - link *type, *etype; + sym_link *type, *etype; int p_type; left = IC_LEFT(ic); @@ -6387,7 +6387,7 @@ static void genPointerGet (iCode *ic) /*-----------------------------------------------------------------*/ /* genPackBits - generates code for packed bit storage */ /*-----------------------------------------------------------------*/ -static void genPackBits (link *etype , +static void genPackBits (sym_link *etype , operand *right , char *rname, int p_type) { @@ -6577,8 +6577,8 @@ static void genNearPointerSet (operand *right, asmop *aop = NULL; regs *preg = NULL ; char *rname , *l; - link *retype, *letype; - link *ptype = operandType(result); + sym_link *retype, *letype; + sym_link *ptype = operandType(result); retype= getSpec(operandType(right)); letype= getSpec(ptype); @@ -6667,7 +6667,7 @@ static void genPagedPointerSet (operand *right, asmop *aop = NULL; regs *preg = NULL ; char *rname , *l; - link *retype, *letype; + sym_link *retype, *letype; retype= getSpec(operandType(right)); letype= getSpec(operandType(result)); @@ -6744,8 +6744,8 @@ static void genFarPointerSet (operand *right, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(right)); - link *letype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(right)); + sym_link *letype = getSpec(operandType(result)); aopOp(result,ic,FALSE); /* if the operand is already in dptr @@ -6793,8 +6793,8 @@ static void genGenPointerSet (operand *right, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(right)); - link *letype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(right)); + sym_link *letype = getSpec(operandType(result)); aopOp(result,ic,FALSE); @@ -6849,7 +6849,7 @@ static void genGenPointerSet (operand *right, static void genPointerSet (iCode *ic) { operand *right, *result ; - link *type, *etype; + sym_link *type, *etype; int p_type; right = IC_RIGHT(ic); @@ -7153,8 +7153,8 @@ static void genJumpTab (iCode *ic) static void genCast (iCode *ic) { operand *result = IC_RESULT(ic); - link *ctype = operandType(IC_LEFT(ic)); - link *rtype = operandType(IC_RIGHT(ic)); + sym_link *ctype = operandType(IC_LEFT(ic)); + sym_link *rtype = operandType(IC_RIGHT(ic)); operand *right = IC_RIGHT(ic); int size, offset ; @@ -7215,8 +7215,8 @@ static void genCast (iCode *ic) if (IS_PTR(ctype)) { int p_type; - link *type = operandType(right); - link *etype = getSpec(type); + sym_link *type = operandType(right); + sym_link *etype = getSpec(type); /* pointer to generic pointer */ if (IS_GENPTR(ctype)) { diff --git a/src/mcs51/main.c b/src/mcs51/main.c index 393ed90a..eb4843ba 100644 --- a/src/mcs51/main.c +++ b/src/mcs51/main.c @@ -56,7 +56,7 @@ static void _mcs51_reset_regparm() regParmFlg = 0; } -static int _mcs51_regparm( link *l) +static int _mcs51_regparm( sym_link *l) { /* for this processor it is simple can pass only the first parameter in a register */ diff --git a/src/mcs51/ralloc.c b/src/mcs51/ralloc.c index 09fd032d..58ae61cc 100644 --- a/src/mcs51/ralloc.c +++ b/src/mcs51/ralloc.c @@ -517,7 +517,7 @@ static symbol *createStackSpil (symbol *sym) /*-----------------------------------------------------------------*/ static bool isSpiltOnStack (symbol *sym) { - link *etype; + sym_link *etype; if (!sym) return FALSE ; @@ -1462,7 +1462,7 @@ static iCode *farSpacePackable (iCode *ic) static int packRegsForAssign (iCode *ic,eBBlock *ebp) { iCode *dic, *sic; - link *etype = operandType(IC_RIGHT(ic)); + sym_link *etype = operandType(IC_RIGHT(ic)); if (!IS_ITEMP(IC_RIGHT(ic)) || OP_SYMBOL(IC_RIGHT(ic))->isind || @@ -1537,7 +1537,7 @@ static int packRegsForAssign (iCode *ic,eBBlock *ebp) /* if assignment then check that right is not a bit */ if (ASSIGNMENT(dic) && !POINTER_SET(dic)) { - link *etype = operandType(IC_RIGHT(dic)); + sym_link *etype = operandType(IC_RIGHT(dic)); if (IS_BITFIELD(etype)) return 0; } /* if the result is on stack or iaccess then it must be @@ -1698,7 +1698,7 @@ static int packRegsForSupport (iCode *ic, eBBlock *ebp) /* if this is a subtraction & the result is a true symbol in far space then don't pack */ if (ic->op == '-' && IS_TRUE_SYMOP(IC_RESULT(dic))) { - link *etype =getSpec(operandType(IC_RESULT(dic))); + sym_link *etype =getSpec(operandType(IC_RESULT(dic))); if (IN_FARSPACE(SPEC_OCLS(etype))) return change ; } @@ -1851,8 +1851,8 @@ static iCode *packRegsForOneuse (iCode *ic, operand *op , eBBlock *ebp) /*-----------------------------------------------------------------*/ static bool isBitwiseOptimizable (iCode *ic) { - link *ltype = getSpec(operandType(IC_LEFT(ic))); - link *rtype = getSpec(operandType(IC_RIGHT(ic))); + sym_link *ltype = getSpec(operandType(IC_LEFT(ic))); + sym_link *rtype = getSpec(operandType(IC_RIGHT(ic))); /* bitwise operations are considered optimizable under the following conditions (Jean-Louis VERN) @@ -2194,8 +2194,8 @@ static void packRegisters (eBBlock *ebp) the result of that arithmetic operation with this result and get rid of the cast */ if (ic->op == CAST) { - link *fromType = operandType(IC_RIGHT(ic)); - link *toType = operandType(IC_LEFT(ic)); + sym_link *fromType = operandType(IC_RIGHT(ic)); + sym_link *toType = operandType(IC_LEFT(ic)); if (IS_INTEGRAL(fromType) && IS_INTEGRAL(toType) && getSize(fromType) != getSize(toType) && diff --git a/src/pic/gen.c b/src/pic/gen.c index 94199061..57659bd4 100644 --- a/src/pic/gen.c +++ b/src/pic/gen.c @@ -315,7 +315,7 @@ static void genSetDPTR(int n) /*-----------------------------------------------------------------*/ /* pointerCode - returns the code for a pointer type */ /*-----------------------------------------------------------------*/ -static int pointerCode (link *etype) +static int pointerCode (sym_link *etype) { return PTR_TYPE(SPEC_OCLS(etype)); @@ -1205,7 +1205,7 @@ static void genNotFloat (operand *op, operand *res) /*-----------------------------------------------------------------*/ static int opIsGptr(operand *op) { - link *type = operandType(op); + sym_link *type = operandType(op); DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); if ((AOP_SIZE(op) == GPTRSIZE) && IS_GENPTR(type)) @@ -1225,7 +1225,7 @@ static int getDataSize(operand *op) size = AOP_SIZE(op); if (size == GPTRSIZE) { - link *type = operandType(op); + sym_link *type = operandType(op); if (IS_GENPTR(type)) { /* generic pointer; arithmetic operations @@ -1297,7 +1297,7 @@ static void toBoolean(operand *oper) static void genNot (iCode *ic) { symbol *tlbl; - link *optype = operandType(IC_LEFT(ic)); + sym_link *optype = operandType(IC_LEFT(ic)); DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); /* assign asmOps to operand & result */ @@ -1406,7 +1406,7 @@ static void genUminusFloat(operand *op,operand *result) static void genUminus (iCode *ic) { int offset ,size ; - link *optype, *rtype; + sym_link *optype, *rtype; DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -1473,7 +1473,7 @@ static void saveRegisters(iCode *lic) int i; iCode *ic; bitVect *rsave; - link *detype; + sym_link *detype; DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); /* look for call */ @@ -1822,7 +1822,7 @@ static void saverbank (int bank, iCode *ic, bool pushPsw) /*-----------------------------------------------------------------*/ static void genCall (iCode *ic) { - link *detype; + sym_link *detype; DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -1913,7 +1913,7 @@ static void genCall (iCode *ic) /*-----------------------------------------------------------------*/ static void genPcall (iCode *ic) { - link *detype; + sym_link *detype; symbol *rlbl = newiTempLabel(NULL); @@ -2070,7 +2070,7 @@ static bool inExcludeList(char *s) static void genFunction (iCode *ic) { symbol *sym; - link *fetype; + sym_link *fetype; DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); labelOffset += FUNCTION_LABEL_INC; @@ -3058,7 +3058,7 @@ static void genMultOneByte (operand *left, operand *right, operand *result) { - link *opetype = operandType(result); + sym_link *opetype = operandType(result); char *l ; symbol *lbl ; int size,offset; @@ -3205,7 +3205,7 @@ static void genDivOneByte (operand *left, operand *right, operand *result) { - link *opetype = operandType(result); + sym_link *opetype = operandType(result); char *l ; symbol *lbl ; int size,offset; @@ -3349,7 +3349,7 @@ static void genModOneByte (operand *left, operand *right, operand *result) { - link *opetype = operandType(result); + sym_link *opetype = operandType(result); char *l ; symbol *lbl ; @@ -3716,7 +3716,7 @@ static void genCmp (operand *left,operand *right, static void genCmpGt (iCode *ic, iCode *ifx) { operand *left, *right, *result; - link *letype , *retype; + sym_link *letype , *retype; int sign ; DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -3745,7 +3745,7 @@ static void genCmpGt (iCode *ic, iCode *ifx) static void genCmpLt (iCode *ic, iCode *ifx) { operand *left, *right, *result; - link *letype , *retype; + sym_link *letype , *retype; int sign ; DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -6280,7 +6280,7 @@ release: static void genRightShift (iCode *ic) { operand *right, *left, *result; - link *retype ; + sym_link *retype ; int size, offset; char *l; symbol *tlbl, *tlbl1 ; @@ -6392,7 +6392,7 @@ static void genUnpackBits (operand *result, char *rname, int ptype) { int shCnt ; int rlen = 0 ; - link *etype; + sym_link *etype; int offset = 0 ; DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -6530,8 +6530,8 @@ static void genNearPointerGet (operand *left, asmop *aop = NULL; regs *preg = NULL ; char *rname ; - link *rtype, *retype; - link *ltype = operandType(left); + sym_link *rtype, *retype; + sym_link *ltype = operandType(left); char buffer[80]; DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -6626,7 +6626,7 @@ static void genPagedPointerGet (operand *left, asmop *aop = NULL; regs *preg = NULL ; char *rname ; - link *rtype, *retype; + sym_link *rtype, *retype; DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -6704,7 +6704,7 @@ static void genFarPointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(result)); DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -6754,7 +6754,7 @@ static void emitcodePointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(result)); DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -6805,7 +6805,7 @@ static void genGenPointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(result)); DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); aopOp(left,ic,FALSE); @@ -6860,7 +6860,7 @@ static void genGenPointerGet (operand *left, static void genPointerGet (iCode *ic) { operand *left, *result ; - link *type, *etype; + sym_link *type, *etype; int p_type; DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -6926,7 +6926,7 @@ static void genPointerGet (iCode *ic) /*-----------------------------------------------------------------*/ /* genPackBits - generates code for packed bit storage */ /*-----------------------------------------------------------------*/ -static void genPackBits (link *etype , +static void genPackBits (sym_link *etype , operand *right , char *rname, int p_type) { @@ -7118,8 +7118,8 @@ static void genNearPointerSet (operand *right, asmop *aop = NULL; regs *preg = NULL ; char *rname , *l; - link *retype; - link *ptype = operandType(result); + sym_link *retype; + sym_link *ptype = operandType(result); DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); retype= getSpec(operandType(right)); @@ -7208,7 +7208,7 @@ static void genPagedPointerSet (operand *right, asmop *aop = NULL; regs *preg = NULL ; char *rname , *l; - link *retype; + sym_link *retype; DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -7286,7 +7286,7 @@ static void genFarPointerSet (operand *right, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(right)); + sym_link *retype = getSpec(operandType(right)); DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); aopOp(result,ic,FALSE); @@ -7336,7 +7336,7 @@ static void genGenPointerSet (operand *right, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(right)); + sym_link *retype = getSpec(operandType(right)); DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -7393,7 +7393,7 @@ static void genGenPointerSet (operand *right, static void genPointerSet (iCode *ic) { operand *right, *result ; - link *type, *etype; + sym_link *type, *etype; int p_type; DEBUGemitcode ("; ***","%s %d",__FUNCTION__,__LINE__); @@ -7732,7 +7732,7 @@ static int genMixedOperation (iCode *ic) { #if 0 operand *result = IC_RESULT(ic); - link *ctype = operandType(IC_LEFT(ic)); + sym_link *ctype = operandType(IC_LEFT(ic)); operand *right = IC_RIGHT(ic); int ret = 0; int big,small; @@ -7854,7 +7854,7 @@ release: static void genCast (iCode *ic) { operand *result = IC_RESULT(ic); - link *ctype = operandType(IC_LEFT(ic)); + sym_link *ctype = operandType(IC_LEFT(ic)); operand *right = IC_RIGHT(ic); int size, offset ; @@ -7924,8 +7924,8 @@ static void genCast (iCode *ic) if (IS_PTR(ctype)) { int p_type; - link *type = operandType(right); - link *etype = getSpec(type); + sym_link *type = operandType(right); + sym_link *etype = getSpec(type); /* pointer to generic pointer */ if (IS_GENPTR(ctype)) { diff --git a/src/pic/glue.c b/src/pic/glue.c index 59d53c9e..c3227de1 100644 --- a/src/pic/glue.c +++ b/src/pic/glue.c @@ -27,7 +27,7 @@ extern symbol *interrupts[256]; -void printIval (symbol *, link *, initList *, FILE *); +void printIval (symbol *, sym_link *, initList *, FILE *); extern int noAlloc; extern set *publics; extern int maxInterrupts; @@ -58,15 +58,15 @@ extern void printChar (FILE * ofile, char *s, int plen); char *aopLiteral (value *val, int offset) static void emitRegularMap (memmap * map, bool addPublics, bool arFlag) value *initPointer (initList *ilist) -void printIvalType (link * type, initList * ilist, FILE * oFile) -void printIvalStruct (symbol * sym,link * type, +void printIvalType (sym_link * type, initList * ilist, FILE * oFile) +void printIvalStruct (symbol * sym,sym_link * type, initList * ilist, FILE * oFile) -int printIvalChar (link * type, initList * ilist, FILE * oFile, char *s) -void printIvalArray (symbol * sym, link * type, initList * ilist, +int printIvalChar (sym_link * type, initList * ilist, FILE * oFile, char *s) +void printIvalArray (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) -void printIvalFuncPtr (link * type, initList * ilist, FILE * oFile) -int printIvalCharPtr (symbol * sym, link * type, value * val, FILE * oFile) -void printIvalPtr (symbol * sym, link * type, initList * ilist, FILE * oFile) +void printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) +int printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) +void printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) #endif @@ -311,7 +311,7 @@ void printChar (FILE * ofile, char *s, int plen) /*-----------------------------------------------------------------*/ /* printIvalType - generates ival for int/char */ /*-----------------------------------------------------------------*/ -void printIvalType (link * type, initList * ilist, FILE * oFile) +void printIvalType (sym_link * type, initList * ilist, FILE * oFile) { value *val; @@ -353,7 +353,7 @@ void printIvalType (link * type, initList * ilist, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIvalStruct - generates initial value for structures */ /*-----------------------------------------------------------------*/ -void printIvalStruct (symbol * sym,link * type, +void printIvalStruct (symbol * sym,sym_link * type, initList * ilist, FILE * oFile) { symbol *sflds; @@ -376,7 +376,7 @@ void printIvalStruct (symbol * sym,link * type, /*-----------------------------------------------------------------*/ /* printIvalChar - generates initital value for character array */ /*-----------------------------------------------------------------*/ -int printIvalChar (link * type, initList * ilist, FILE * oFile, char *s) +int printIvalChar (sym_link * type, initList * ilist, FILE * oFile, char *s) { value *val; int remain; @@ -412,7 +412,7 @@ int printIvalChar (link * type, initList * ilist, FILE * oFile, char *s) /*-----------------------------------------------------------------*/ /* printIvalArray - generates code for array initialization */ /*-----------------------------------------------------------------*/ -void printIvalArray (symbol * sym, link * type, initList * ilist, +void printIvalArray (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) { initList *iloop; @@ -463,7 +463,7 @@ void printIvalArray (symbol * sym, link * type, initList * ilist, /*-----------------------------------------------------------------*/ /* printIvalFuncPtr - generate initial value for function pointers */ /*-----------------------------------------------------------------*/ -void printIvalFuncPtr (link * type, initList * ilist, FILE * oFile) +void printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) { value *val; int dLvl = 0; @@ -495,7 +495,7 @@ void printIvalFuncPtr (link * type, initList * ilist, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIvalCharPtr - generates initial values for character pointers */ /*-----------------------------------------------------------------*/ -int printIvalCharPtr (symbol * sym, link * type, value * val, FILE * oFile) +int printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) { int size = 0; @@ -523,7 +523,7 @@ int printIvalCharPtr (symbol * sym, link * type, value * val, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIvalPtr - generates initial value for pointers */ /*-----------------------------------------------------------------*/ -void printIvalPtr (symbol * sym, link * type, initList * ilist, FILE * oFile) +void printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) { value *val; @@ -586,7 +586,7 @@ void printIvalPtr (symbol * sym, link * type, initList * ilist, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIval - generates code for initial value */ /*-----------------------------------------------------------------*/ -void printIval (symbol * sym, link * type, initList * ilist, FILE * oFile) +void printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) { if (!ilist) return; diff --git a/src/pic/main.c b/src/pic/main.c index 7fde90c9..eb997bbf 100644 --- a/src/pic/main.c +++ b/src/pic/main.c @@ -56,7 +56,7 @@ static void _pic14_reset_regparm() regParmFlg = 0; } -static int _pic14_regparm( link *l) +static int _pic14_regparm( sym_link *l) { /* for this processor it is simple can pass only the first parameter in a register */ diff --git a/src/pic/ralloc.c b/src/pic/ralloc.c index 11eab9dc..13df6fa2 100644 --- a/src/pic/ralloc.c +++ b/src/pic/ralloc.c @@ -528,7 +528,7 @@ static symbol *createStackSpil (symbol *sym) /*-----------------------------------------------------------------*/ static bool isSpiltOnStack (symbol *sym) { - link *etype; + sym_link *etype; if (!sym) return FALSE ; @@ -1701,7 +1701,7 @@ static int packRegsForSupport (iCode *ic, eBBlock *ebp) /* if this is a subtraction & the result is a true symbol in far space then don't pack */ if (ic->op == '-' && IS_TRUE_SYMOP(IC_RESULT(dic))) { - link *etype =getSpec(operandType(IC_RESULT(dic))); + sym_link *etype =getSpec(operandType(IC_RESULT(dic))); if (IN_FARSPACE(SPEC_OCLS(etype))) return change ; } @@ -1852,8 +1852,8 @@ static iCode *packRegsForOneuse (iCode *ic, operand *op , eBBlock *ebp) /*-----------------------------------------------------------------*/ static bool isBitwiseOptimizable (iCode *ic) { - link *ltype = getSpec(operandType(IC_LEFT(ic))); - link *rtype = getSpec(operandType(IC_RIGHT(ic))); + sym_link *ltype = getSpec(operandType(IC_LEFT(ic))); + sym_link *rtype = getSpec(operandType(IC_RIGHT(ic))); /* bitwise operations are considered optimizable under the following conditions (Jean-Louis VERN) @@ -2196,8 +2196,8 @@ static void packRegisters (eBBlock *ebp) the result of that arithmetic operation with this result and get rid of the cast */ if (ic->op == CAST) { - link *fromType = operandType(IC_RIGHT(ic)); - link *toType = operandType(IC_LEFT(ic)); + sym_link *fromType = operandType(IC_RIGHT(ic)); + sym_link *toType = operandType(IC_LEFT(ic)); if (IS_INTEGRAL(fromType) && IS_INTEGRAL(toType) && getSize(fromType) != getSize(toType) ) { diff --git a/src/port.h b/src/port.h index b41e0f82..2e4efd54 100644 --- a/src/port.h +++ b/src/port.h @@ -151,7 +151,7 @@ typedef struct { /* parameter passing in register related functions */ void (*reset_regparms)(); /* reset the register count */ - int (*reg_parm)(struct link *); /* will return 1 if can be passed in register */ + int (*reg_parm)(struct sym_link *); /* will return 1 if can be passed in register */ /** Process the pragma string 'sz'. Returns 0 if recognised and processed, 1 otherwise. May be NULL. diff --git a/src/z80/gen.c b/src/z80/gen.c index 2bdd7f38..6ff3ebe8 100644 --- a/src/z80/gen.c +++ b/src/z80/gen.c @@ -1348,7 +1348,7 @@ void toBoolean(operand *oper) /*-----------------------------------------------------------------*/ static void genNot (iCode *ic) { - link *optype = operandType(IC_LEFT(ic)); + sym_link *optype = operandType(IC_LEFT(ic)); /* assign asmOps to operand & result */ aopOp (IC_LEFT(ic),ic,FALSE, TRUE); @@ -1417,7 +1417,7 @@ static void genCpl (iCode *ic) static void genUminus (iCode *ic) { int offset ,size ; - link *optype, *rtype; + sym_link *optype, *rtype; /* assign asmops */ aopOp(IC_LEFT(ic),ic,FALSE, FALSE); @@ -1712,7 +1712,7 @@ static bool isInHome(void) static void emitCall(iCode *ic, bool ispcall) { int pushed_de = 0; - link *detype = getSpec(operandType(IC_LEFT(ic))); + sym_link *detype = getSpec(operandType(IC_LEFT(ic))); /* if caller saves & we have not saved then */ if (!ic->regsSaved) { @@ -1872,7 +1872,7 @@ static void emitCall(iCode *ic, bool ispcall) /*-----------------------------------------------------------------*/ static void genCall (iCode *ic) { - link *detype = getSpec(operandType(IC_LEFT(ic))); + sym_link *detype = getSpec(operandType(IC_LEFT(ic))); emitCall(ic, FALSE); } @@ -1909,7 +1909,7 @@ extern set *publics; static void genFunction (iCode *ic) { symbol *sym = OP_SYMBOL(IC_LEFT(ic)); - link *fetype; + sym_link *fetype; nregssaved = 0; setArea(IS_NONBANKED(sym->etype)); @@ -2793,7 +2793,7 @@ release: static void genCmpGt (iCode *ic, iCode *ifx) { operand *left, *right, *result; - link *letype , *retype; + sym_link *letype , *retype; int sign ; left = IC_LEFT(ic); @@ -2821,7 +2821,7 @@ static void genCmpGt (iCode *ic, iCode *ifx) static void genCmpLt (iCode *ic, iCode *ifx) { operand *left, *right, *result; - link *letype , *retype; + sym_link *letype , *retype; int sign ; left = IC_LEFT(ic); @@ -4091,7 +4091,7 @@ static void genRightShiftLiteral (operand *left, static void genRightShift (iCode *ic) { operand *right, *left, *result; - link *retype ; + sym_link *retype ; int size, offset, first = 1; char *l; bool is_signed; @@ -4179,7 +4179,7 @@ static void genGenPointerGet (operand *left, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(result)); + sym_link *retype = getSpec(operandType(result)); int pair = PAIR_HL; if (IS_GB) @@ -4244,7 +4244,7 @@ static void genGenPointerGet (operand *left, static void genPointerGet (iCode *ic) { operand *left, *result ; - link *type, *etype; + sym_link *type, *etype; left = IC_LEFT(ic); result = IC_RESULT(ic) ; @@ -4271,7 +4271,7 @@ static void genGenPointerSet (operand *right, operand *result, iCode *ic) { int size, offset ; - link *retype = getSpec(operandType(right)); + sym_link *retype = getSpec(operandType(right)); PAIR_ID pairId = PAIR_HL; aopOp(result,ic,FALSE, FALSE); @@ -4337,7 +4337,7 @@ static void genGenPointerSet (operand *right, static void genPointerSet (iCode *ic) { operand *right, *result ; - link *type, *etype; + sym_link *type, *etype; right = IC_RIGHT(ic); result = IC_RESULT(ic) ; @@ -4571,7 +4571,7 @@ static void genJumpTab (iCode *ic) static void genCast (iCode *ic) { operand *result = IC_RESULT(ic); - link *ctype = operandType(IC_LEFT(ic)); + sym_link *ctype = operandType(IC_LEFT(ic)); operand *right = IC_RIGHT(ic); int size, offset ; diff --git a/src/z80/main.c b/src/z80/main.c index 7cc38f25..aef74af8 100644 --- a/src/z80/main.c +++ b/src/z80/main.c @@ -55,7 +55,7 @@ static void _reset_regparm() regParmFlg = 0; } -static int _reg_parm(link *l) +static int _reg_parm(sym_link *l) { if (regParmFlg == 2) return 0; diff --git a/src/z80/ralloc.c b/src/z80/ralloc.c index fc224eb4..540b3a16 100644 --- a/src/z80/ralloc.c +++ b/src/z80/ralloc.c @@ -461,7 +461,7 @@ symbol *createStackSpil (symbol *sym) /*-----------------------------------------------------------------*/ bool isSpiltOnStack (symbol *sym) { - link *etype; + sym_link *etype; if (!sym) return FALSE ; @@ -1653,7 +1653,7 @@ static iCode *packRegsForOneuse (iCode *ic, operand *op , eBBlock *ebp) /*-----------------------------------------------------------------*/ static bool isBitwiseOptimizable (iCode *ic) { - link *rtype = getSpec(operandType(IC_RIGHT(ic))); + sym_link *rtype = getSpec(operandType(IC_RIGHT(ic))); /* bitwise operations are considered optimizable under the following conditions (Jean-Louis VERN) -- 2.47.2