/*-------------------------------------------------------------------------
  SDCCsymt.h - Header file for Symbols table related structures and MACRO's.

  Copyright (C) 1998 Sandeep Dutta . sandeep.dutta@usa.net

  This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2, or (at your option) any
  later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-------------------------------------------------------------------------*/

#ifndef  SDCCSYMT_H
#define  SDCCSYMT_H

#define MAX_NEST_LEVEL  256
#define SDCC_SYMNAME_MAX 256
#define SDCC_NAME_MAX  3*SDCC_SYMNAME_MAX       // big enough for _<func>_<var>_etc
#include "SDCChasht.h"
#include "SDCCglobl.h"
#include "SDCCattr.h"
#include "dbuf.h"

#define INTNO_MAX 255           /* maximum allowed interrupt number */
#define INTNO_TRAP INTNO_MAX
#define INTNO_UNSPEC (INTNO_MAX+1)      /* interrupt number unspecified */


#define BITVAR_PAD -1

enum
{
  TYPEOF_INT = 1,
  TYPEOF_SHORT,
  TYPEOF_BOOL,
  TYPEOF_CHAR,
  TYPEOF_LONG,
  TYPEOF_LONGLONG,
  TYPEOF_FLOAT,
  TYPEOF_FIXED16X16,
  TYPEOF_BIT,
  TYPEOF_BITFIELD,
  TYPEOF_SBIT,
  TYPEOF_SFR,
  TYPEOF_VOID,
  TYPEOF_STRUCT,
  TYPEOF_ARRAY,
  TYPEOF_FUNCTION,
  TYPEOF_POINTER,
  TYPEOF_FPOINTER,
  TYPEOF_CPOINTER,
  TYPEOF_GPOINTER,
  TYPEOF_PPOINTER,
  TYPEOF_IPOINTER,
  TYPEOF_EEPPOINTER
};

// values for first byte (or 3 most significant bits) of generic pointer.
#if 0
#define GPTYPE_FAR       0x00
#define GPTYPE_NEAR      0x40
#define GPTYPE_XSTACK    0x60
#define GPTYPE_CODE      0x80
#else
#define GPTYPE_FAR      (port->gp_tags.tag_far)
#define GPTYPE_NEAR     (port->gp_tags.tag_near)
#define GPTYPE_XSTACK   (port->gp_tags.tag_xstack)
#define GPTYPE_CODE     (port->gp_tags.tag_code)
#endif

#define HASHTAB_SIZE 256

/* hash table bucket */
typedef struct bucket
{
  void *sym;                    /* pointer to the object      */
  char name[SDCC_NAME_MAX + 1]; /* name of this symbol        */
  long level;                   /* nest level for this symbol */
  int block;                    /* belongs to which block     */
  struct bucket *prev;          /* ptr 2 previous bucket      */
  struct bucket *next;          /* ptr 2 next bucket          */
}
bucket;

typedef struct structdef
{
  char tag[SDCC_NAME_MAX + 1];  /* tag part of structure      */
  long level;                   /* Nesting level              */
  int block;                    /* belongs to which block     */
  struct symbol *fields;        /* pointer to fields          */
  unsigned size;                /* sizeof the table in bytes  */
  int type;                     /* STRUCT or UNION            */
  bool b_flexArrayMember;       /* has got a flexible array member,
                                   only needed for syntax checks */
  struct symbol *tagsym;        /* tag symbol (NULL if no tag) */
}
structdef;

/* noun definitions */
typedef enum
{
  V_INT = 1,
  V_FLOAT,
  V_FIXED16X16,
  V_BOOL,
  V_CHAR,
  V_VOID,
  V_STRUCT,
  V_LABEL,
  V_BIT,
  V_BITFIELD,
  V_BBITFIELD,
  V_SBIT,
  V_DOUBLE
}
NOUN;

/* storage class    */
typedef enum
{
  S_FIXED = 0,
  S_AUTO,
  S_REGISTER,
  S_SFR,
  S_SBIT,
  S_CODE,
  S_XDATA,
  S_DATA,
  S_IDATA,
  S_PDATA,
  S_LITERAL,
  S_STACK,
  S_XSTACK,
  S_BIT,
  S_EEPROM
}
STORAGE_CLASS;

#define TYPE_TARGET_CHAR  TYPE_BYTE
#define TYPE_TARGET_INT   TYPE_WORD
#define TYPE_TARGET_LONG  TYPE_DWORD
#define TYPE_TARGET_UCHAR TYPE_UBYTE
#define TYPE_TARGET_UINT  TYPE_UWORD
#define TYPE_TARGET_ULONG TYPE_UDWORD
#define TYPE_TARGET_LONGLONG TYPE_QWORD
#define TYPE_TARGET_ULONGLONG TYPE_UQWORD

/* specifier is the last in the type-chain */
typedef struct specifier
{
  NOUN noun;                        /* CHAR INT STRUCTURE LABEL   */
  STORAGE_CLASS sclass;             /* REGISTER,AUTO,FIX,CONSTANT */
  struct memmap *oclass;            /* output storage class       */
  unsigned b_long:1;                /* 1=long                     */
  unsigned b_longlong:1;            /* 1=long long                */
  unsigned b_short:1;               /* 1=short int                */
  unsigned b_unsigned:1;            /* 1=unsigned, 0=signed       */
  unsigned b_signed:1;              /* just for sanity checks only*/
  bool     b_implicit_sign:1;       /* signedness not explicitly specified - needed to keep char a separate type from signed char and unsigned char. */
  unsigned b_static:1;              /* 1=static keyword found     */
  unsigned b_extern:1;              /* 1=extern found             */
  unsigned b_inline:1;              /* inline function requested  */
  unsigned b_noreturn:1;            /* promised not to return     */
  unsigned b_alignas:1;             /* alignment                  */
  unsigned b_absadr:1;              /* absolute address specfied  */
  unsigned b_volatile:1;            /* is marked as volatile      */
  unsigned b_const:1;               /* is a constant              */
  unsigned b_restrict:1;            /* is restricted              */
  struct symbol *addrspace;         /* is in named address space  */
  unsigned b_typedef:1;             /* is typedefed               */
  unsigned b_isregparm:1;           /* is the first parameter     */
  unsigned b_isenum:1;              /* is an enumerated type      */
  unsigned b_bitUnnamed:1;          /* is an unnamed bit-field    */
  unsigned b_needspar:1;            /* has to be a parameter      */
  unsigned _bitStart;               /* bit start position         */
  unsigned _bitLength;              /* bit length                 */
  unsigned _addr;                   /* address of symbol          */
  unsigned _stack;                  /* stack offset for stacked v */
  int argreg;                       /* reg no for regparm         */
  union
  {                                   /* Values if constant or enum */
    TYPE_TARGET_INT v_int;            /* 2 bytes: int and char values            */
    const char *v_char;               /*          char character string          */
    const TYPE_TARGET_UINT *v_char16; /*          char16_t character string      */
    const TYPE_TARGET_ULONG *v_char32;/*          char32_t character string      */
    TYPE_TARGET_UINT v_uint;          /* 2 bytes: unsigned int const value       */
    TYPE_TARGET_LONG v_long;          /* 4 bytes: long constant value            */
    TYPE_TARGET_ULONG v_ulong;        /* 4 bytes: unsigned long constant value   */
    TYPE_TARGET_LONGLONG v_longlong;  /* 8 bytes: long long constant value       */
    TYPE_TARGET_ULONGLONG v_ulonglong;/* 8 bytes: unsigned long long const value */
    double v_float;                   /*          floating point constant value  */
    TYPE_TARGET_ULONG v_fixed16x16;   /* 4 bytes: fixed point constant value     */
    struct symbol *v_enum;            /* ptr to enum_list if enum==1             */
  }
  const_val;
  struct structdef *v_struct;       /* structure pointer      */
}
specifier;

/* types of declarators */
typedef enum
{
  UPOINTER = 0,                     /* unknown pointer used only when parsing */
  POINTER,                          /* pointer to near data  */
  IPOINTER,                         /* pointer to upper 128 bytes */
  PPOINTER,                         /* paged area pointer    */
  FPOINTER,                         /* pointer to far data   */
  CPOINTER,                         /* pointer to code space */
  GPOINTER,                         /* generic pointer       */
  EEPPOINTER,                       /* pointer to eeprom     */
  ARRAY,
  FUNCTION
}
DECLARATOR_TYPE;

typedef struct declarator
{
  DECLARATOR_TYPE dcl_type;         /* POINTER,ARRAY or FUNCTION  */
  size_t num_elem;                  /* # of elems if type==array, */
  /* always 0 for flexible arrays */
  unsigned ptr_const:1;             /* pointer is constant        */
  unsigned ptr_volatile:1;          /* pointer is volatile        */
  unsigned ptr_restrict:1;          /* pointer is resticted       */
  struct symbol *ptr_addrspace;     /* pointer is in named address space  */

  struct sym_link *tspec;           /* pointer type specifier     */
}
declarator;

typedef enum
{
  DECLARATOR = 1,
  SPECIFIER
} SYM_LINK_CLASS;
#define DECLSPEC2TXT(select) (select==DECLARATOR?"DECLARATOR":select==SPECIFIER?"SPECIFIER":"UNKNOWN")

typedef struct sym_link
{
  SYM_LINK_CLASS xclass;            /* DECLARATOR or SPECIFIER     */
  unsigned tdef:1;                  /* current link created by     */
                                    /* typedef if this flag is set */
  union
  {
    specifier s;                    /* if CLASS == SPECIFIER      */
    declarator d;                   /* if CLASS == DECLARATOR     */
  } select;

  /* function attributes */
  struct
  {
    struct value *args;             /* the defined arguments                */
    unsigned hasVargs:1;            /* functions has varargs                */
    unsigned calleeSaves:1;         /* functions uses callee save           */
    unsigned hasbody:1;             /* function body defined                */
    unsigned hasFcall:1;            /* does it call other functions         */
    unsigned reent:1;               /* function is reentrant                */
    unsigned naked:1;               /* naked function                       */

    unsigned shadowregs:1;          /* function uses shadow registers (pic16 port) */
    unsigned wparam:1;              /* first byte of arguments is passed via WREG (pic16 port) */
    unsigned nonbanked:1;           /* function has the nonbanked attribute */
    unsigned banked:1;              /* function has the banked attribute    */
    unsigned critical:1;            /* critical function                    */
    unsigned intrtn:1;              /* this is an interrupt routine         */
    unsigned rbank:1;               /* seperate register bank               */
    unsigned inlinereq:1;           /* inlining requested                   */
    unsigned noreturn:1;            /* promised not to return               */
    signed sdcccall;                /* ABI version used                     */
    unsigned smallc:1;              /* Small-C calling convention: Parameters on stack are passed left-to-right */
    unsigned raisonance:1;          /* Raisonance calling convention for STM8 */
    unsigned iar:1;                 /* IAR calling convention               */
    unsigned cosmic:1;              /* Cosmic calling convention            */
    unsigned z88dk_fastcall:1;      /* For the z80-related ports: Function has a single paramter of at most 32 bits that is passed in dehl */
    unsigned z88dk_callee:1;        /* Stack pointer adjustment for parameters passed on the stack is done by the callee */
    unsigned z88dk_shortcall:1;     /* Short call available via rst (see values later) (Z80 only) */
    unsigned z88dk_has_params_offset:1;     /* Has a parameter offset (Z80 only) */
    unsigned intno;                 /* Number of interrupt for interrupt service routine */
    short regbank;                  /* register bank 2b used                */
    unsigned builtin;               /* is a builtin function                */
    unsigned javaNative;            /* is a JavaNative Function (TININative ONLY) */
    unsigned overlay;               /* force parameters & locals into overlay segment */
    unsigned hasStackParms;         /* function has parameters on stack     */
    bool preserved_regs[9];         /* Registers preserved by the function - may be an underestimate */
    unsigned char z88dk_shortcall_rst;  /* Rst for a short call */
    unsigned short z88dk_shortcall_val; /* Value for a short call */
    unsigned short z88dk_params_offset;  /* Additional offset from for arguments */
  } funcAttrs;

  struct sym_link *next;            /* next element on the chain  */
}
sym_link;

typedef struct symbol
{
  char name[SDCC_SYMNAME_MAX + 1];  /* Input Variable Name     */
  char rname[SDCC_NAME_MAX + 1];    /* internal name           */

  long level;                       /* declaration lev,fld offset */
  int block;                        /* sequential block # of definition */
  int seqPoint;                     /* sequence point defined or, if unbound, used */
  int key;
  unsigned flexArrayLength;         /* if the symbol specifies a struct
                                       with a "flexible array member", then the additional length in bytes for
                                       the "fam" is stored here. Because the length can be different from symbol
                                       to symbol AND v_struct isn't copied in copyLinkChain(), it's located here
                                       in the symbol and not in v_struct or the declarator */
  unsigned implicit:1;              /* implicit flag                     */
  unsigned undefined:1;             /* undefined variable                */
  unsigned infertype:1;             /* type should be inferred from first assign */
  unsigned _isparm:1;               /* is a parameter          */
  unsigned ismyparm:1;              /* is parameter of the function being generated */
  unsigned isitmp:1;                /* is an intermediate temp */
  unsigned islbl:1;                 /* is a temporary label */
  unsigned isref:1;                 /* has been referenced  */
  unsigned isind:1;                 /* is an induction variable */
  unsigned isinvariant:1;           /* is a loop invariant  */
  unsigned cdef:1;                  /* compiler defined symbol */
  unsigned addrtaken:1;             /* address of the symbol was taken */
  unsigned isreqv:1;                /* is the register equivalent of a symbol */
  unsigned udChked:1;               /* use def checking has been already done */
  unsigned generated:1;             /* code generated (function symbols only) */
  unsigned isinscope:1;             /* is in scope */

  /* following flags are used by the backend
     for code generation and can be changed
     if a better scheme for backend is thought of */
  unsigned isLiveFcall:1;           /* is live at or across a function call */
  unsigned isspilt:1;               /* has to be spilt */
  unsigned spillA:1;                /* spilt be register allocator */
  unsigned remat:1;                 /* can be remateriazed */
  unsigned isptr:1;                 /* is a pointer */
  unsigned uptr:1;                  /* used as a pointer */
  unsigned isFree:1;                /* used by register allocator */
  unsigned islocal:1;               /* is a local variable        */
  unsigned blockSpil:1;             /* spilt at block level       */
  unsigned remainSpil:1;            /* spilt because not used in remainder */
  unsigned stackSpil:1;             /* has been spilt on temp stack location */
  unsigned onStack:1;               /* this symbol allocated on the stack */
  unsigned iaccess:1;               /* indirect access      */
  unsigned ruonly:1;                /* used in return statement only */
  unsigned spildir:1;               /* spilt in direct space */
  unsigned ptrreg:1;                /* this symbol assigned to a ptr reg */
  unsigned noSpilLoc:1;             /* cannot be assigned a spil location */
  bool funcDivFlagSafe:1;           /* we know this function is safe to call with undocumented stm8 flag bit 6 set*/
  bool funcUsesVolatile:1;          /* The function accesses a volatile variable */
  unsigned isstrlit;                /* is a string literal and it's usage count  */
  unsigned accuse;                  /* can be left in the accumulator
                                       On the Z80 accuse is divided into
                                       ACCUSE_A and ACCUSE_HL as the idea
                                       is quite similar.
                                     */
  unsigned dptr;                    /* 8051 variants with multiple DPTRS
                                       currently implemented in DS390 only
                                     */
  int allocreq;                     /* allocation is required for this variable */
  int stack;                        /* offset on stack      */
  int xstack;                       /* offset on xternal stack */
  short nRegs;                      /* number of registers required */
  short regType;                    /* type of register required    */

  struct reg_info *regs[8];         /* can have at the most 8 registers */
  struct asmop *aop;                /* asmoperand for this symbol */
  struct iCode *fuse;               /* furthest use */
  struct iCode *rematiCode;         /* rematerialise with which instruction */
  struct operand *reqv;             /* register equivalent of a local variable */
  struct symbol *prereqv;           /* symbol before register equiv. substitution */
  struct symbol *psbase;            /* if pseudo symbol, the symbol it is based on */
  union
  {
    struct symbol *spillLoc;        /* register spil location */
    struct set *itmpStack;          /* symbols spilt @ this stack location */
  }
  usl;
  int bitVar;                       /* if bitVar != 0: this is a bit variable, bitVar is the size in bits */
  unsigned bitUnnamed:1;            /* unnamed bit variable */
  unsigned offset;                  /* offset from top if struct */

  int lineDef;                      /* defined line number        */
  char *fileDef;                    /* defined filename           */
  int lastLine;                     /* for functions the last line */
  struct sym_link *type;            /* 1st link to declarator chain */
  struct sym_link *etype;           /* last link to declarator chain */
  struct symbol *next;              /* crosslink to next symbol   */
  struct symbol *localof;           /* local variable of which function */
  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 */
  int liveFrom;                     /* live from iCode sequence number */
  int liveTo;                       /* live to sequence number */
  int used;                         /* no. of times this was used */
  int recvSize;                     /* size of first argument  */
  struct bitVect *clashes;          /* overlaps with what other symbols */
  struct ast *funcTree;             /* function body ast if inlined */
  struct symbol *addressmod[2];     /* access functions for named address spaces */

  bool for_newralloc;
}
symbol;

extern sym_link *validateLink (sym_link * l,
                               const char *macro, const char *args, const char select, const char *file, unsigned line);
/* Easy Access Macros */
#define IS_OP_RUONLY(x) (IS_SYMOP(x) && OP_SYMBOL(x) && OP_SYMBOL(x)->ruonly)
#define IS_OP_ACCUSE(x) (IS_SYMOP(x) && OP_SYMBOL(x) && OP_SYMBOL(x)->accuse)

#define DCL_TYPE(l)  validateLink(l, "DCL_TYPE", #l, DECLARATOR, __FILE__, __LINE__)->select.d.dcl_type
#define DCL_ELEM(l)  validateLink(l, "DCL_ELEM", #l, DECLARATOR, __FILE__, __LINE__)->select.d.num_elem
#define DCL_PTR_CONST(l) validateLink(l, "DCL_PTR_CONST", #l, DECLARATOR, __FILE__, __LINE__)->select.d.ptr_const
#define DCL_PTR_VOLATILE(l) validateLink(l, "DCL_PTR_VOLATILE", #l, DECLARATOR, __FILE__, __LINE__)->select.d.ptr_volatile
#define DCL_PTR_RESTRICT(l) validateLink(l, "DCL_PTR_RESTRICT", #l, DECLARATOR, __FILE__, __LINE__)->select.d.ptr_restrict
#define DCL_PTR_ADDRSPACE(l) validateLink(l, "DCL_PTR_ADDRSPACE", #l, DECLARATOR, __FILE__, __LINE__)->select.d.ptr_addrspace
#define DCL_TSPEC(l) validateLink(l, "DCL_TSPEC", #l, DECLARATOR, __FILE__, __LINE__)->select.d.tspec

#define FUNC_DEBUG              //assert(IS_FUNC(x));
#define FUNC_HASVARARGS(x) (x->funcAttrs.hasVargs)
#define IFFUNC_HASVARARGS(x) (IS_FUNC(x) && FUNC_HASVARARGS(x))
#define FUNC_ARGS(x) (x->funcAttrs.args)
#define IFFUNC_ARGS(x) (IS_FUNC(x) && FUNC_ARGS(x))
#define FUNC_HASFCALL(x) (x->funcAttrs.hasFcall)
#define IFFUNC_HASFCALL(x) (IS_FUNC(x) && FUNC_HASFCALL(x))
#define FUNC_HASBODY(x) (x->funcAttrs.hasbody)
#define IFFUNC_HASBODY(x) (IS_FUNC(x) && FUNC_HASBODY(x))
#define FUNC_CALLEESAVES(x) (x->funcAttrs.calleeSaves)
#define IFFUNC_CALLEESAVES(x) (IS_FUNC(x) && FUNC_CALLEESAVES(x))
#define FUNC_ISISR(x) (x->funcAttrs.intrtn)
#define IFFUNC_ISISR(x) (IS_FUNC(x) && FUNC_ISISR(x))
#define FUNC_INTNO(x) (x->funcAttrs.intno)
#define FUNC_SDCCCALL(x) (x->funcAttrs.sdcccall)
#define FUNC_REGBANK(x) (x->funcAttrs.regbank)
#define FUNC_HASSTACKPARM(x) (x->funcAttrs.hasStackParms)
#define FUNC_ISINLINE(x) (x->funcAttrs.inlinereq)
#define IFFUNC_ISINLINE(x) (IS_FUNC(x) && FUNC_ISINLINE(x))
#define FUNC_ISNORETURN(x) (x->funcAttrs.noreturn)
#define IFFUNC_ISNORETURN(x) (IS_FUNC(x) && FUNC_ISNORETURN(x))

#define FUNC_ISREENT(x) (x->funcAttrs.reent)
#define IFFUNC_ISREENT(x) (IS_FUNC(x) && FUNC_ISREENT(x))
#define FUNC_ISSHADOWREGS(x) (x->funcAttrs.shadowregs)
#define IFFUNC_ISSHADOWREGS(x) (IS_FUNC(x) && FUNC_ISSHADOWREGS(x))
#define FUNC_ISWPARAM(x) (x->funcAttrs.wparam)
#define IFFUNC_ISWPARAM(x) (IS_FUNC(x) && FUNC_ISWPARAM(x))
#define FUNC_ISNAKED(x) (x->funcAttrs.naked)
#define IFFUNC_ISNAKED(x) (IS_FUNC(x) && FUNC_ISNAKED(x))
#define FUNC_NONBANKED(x) (x->funcAttrs.nonbanked)
#define IFFUNC_NONBANKED(x) (IS_FUNC(x) && FUNC_NONBANKED(x))
#define FUNC_BANKED(x) (x->funcAttrs.banked)
#define IFFUNC_BANKED(x) (IS_FUNC(x) && FUNC_BANKED(x))
#define FUNC_ISCRITICAL(x) (x->funcAttrs.critical)
#define IFFUNC_ISCRITICAL(x) (IS_FUNC(x) && FUNC_ISCRITICAL(x))
#define FUNC_ISBUILTIN(x) (x->funcAttrs.builtin)
#define IFFUNC_ISBUILTIN(x) (IS_FUNC(x) && FUNC_ISBUILTIN(x))
#define FUNC_ISJAVANATIVE(x) (x->funcAttrs.javaNative)
#define IFFUNC_ISJAVANATIVE(x) (IS_FUNC(x) && FUNC_ISJAVANATIVE(x))
#define FUNC_ISOVERLAY(x) (x->funcAttrs.overlay)
#define IFFUNC_ISOVERLAY(x) (IS_FUNC(x) && FUNC_ISOVERLAY(x))
#define FUNC_ISSMALLC(x) (x->funcAttrs.smallc)
#define IFFUNC_ISSMALLC(x) (IS_FUNC(x) && FUNC_ISSMALLC(x))
#define FUNC_ISRAISONANCE(x) (x->funcAttrs.raisonance)
#define IFFUNC_ISRAISONANCE(x) (IS_FUNC(x) && FUNC_ISRAISONANCE(x))
#define FUNC_ISIAR(x) (x->funcAttrs.iar)
#define IFFUNC_ISIAR(x) (IS_FUNC(x) && FUNC_ISIAR(x))
#define FUNC_ISCOSMIC(x) (x->funcAttrs.cosmic)
#define IFFUNC_ISCOSMIC(x) (IS_FUNC(x) && FUNC_ISCOSMIC(x))
#define FUNC_ISZ88DK_FASTCALL(x) (x->funcAttrs.z88dk_fastcall)
#define IFFUNC_ISZ88DK_FASTCALL(x) (IS_FUNC(x) && FUNC_ISZ88DK_FASTCALL(x))
#define FUNC_ISZ88DK_CALLEE(x) (x->funcAttrs.z88dk_callee)
#define IFFUNC_ISZ88DK_CALLEE(x) (IS_FUNC(x) && FUNC_ISZ88DK_CALLEE(x))
#define FUNC_ISZ88DK_SHORTCALL(x) (x->funcAttrs.z88dk_shortcall)
#define IFFUNC_ISZ88DK_SHORTCALL(x) (IS_FUNC(x) && FUNC_ISZ88DK_SHORTCALL(x))

#define BANKED_FUNCTIONS        ( options.model == MODEL_HUGE || \
                                  ( (options.model == MODEL_LARGE || options.model == MODEL_MEDIUM) && \
                                    TARGET_Z80_LIKE ) )
#define IFFUNC_ISBANKEDCALL(x)  ( IS_FUNC(x) && \
                                  ( FUNC_BANKED(x) || ( BANKED_FUNCTIONS && !FUNC_NONBANKED(x) ) ) )

#define SPEC_NOUN(x) validateLink(x, "SPEC_NOUN", #x, SPECIFIER, __FILE__, __LINE__)->select.s.noun
#define SPEC_LONG(x) validateLink(x, "SPEC_LONG", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_long
#define SPEC_LONGLONG(x) validateLink(x, "SPEC_LONGLONG", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_longlong
#define SPEC_SHORT(x) validateLink(x, "SPEC_LONG", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_short
#define SPEC_USIGN(x) validateLink(x, "SPEC_USIGN", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_unsigned
#define SPEC_SIGN(x) validateLink(x, "SPEC_SIGN", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_signed
#define SPEC_SCLS(x) validateLink(x, "SPEC_SCLS", #x, SPECIFIER, __FILE__, __LINE__)->select.s.sclass
#define SPEC_ENUM(x) validateLink(x, "SPEC_ENUM", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_isenum
#define SPEC_OCLS(x) validateLink(x, "SPEC_OCLS", #x, SPECIFIER, __FILE__, __LINE__)->select.s.oclass
#define SPEC_STAT(x) validateLink(x, "SPEC_STAT", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_static
#define SPEC_EXTR(x) validateLink(x, "SPEC_EXTR", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_extern
#define SPEC_CODE(x) validateLink(x, "SPEC_CODE", #x, SPECIFIER, __FILE__, __LINE__)->select.s._codesg
#define SPEC_ABSA(x) validateLink(x, "SPEC_ABSA", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_absadr
#define SPEC_BANK(x) validateLink(x, "SPEC_BANK", #x, SPECIFIER, __FILE__, __LINE__)->select.s._regbank
#define SPEC_ADDR(x) validateLink(x, "SPEC_ADDR", #x, SPECIFIER, __FILE__, __LINE__)->select.s._addr
#define SPEC_STAK(x) validateLink(x, "SPEC_STAK", #x, SPECIFIER, __FILE__, __LINE__)->select.s._stack
#define SPEC_CVAL(x) validateLink(x, "SPEC_CVAL", #x, SPECIFIER, __FILE__, __LINE__)->select.s.const_val
#define SPEC_BSTR(x) validateLink(x, "SPEC_BSTR", #x, SPECIFIER, __FILE__, __LINE__)->select.s._bitStart
#define SPEC_BLEN(x) validateLink(x, "SPEC_BLEN", #x, SPECIFIER, __FILE__, __LINE__)->select.s._bitLength
#define SPEC_BUNNAMED(x) validateLink(x, "SPEC_BUNNAMED", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_bitUnnamed
#define SPEC_NEEDSPAR(x) validateLink(x, "SPEC_NEEDSPAR", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_needspar

/* Sleaze: SPEC_ISR_SAVED_BANKS is only used on
 * function type symbols, which obviously cannot
 * be of BIT type. Therefore, we recycle the
 * _bitStart field instead of defining a new field.
 */
#define SPEC_ISR_SAVED_BANKS(x) validateLink(x, "SPEC_NOUN", #x, SPECIFIER, __FILE__, __LINE__)->select.s._bitStart
#define SPEC_VOLATILE(x) validateLink(x, "SPEC_NOUN", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_volatile
#define SPEC_CONST(x) validateLink(x, "SPEC_NOUN", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_const
#define SPEC_RESTRICT(x) validateLink(x, "SPEC_NOUN", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_restrict
#define SPEC_ADDRSPACE(x) validateLink(x, "SPEC_NOUN", #x, SPECIFIER, __FILE__, __LINE__)->select.s.addrspace
#define SPEC_STRUCT(x) validateLink(x, "SPEC_NOUN", #x, SPECIFIER, __FILE__, __LINE__)->select.s.v_struct
#define SPEC_TYPEDEF(x) validateLink(x, "SPEC_NOUN", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_typedef
#define SPEC_REGPARM(x) validateLink(x, "SPEC_NOUN", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_isregparm
#define SPEC_ARGREG(x) validateLink(x, "SPEC_NOUN", #x, SPECIFIER, __FILE__, __LINE__)->select.s.argreg
#define SPEC_INLINE(x) validateLink(x, "SPEC_INLINE", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_inline
#define SPEC_NORETURN(x) validateLink(x, "SPEC_NORETURN", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_noreturn
#define SPEC_ALIGNAS(x) validateLink(x, "SPEC_ALIGNAS", #x, SPECIFIER, __FILE__, __LINE__)->select.s.b_alignas

/* type check macros */
#define IS_DECL(x)       ( x && x->xclass == DECLARATOR )
#define IS_SPEC(x)       ( x && x->xclass == SPECIFIER  )

#define IS_ARRAY(x)      (IS_DECL(x) && DCL_TYPE(x) == ARRAY)
#define IS_DATA_PTR(x)   (IS_DECL(x) && DCL_TYPE(x) == POINTER)
#define IS_SMALL_PTR(x)  (IS_DECL(x) && (DCL_TYPE(x) == POINTER    ||    \
                                         DCL_TYPE(x) == IPOINTER   ||    \
                                         DCL_TYPE(x) == PPOINTER  ))
#define IS_PTR(x)        (IS_DECL(x) && (DCL_TYPE(x) == POINTER    ||    \
                                         DCL_TYPE(x) == FPOINTER   ||    \
                                         DCL_TYPE(x) == GPOINTER   ||    \
                                         DCL_TYPE(x) == IPOINTER   ||    \
                                         DCL_TYPE(x) == PPOINTER   ||    \
                                         DCL_TYPE(x) == EEPPOINTER ||    \
                                         DCL_TYPE(x) == CPOINTER   ||    \
                                         DCL_TYPE(x) == UPOINTER  ))
#define IS_PTR_CONST(x)  (IS_PTR(x) && DCL_PTR_CONST(x))
#define IS_PTR_RESTRICT(x) (IS_PTR(x) && DCL_PTR_RESTRICT(x))
#define IS_FARPTR(x)     (IS_DECL(x) && DCL_TYPE(x) == FPOINTER)
#define IS_CODEPTR(x)    (IS_DECL(x) && DCL_TYPE(x) == CPOINTER)
#define IS_GENPTR(x)     (IS_DECL(x) && DCL_TYPE(x) == GPOINTER)
#define IS_FUNCPTR(x)    (IS_DECL(x) && (DCL_TYPE(x) == CPOINTER || DCL_TYPE(x) == GPOINTER) && IS_FUNC(x->next))
#define IS_FUNC(x)       (IS_DECL(x) && DCL_TYPE(x) == FUNCTION)
#define IS_LONG(x)       (IS_SPEC(x) && x->select.s.b_long)
#define IS_LONGLONG(x)   (IS_SPEC(x) && x->select.s.b_longlong)
#define IS_UNSIGNED(x)   (IS_SPEC(x) && x->select.s.b_unsigned)
#define IS_TYPEDEF(x)    (IS_SPEC(x) && x->select.s.b_typedef)
#define IS_CONSTANT(x)   (isConstant (x))
#define IS_RESTRICT(x)   (isRestrict (x))
#define IS_STRUCT(x)     (IS_SPEC(x) && x->select.s.noun == V_STRUCT)
#define IS_ABSOLUTE(x)   (IS_SPEC(x) && x->select.s.b_absadr )
#define IS_REGISTER(x)   (IS_SPEC(x) && SPEC_SCLS(x) == S_REGISTER)
#define IS_RENT(x)       (IS_SPEC(x) && x->select.s._reent )
#define IS_STATIC(x)     (IS_SPEC(x) && SPEC_STAT(x))
#define IS_INLINE(x)     (IS_SPEC(x) && SPEC_INLINE(x))
#define IS_NORETURN(x)   (IS_SPEC(x) && SPEC_NORETURN(x))
#define IS_INT(x)        (IS_SPEC(x) && x->select.s.noun == V_INT)
#define IS_VOID(x)       (IS_SPEC(x) && x->select.s.noun == V_VOID)
#define IS_BOOL(x)       (IS_SPEC(x) && x->select.s.noun == V_BOOL)
#define IS_CHAR(x)       (IS_SPEC(x) && x->select.s.noun == V_CHAR)
#define IS_EXTERN(x)     (IS_SPEC(x) && x->select.s.b_extern)
#define IS_VOLATILE(x)   (isVolatile (x))
#define IS_INTEGRAL(x)   (IS_SPEC(x) && (x->select.s.noun == V_INT       || \
                                         x->select.s.noun == V_BOOL      || \
                                         x->select.s.noun == V_CHAR      || \
                                         x->select.s.noun == V_BITFIELD  || \
                                         x->select.s.noun == V_BBITFIELD || \
                                         x->select.s.noun == V_BIT       || \
                                         x->select.s.noun == V_SBIT ))
#define IS_BITFIELD(x)   (IS_SPEC(x) && (x->select.s.noun == V_BITFIELD  || \
                                         x->select.s.noun == V_BBITFIELD ))
#define IS_BITVAR(x)     (IS_SPEC(x) && (x->select.s.noun == V_BITFIELD  || \
                                         x->select.s.noun == V_BBITFIELD || \
                                         x->select.s.noun == V_BIT       || \
                                         x->select.s.noun == V_SBIT ))
#define IS_BIT(x)        (IS_SPEC(x) && (x->select.s.noun == V_BIT       || \
                                         x->select.s.noun == V_SBIT ))
#define IS_BOOLEAN(x)    (IS_SPEC(x) && (x->select.s.noun == V_BIT       || \
                                         x->select.s.noun == V_SBIT      || \
                                         x->select.s.noun == V_BBITFIELD || \
                                         x->select.s.noun == V_BOOL ))
#define IS_FLOAT(x)      (IS_SPEC(x) && x->select.s.noun == V_FLOAT)
#define IS_FIXED16X16(x) (IS_SPEC(x) && x->select.s.noun == V_FIXED16X16)
#define IS_FIXED(x)      (IS_FIXED16X16(x))
#define IS_ARITHMETIC(x) (IS_INTEGRAL(x) || IS_FLOAT(x) || IS_FIXED(x))
#define IS_AGGREGATE(x)  (IS_ARRAY(x) || IS_STRUCT(x))
#define IS_LITERAL(x)    (IS_SPEC(x) && x->select.s.sclass == S_LITERAL)
#define IS_CODE(x)       (IS_SPEC(x) && SPEC_SCLS(x) == S_CODE)
#define IS_REGPARM(x)    (IS_SPEC(x) && SPEC_REGPARM(x))

#define IS_VALID_PARAMETER_STORAGE_CLASS_SPEC(x)    (!SPEC_TYPEDEF(x) && !SPEC_EXTR(x) && !SPEC_STAT(x) && SPEC_SCLS(x) != S_AUTO)

/* symbol check macros */
#define IS_AUTO(x)       (x->level && !IS_STATIC(x->etype) && !IS_EXTERN(x->etype))

/* forward declaration for the global vars */
extern bucket *SymbolTab[];
extern bucket *StructTab[];
extern bucket *TypedefTab[];
extern bucket *LabelTab[];
extern bucket *enumTab[];
extern bucket *AddrspaceTab[];
extern symbol *fsadd;
extern symbol *fssub;
extern symbol *fsmul;
extern symbol *fsdiv;
extern symbol *fseq;
extern symbol *fsneq;
extern symbol *fslt;

extern symbol *fps16x16_add;
extern symbol *fps16x16_sub;
extern symbol *fps16x16_mul;
extern symbol *fps16x16_div;
extern symbol *fps16x16_eq;
extern symbol *fps16x16_neq;
extern symbol *fps16x16_lt;
extern symbol *fps16x16_lteq;
extern symbol *fps16x16_gt;
extern symbol *fps16x16_gteq;

/* Dims: mul/div/mod, BYTE/WORD/DWORD/QWORD, SIGNED/UNSIGNED/BOTH */
extern symbol *muldiv[3][4][4];
/* 16 x 16 -> 32 multiplication SIGNED/UNSIGNED */
extern symbol *muls16tos32[2];
/* Dims: BYTE/WORD/DWORD/QWORD SIGNED/UNSIGNED */
extern sym_link *multypes[4][2];
/* Dims: to/from float, BYTE/WORD/DWORD/QWORD, SIGNED/USIGNED */
extern symbol *conv[2][4][2];
/* Dims: to/from fixed16x16, BYTE/WORD/DWORD/QWORD/FLOAT, SIGNED/USIGNED */
extern symbol *fp16x16conv[2][5][2];
/* Dims: shift left/shift right, BYTE/WORD/DWORD/QWORD, SIGNED/UNSIGNED */
extern symbol *rlrr[2][4][2];

extern symbol *builtin_memcpy;
extern symbol *nonbuiltin_memcpy;

#define SCHARTYPE       multypes[0][0]
#define UCHARTYPE       multypes[0][1]
#define INTTYPE         multypes[1][0]
#define UINTTYPE        multypes[1][1]
#define LONGTYPE        multypes[2][0]
#define ULONGTYPE       multypes[2][1]
#define LONGLONGTYPE    multypes[3][0]
#define ULONGLONGTYPE   multypes[3][1]

extern sym_link *floatType;
extern sym_link *fixed16x16Type;

#include "SDCCval.h"

typedef enum
{
  RESULT_TYPE_NONE = 0,         /* operands will be promoted to int */
  RESULT_TYPE_BOOL,
  RESULT_TYPE_CHAR,
  RESULT_TYPE_INT,
  RESULT_TYPE_OTHER,            /* operands will be promoted to int */
  RESULT_TYPE_IFX,
  RESULT_TYPE_GPTR              /* operands will be promoted to generic ptr */
} RESULT_TYPE;

/* forward definitions for the symbol table related functions */
void initSymt ();
symbol *newSymbol (const char *, long);
sym_link *newLink (SYM_LINK_CLASS);
sym_link *newFloatLink ();
structdef *newStruct (const char *);
void addDecl (symbol *, int, sym_link *);
sym_link *finalizeSpec (sym_link *);
sym_link *mergeSpec (sym_link *, sym_link *, const char *name);
sym_link *mergeDeclSpec (sym_link *, sym_link *, const char *name);
symbol *reverseSyms (symbol *);
sym_link *reverseLink (sym_link *);
symbol *copySymbol (const symbol *);
symbol *copySymbolChain (const symbol *);
char *genSymName (long);
sym_link *getSpec (sym_link *);
int compStructSize (int, structdef *);
sym_link *copyLinkChain (const sym_link *);
int checkDecl (symbol *, int);
void checkBasic (sym_link *, sym_link *);
value *checkPointerIval (sym_link *, value *);
value *checkStructIval (symbol *, value *);
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 ();
sym_link *newBoolLink ();
sym_link *newPtrDiffLink ();
sym_link *newVoidLink ();
int compareType (sym_link *, sym_link *);
int compareTypeExact (sym_link *, sym_link *, long);
int compareTypeInexact (sym_link *, sym_link *);
int checkFunction (symbol *, symbol *);
void cleanUpLevel (bucket **, long);
void cleanUpBlock (bucket **, int);
symbol *getAddrspace (sym_link *type);
int funcInChain (sym_link *);
void addSymChain (symbol **);
sym_link *structElemType (sym_link *, value *);
symbol *getStructElement (structdef *, symbol *);
sym_link *computeType (sym_link *, sym_link *, RESULT_TYPE, int);
void processFuncPtrArgs (sym_link *);
void processFuncArgs (symbol *, sym_link *);
int isSymbolEqual (const symbol *, const symbol *);
int powof2 (TYPE_TARGET_ULONG);
void dbuf_printTypeChain (sym_link *, struct dbuf_s *);
void printTypeChain (sym_link *, FILE *);
void printTypeChainRaw (sym_link *, FILE *);
void initCSupport ();
void initBuiltIns ();
void pointerTypes (sym_link *, sym_link *);
void cdbStructBlock (int);
void initHashT ();
bucket *newBucket ();
void addSym (bucket **, void *, char *, long, int, int checkType);
void deleteSym (bucket **, void *, const char *);
void *findSym (bucket **, void *, const char *);
void *findSymWithLevel (bucket **, struct symbol *);
void *findSymWithBlock (bucket **, struct symbol *, int, long);
void changePointer (sym_link * p);
void checkTypeSanity (sym_link * etype, const char *name);
sym_link *typeFromStr (const char *);
STORAGE_CLASS sclsFromPtr (sym_link * ptr);
sym_link *newEnumType (symbol *);
void promoteAnonStructs (int, structdef *);
int isConstant (sym_link * type);
int isVolatile (sym_link * type);
int isRestrict (sym_link * type);
value *aggregateToPointer (value *);
void leaveBlockScope (int block);


extern char *nounName (sym_link *);     /* noun strings */
extern void printFromToType (sym_link *, sym_link *);

#endif
