symb.bi

''
'' symbol table protos
''

#include once "list.bi"
#include once "pool.bi"
#include once "ast-op.bi"
#include once "stack.bi"

''
enum FB_DATACLASS
	FB_DATACLASS_INTEGER                        '' must be the first
	FB_DATACLASS_FPOINT
	FB_DATACLASS_STRING
	FB_DATACLASS_UDT
	FB_DATACLASS_PROC
	FB_DATACLASS_UNKNOWN
end enum

'' if FB_DATATYPE changes, take care to update:
'' - ir-hlc.bas::dtypeName() array
'' - edbg_stab.bas::remapTB() array
'' - symb-mangling.bas::typecodeTB() array
'' - symb-data.bas::symb_dtypeTB() array
'' - emit_x86.bas::dtypeTB() array

enum FB_DATATYPE
	FB_DATATYPE_VOID
	FB_DATATYPE_BOOLEAN
	FB_DATATYPE_BYTE
	FB_DATATYPE_UBYTE
	FB_DATATYPE_CHAR
	FB_DATATYPE_SHORT
	FB_DATATYPE_USHORT
	FB_DATATYPE_WCHAR
	FB_DATATYPE_INTEGER
	FB_DATATYPE_UINT
	FB_DATATYPE_ENUM
	FB_DATATYPE_LONG
	FB_DATATYPE_ULONG
	FB_DATATYPE_LONGINT
	FB_DATATYPE_ULONGINT
	FB_DATATYPE_SINGLE
	FB_DATATYPE_DOUBLE
	FB_DATATYPE_STRING
	FB_DATATYPE_FIXSTR
	FB_DATATYPE_VA_LIST
	FB_DATATYPE_STRUCT
	FB_DATATYPE_NAMESPC
	FB_DATATYPE_FUNCTION
	FB_DATATYPE_FWDREF
	FB_DATATYPE_POINTER
	FB_DATATYPE_XMMWORD
end enum

const FB_DATATYPE_FIRST_NUMERIC = FB_DATATYPE_BOOLEAN
const FB_DATATYPE_LAST_NUMERIC = FB_DATATYPE_DOUBLE

const FB_DATATYPES = (FB_DATATYPE_XMMWORD - FB_DATATYPE_VOID) + 1

const FB_DT_TYPEMASK        = &b00000000000000000000000000011111 '' max 32 built-in datatypes
const FB_DT_PTRMASK         = &b00000000000000000000000111100000 '' level of pointer indirection
const FB_DT_CONSTMASK       = &b00000000000000111111111000000000 '' PTRLEVELS + 1 bit-masks
const FB_DATATYPE_REFERENCE = &b00000000000010000000000000000000 '' used for mangling BYREF parameters
const FB_DT_MANGLEMASK      = &b00000001111100000000000000000000 '' used to modify mangling for builtin types
const FB_DATATYPE_INVALID   = &b10000000000000000000000000000000

const FB_DT_PTRLEVELS       = 8                 '' max levels of pointer indirection

const FB_DT_PTRPOS          = 5
const FB_DT_CONSTPOS        = FB_DT_PTRPOS + 4

const FB_DT_MANGLEPOS       = 20

const FB_OVLPROC_MINORSCALE = 10

#define OvlMatchScore(major, minor) (((major) * FB_OVLPROC_MINORSCALE) + (minor))

enum FB_OVLPROC_MATCH_SCORE
	FB_OVLPROC_NO_MATCH = 0
	FB_OVLPROC_LOWEST_MATCH = 1
	FB_OVLPROC_CONVMATCH = OvlMatchScore( FB_DATATYPES * 1, 0 )
	FB_OVLPROC_CASTMATCH = OvlMatchScore( FB_DATATYPES * 2, 0 )
	FB_OVLPROC_HALFMATCH = OvlMatchScore( FB_DATATYPES * 3, 0 )
	FB_OVLPROC_TYPEMATCH = OvlMatchScore( FB_DATATYPES * 4, 0 )
	FB_OVLPROC_FULLMATCH = OvlMatchScore( FB_DATATYPES * 5, 0 )
end enum

enum
	FB_SIZETYPE_BOOLEAN = 0
	FB_SIZETYPE_INT8
	FB_SIZETYPE_UINT8
	FB_SIZETYPE_INT16
	FB_SIZETYPE_UINT16
	FB_SIZETYPE_INT32
	FB_SIZETYPE_UINT32
	FB_SIZETYPE_INT64
	FB_SIZETYPE_UINT64
	FB_SIZETYPE_FLOAT32
	FB_SIZETYPE_FLOAT64
end enum

'' symbol classes
'' When changing, update symb.bas:classnames() and symb.bas:classnamesPretty()
enum FB_SYMBCLASS
	FB_SYMBCLASS_VAR            = 1
	FB_SYMBCLASS_CONST
	FB_SYMBCLASS_PROC
	FB_SYMBCLASS_PARAM
	FB_SYMBCLASS_DEFINE
	FB_SYMBCLASS_KEYWORD
	FB_SYMBCLASS_LABEL
	FB_SYMBCLASS_NAMESPACE
	FB_SYMBCLASS_ENUM
	FB_SYMBCLASS_STRUCT
	FB_SYMBCLASS_CLASS
	FB_SYMBCLASS_FIELD
	FB_SYMBCLASS_TYPEDEF
	FB_SYMBCLASS_FWDREF                     '' forward definition
	FB_SYMBCLASS_SCOPE
	FB_SYMBCLASS_RESERVED                   '' reserved symbol
	FB_SYMBCLASS_NSIMPORT                   '' namespace import (an USING)
end enum

'' symbol state mask
enum FB_SYMBSTATS
	''                      ''= &h00000001 '' not-used
	FB_SYMBSTATS_ACCESSED     = &h00000002
	FB_SYMBSTATS_CTORINITED   = &h00000004  '' ctor method procs only
	FB_SYMBSTATS_DECLARED     = &h00000008
	FB_SYMBSTATS_IMPLICIT     = &h00000010  '' VARs only: implicitly generated by compiler (symbAddImplicitVar()), not explicitly defined in source code
	FB_SYMBSTATS_RTL          = &h00000020
	FB_SYMBSTATS_THROWABLE    = &h00000040
	FB_SYMBSTATS_PARSED       = &h00000080
	FB_SYMBSTATS_RTTITABLE    = &h00000100  '' VARs only: it's an rtti table (used for name mangling)
	FB_SYMBSTATS_HASALIAS     = &h00000200
	FB_SYMBSTATS_VTABLE       = &h00000400  '' VARs only: it's a vtable (used for name mangling)
	FB_SYMBSTATS_DONTINIT     = &h00000800
	FB_SYMBSTATS_MAINPROC     = &H00001000
	FB_SYMBSTATS_MODLEVELPROC = &h00002000
	FB_SYMBSTATS_FUNCPTR      = &h00004000  '' needed to demangle
	FB_SYMBSTATS_JUMPTB       = &h00008000  '' ASM backend's fake jumptb vars only
	FB_SYMBSTATS_GLOBALCTOR   = &h00010000
	FB_SYMBSTATS_GLOBALDTOR   = &h00020000
	FB_SYMBSTATS_CANTDUP      = &h00040000
	FB_SYMBSTATS_CANBECLONED  = &h00080000  '' procedures: It's safe to duplicate CALLs to procedures with this flag, no problems with side effects. Useful for RTL procedures where we can be sure about this.
	FB_SYMBSTATS_CANREDEFINE  = &h00100000  '' CONSTs: implicitly generated by compiler (symbKeywordConstsInit()), may be redefined
	FB_SYMBSTATS_FIXLENSTR    = &h00200000  '' TYPEDEFs: to differentiate between Zstring and Zstring * 1 (same for Wstring)
	FB_SYMBSTATS_HASRTTI      = &h00400000
	FB_SYMBSTATS_CANTUNDEF    = &h00800000
	FB_SYMBSTATS_UNIONFIELD   = &h01000000  '' fields only
	FB_SYMBSTATS_TEMPORARY    = &h01000000  '' variables: String and Wstring - a pointer that needs deallocating at scope breaks/end
	''                      ''= &h02000000  '' not-used
	FB_SYMBSTATS_EMITTED      = &h04000000  '' needed by high-level IRs, to avoid emitting structs etc twice
	FB_SYMBSTATS_BEINGEMITTED = &h08000000  '' ditto, for circular dependencies with structs

	'' reuse - take care
	FB_SYMBSTATS_PROCEMITTED  = FB_SYMBSTATS_UNIONFIELD  '' procs only
	FB_SYMBSTATS_EXCLPARENT   = FB_SYMBSTATS_DONTINIT    '' procs only

	FB_SYMBSTATS_ARGV = FB_SYMBSTATS_CANBECLONED  '' params/paramvars only: is it main()'s argv? (helping the C backend to emit a clang-compatible main() signature)
end enum

'' symbol attributes mask
enum FB_SYMBATTRIB
	FB_SYMBATTRIB_NONE             = &h00000000

	FB_SYMBATTRIB_SHARED           = &h00000001  '' all symbols
	FB_SYMBATTRIB_STATIC           = &h00000002  '' all symbols
	FB_SYMBATTRIB_DYNAMIC          = &h00000004  '' all symbols
	FB_SYMBATTRIB_COMMON           = &h00000008  '' all symbols
	FB_SYMBATTRIB_EXTERN           = &h00000010  '' all symbols: extern's become public when DIM'ed
	FB_SYMBATTRIB_PUBLIC           = &h00000020  '' all symbols
	FB_SYMBATTRIB_PRIVATE          = &h00000040  '' all symbols
	FB_SYMBATTRIB_LOCAL            = &h00000080  '' all symbols
	FB_SYMBATTRIB_EXPORT           = &h00000100  '' all symbols
	FB_SYMBATTRIB_IMPORT           = &h00000200  '' all symbols
	FB_SYMBATTRIB_LITERAL          = &h00000400  '' literal value - typically implies CONST
	FB_SYMBATTRIB_CONST            = &h00000800  '' CONST value, expression, or method
	FB_SYMBATTRIB_TEMP             = &h00001000  '' VARs
	FB_SYMBATTRIB_DESCRIPTOR       = &h00002000  '' VARs (arrays)
	FB_SYMBATTRIB_PARAMVARBYDESC   = &h00004000  '' VARs (paramater variables)
	FB_SYMBATTRIB_PARAMVARBYVAL    = &h00008000  '' VARs (paramater variables)
	FB_SYMBATTRIB_PARAMVARBYREF    = &h00010000  '' VARs (paramater variables)
	FB_SYMBATTRIB_FUNCRESULT       = &h00020000
	FB_SYMBATTRIB_REF              = &h00040000  '' VARs/FIELDs (if declared with BYREF)
	FB_SYMBATTRIB_INSTANCEPARAM    = &h00080000
	FB_SYMBATTRIB_SUFFIXED         = &h00100000
	FB_SYMBATTRIB_VIS_PRIVATE      = &h00200000  '' UDT members only
	FB_SYMBATTRIB_VIS_PROTECTED    = &h00400000  '' UDT members only
	FB_SYMBATTRIB_INTERNAL         = &h00800000  '' default UDT members / vtable / rtti - affects name mangling
	FB_SYMBATTRIB_ANONYMOUS        = &h01000000  '' anonymous / unnamed id
end enum

'' proc symbol attributes mask
enum FB_PROCATTRIB
	FB_PROCATTRIB_NONE             = &h00000000

	FB_PROCATTRIB_OVERLOADED       = &h00000001  '' PROCs / METHODs only
	FB_PROCATTRIB_METHOD           = &h00000002  '' Non-STATIC UDT member procs, i.e. procs with implicit THIS ptr
	FB_PROCATTRIB_CONSTRUCTOR      = &h00000004  '' methods only
	FB_PROCATTRIB_DESTRUCTOR1      = &h00000008  '' methods only - complete destructor
	FB_PROCATTRIB_OPERATOR         = &h00000010  '' methods only
	FB_PROCATTRIB_PROPERTY         = &h00000020  '' methods only
	FB_PROCATTRIB_STATICLOCALS     = &h00000040  '' PROCs only
	FB_PROCATTRIB_NAKED            = &h00000080  '' procedures only
	FB_PROCATTRIB_VIRTUAL          = &h00000100  '' methods only: all virtuals (normal and pure)
	FB_PROCATTRIB_ABSTRACT         = &h00000200  '' methods only: pure virtuals (only)
	FB_PROCATTRIB_NOTHISCONSTNESS  = &h00000400  '' PROCs only
	FB_PROCATTRIB_RETURNBYREF      = &h00000800  '' PROCs (functions/function pointers returning BYREF)
	FB_PROCATTRIB_DESTRUCTOR0      = &h00001000  '' methods only - deleting destructor
end enum

'' parameter modes
enum FB_PARAMMODE
	FB_PARAMMODE_BYVAL          = 1             '' must start at 1! used for mangling
	FB_PARAMMODE_BYREF
	FB_PARAMMODE_BYDESC
	FB_PARAMMODE_VARARG
end enum

'' call conventions
enum FB_FUNCMODE
	FB_FUNCMODE_STDCALL         = 1             '' ditto
	FB_FUNCMODE_STDCALL_MS                      '' ms/vb-style: don't include the @n suffix
	FB_FUNCMODE_CDECL
	FB_FUNCMODE_PASCAL
	FB_FUNCMODE_THISCALL                        '' x86 only
	FB_FUNCMODE_FASTCALL                        '' x86 only

	'' Symbolic constant to represent FBCALL, telling cProcCallingConv()
	'' and the RTL procedure definitions to use env.target.fbcall which
	'' will be the real FB_FUNCMODE_* implementing FBCALL depending on the
	'' compilation target.
	FB_FUNCMODE_FBCALL = -1
end enum

'' options when adding new symbols
enum FB_SYMBOPT
	FB_SYMBOPT_NONE             = &h00000000

	FB_SYMBOPT_PRESERVECASE     = &h00000001
	FB_SYMBOPT_UNSCOPE          = &h00000002
	FB_SYMBOPT_DECLARING        = &h00000004
	FB_SYMBOPT_MOVETOGLOB       = &h00000008
	FB_SYMBOPT_RTL              = &h00000010
	FB_SYMBOPT_DOHASH           = &h00000020
	FB_SYMBOPT_CREATEALIAS      = &h00000040
	FB_SYMBOPT_NODUPCHECK       = &h00000080
end enum

'' options when finding symbols
enum FB_SYMBFINDOPT
	FB_SYMBFINDOPT_NONE         = &h00000000
	FB_SYMBFINDOPT_PROPGET      = &h00000001  '' match property get and not property set
	FB_SYMBFINDOPT_BOP_OVL      = &h00000002  '' exact match at least one parameter
	FB_SYMBFINDOPT_EXPLICIT     = &h00000004  '' require explicit exact match
	FB_SYMBFINDOPT_NO_ERROR     = &h00000008  '' don't report errors, return to caller
	FB_SYMBFINDOPT_NO_CTOR      = &h00000010  '' don't find matching constructors
	FB_SYMBFINDOPT_NO_CAST      = &h00000020  '' don't find matching cast operators
end enum

''
enum FB_MANGLING
	FB_MANGLING_BASIC
	FB_MANGLING_CDECL
	FB_MANGLING_STDCALL
	FB_MANGLING_STDCALL_MS
	FB_MANGLING_CPP
	FB_MANGLING_PASCAL
	FB_MANGLING_RTLIB
end enum

''
enum FB_MANGLEOPT
	FB_MANGLEOPT_NONE         =   0  '' no special options
	FB_MANGLEOPT_KEEPTOPCONST =   1  '' keep the top-level const when mangling
	FB_MANGLEOPT_HASPTR       =   2  '' mangled type has/is a pointer type
	FB_MANGLEOPT_HASREF       =   4  '' mangled type has/is reference type
	FB_MANGLEOPT_NESTED       =   8  '' mangled type is nested in another type
end enum

enum FB_STRUCT_INREG
	FB_STRUCT_NONE ''(default, not used)
	FB_STRUCT_R    ''RAX
	FB_STRUCT_RR   ''RAX/RDX
	FB_STRUCT_RX   ''RAX/XMM0
	FB_STRUCT_X    ''XMM0
	FB_STRUCT_XR   ''XMM0/RAX
	FB_STRUCT_XX   ''XMM0/XMM1
end enum

''for analyzing structures Linux only
#define KPARTNOTDEF 0
#define KPART1FLOAT 2
#define KPART2FLOAT 8
#define KPART1INTEGER 1
#define KPART2INTEGER 4
#define KLOW8BYTES 1
#define KHIGH8BYTES 2
#define KSTRUCT_R  KPART1INTEGER
#define KSTRUCT_X  KPART1FLOAT
#define KSTRUCT_RR KPART1INTEGER + KPART2INTEGER
#define KSTRUCT_RX KPART1INTEGER + KPART2FLOAT
#define KSTRUCT_XR KPART1FLOAT   + KPART2INTEGER
#define KSTRUCT_XX KPART1FLOAT   + KPART2FLOAT

type FBSYMBOL_ as FBSYMBOL

#ifndef ASTNODE_
type ASTNODE_ as ASTNODE
#endif

#ifndef EMIT_NODE_
type EMIT_NODE_ as EMIT_NODE
#endif

''
type FBSYMLIST
	head            as FBSYMBOL_ ptr
	tail            as FBSYMBOL_ ptr
end type

type FBARRAYDIM
	lower           as longint
	upper           as longint
end type

'' Special value to represent the case where '...' ellipsis was given as ubound
const FB_ARRAYDIM_UNKNOWN = &h8000000000000000ll

''
type FBSYMCHAIN
	sym             as FBSYMBOL_ ptr            '' first symbol
	next            as FBSYMCHAIN ptr
	isimport        as integer

	'' all fields below are only set when importing (with USING) a ns
	prev            as FBSYMCHAIN ptr
	item            as HASHITEM ptr
	imp_next        as FBSYMCHAIN ptr
end type

''
type FBHASHTB
	owner           as FBSYMBOL_ ptr            '' back link
	tb              as THASH
	prev            as FBHASHTB ptr             '' prev node in the current hash tbs lookup list
	next            as FBHASHTB ptr             '' next  //
end type

type FBSYMHASH
	tb              as FBHASHTB ptr             '' parent's hash tb
	item            as HASHITEM ptr             '' hash item, for fast deletion
	index           as uinteger                 '' ditto
	prev            as FBSYMBOL_ ptr            '' prev duplicated symbol
	next            as FBSYMBOL_ ptr            '' next //
end type

''
type FBSYMBOLTB
	owner           as FBSYMBOL_ ptr            '' back link
	head            as FBSYMBOL_ ptr            '' first node
	tail            as FBSYMBOL_ ptr            '' last node
end type

''
type FBNAMESPC_EXT
	implist         as FBSYMLIST                '' all namespaces imported by this ns
	explist         as FBSYMLIST                '' all namespaces importing this ns
	cnt             as integer                  '' times this ns was imported/nested
	impsym_head     as FBSYMCHAIN ptr           '' imported symbols by the last USING
	impsym_tail     as FBSYMCHAIN ptr           '' /
end type

type FBNAMESPC
	symtb           as FBSYMBOLTB
	hashtb          as FBHASHTB
	ext             as FBNAMESPC_EXT ptr
end type

union FBVALUE
	s           as FBSYMBOL_ ptr
	i           as longint
	f           as double
end union

'' keyword
type FBS_KEYWORD
	id              as integer
	tkclass         as FB_TKCLASS
end type

'' define or macro
type FB_DEFPARAM
	name            as zstring ptr
	num             as integer
	next            as FB_DEFPARAM ptr
end type

enum FB_DEFTOK_TYPE
	FB_DEFTOK_TYPE_PARAM
	FB_DEFTOK_TYPE_PARAMSTR
	FB_DEFTOK_TYPE_TEX
	FB_DEFTOK_TYPE_TEXW
end enum

type FB_DEFTOK
	type            as FB_DEFTOK_TYPE

	union
		text        as zstring ptr
		textw       as wstring ptr
		paramnum    as integer
	end union

	prev            as FB_DEFTOK ptr
	next            as FB_DEFTOK ptr
end type

enum FB_DEFINE_FLAGS
	FB_DEFINE_FLAGS_NONE        = &h00000000
	FB_DEFINE_FLAGS_STR         = &h00000001
	FB_DEFINE_FLAGS_NOGCC       = &h00000002
	FB_DEFINE_FLAGS_VARIADIC    = &h00000004
	FB_DEFINE_FLAGS_NEEDPARENS  = &h00000008
end enum

type LEXPP_ARGTB_ as LEXPP_ARGTB ptr

type FBS_DEFINE_PROCZ as function( ) as string
type FBS_MACRO_PROCZ as function( byval argtb as LEXPP_ARGTB_, byval errnum as integer ptr ) as string
type FBS_MACRO_PROCW as function( byval argtb as LEXPP_ARGTB_, byval errnum as integer ptr ) as wstring ptr

type FBS_DEFINE
	params          as integer
	paramhead       as FB_DEFPARAM ptr

	union
		tokhead     as FB_DEFTOK ptr            '' only if args > 0
		text        as zstring ptr              '' //           = 0
		textw       as wstring ptr
	end union

	isargless       as integer
	flags           as FB_DEFINE_FLAGS          '' bit 0: 1=numeric, 0=string
	union
		dprocz          as FBS_DEFINE_PROCZ
		mprocz          as FBS_MACRO_PROCZ
	end union
	union
		mprocw          as FBS_MACRO_PROCW
	end union
end type

'' forward definition
type FBFWDREF
	ref             as FBSYMBOL_ ptr    '' The user that has to be backpatched
	prev            as FBFWDREF ptr
end type

type FBS_FWDREF
	tail            as FBFWDREF ptr     '' List of users of this fwdref
end type

'' label
type FBS_LABEL
	parent          as FBSYMBOL_ ptr            '' parent block, not always a proc
	declared        as integer
	stmtnum         as integer                  '' can't use colnum as it's unreliable

	gosub           as boolean                  '' if label is used for gosub with gas64
end type

'' structure
enum FB_UDTOPT
	FB_UDTOPT_ISUNION           = &h00000001
	FB_UDTOPT_ISANON            = &h00000002
	FB_UDTOPT_HASPTRFIELD       = &h00000004
	FB_UDTOPT_HASCTORFIELD      = &h00000008
	FB_UDTOPT_HASDTORFIELD      = &h00000010
	FB_UDTOPT_HASRECBYVALPARAM  = &h00000020
	FB_UDTOPT_HASRECBYVALRES    = &h00000040
	FB_UDTOPT_HASGETPROPERTY    = &h00000080
	FB_UDTOPT_HASSETPROPERTY    = &h00000100
	FB_UDTOPT_HASIDXGETPROPERTY = &h00000200
	FB_UDTOPT_HASIDXSETPROPERTY = &h00000400
	FB_UDTOPT_HASKWDFIELD       = &h00000800
	FB_UDTOPT_HASINITEDFIELD    = &h00001000
	FB_UDTOPT_HASANONUNION      = &h00002000
	FB_UDTOPT_HASSTATICVAR      = &h00004000
	FB_UDTOPT_HASBITFIELD       = &h00008000
	FB_UDTOPT_ISWSTRING         = &h00010000
	FB_UDTOPT_ISZSTRING         = &h00020000
	FB_UDTOPT_HASNESTED         = &h00040000
	FB_UDTOPT_HASZEROEDFIELD    = &h00080000
	FB_UDTOPT_HASFILLEDFIELD    = &h00100000
	FB_UDTOPT_VALISTTYPEMASK    = &h00f00000
end enum

type FB_STRUCT_DBG
	typenum         as integer
end type

type FB_STRUCTEXT
	ctorhead        as FBSYMBOL_ ptr            '' ctor head (first overload proc) or NULL
	defctor         as FBSYMBOL_ ptr            '' default ctor or NULL
	copyctor        as FBSYMBOL_ ptr            '' copy ctor or NULL
	copyctorconst   as FBSYMBOL_ ptr            '' copy ctor with CONST param or NULL
	dtor1           as FBSYMBOL_ ptr            '' complete object destructor or NULL
	dtor0           as FBSYMBOL_ ptr            '' deleting destructor or NULL
	copyletop       as FBSYMBOL_ ptr            '' copy LET overload proc or NULL
	copyletopconst  as FBSYMBOL_ ptr            '' copy LET overload proc with CONST param or NULL
	opovlTb(0 to AST_OP_SELFOPS-1) as FBSYMBOL_ ptr
	vtableelements  as integer                  '' vtable elements counter
	vtable          as FBSYMBOL_ ptr            '' virtual-functions table struct
	rtti            as FBSYMBOL_ ptr            '' Run-Time Type Info struct
	abstractcount   as integer                  '' ABSTRACT method counter (to determine abstract classes, which aren't allowed to be instantiated)
end type

type FBS_STRUCT
	'' extends FBNAMESPC
	ns              as FBNAMESPC

	base            as FBSYMBOL_ ptr            '' base class
	anonparent      as FBSYMBOL_ ptr
	natalign        as integer                  '' UDT's natural alignment based on largest natural field alignment
	unpadlgt        as longint                  '' unpadded len
	options         as long                     '' FB_UDTOPT
	bitpos          as ubyte
	align           as ubyte

	'' real type used to return this UDT from functions
	retdtype        as FB_DATATYPE
	retin2regs      as FB_STRUCT_INREG ''for gas64
	dbg             as FB_STRUCT_DBG
	ext             as FB_STRUCTEXT ptr
end type

'' enumeration
type FBS_ENUM
	'' extends FBNAMESPC
	ns              as FBNAMESPC

	elements        as integer
	dbg             as FB_STRUCT_DBG
end type

type FB_CALL_ARG                                '' used by overloaded function calls
	expr            as ASTNODE_ ptr
	mode            as FB_PARAMMODE
	next            as FB_CALL_ARG ptr
end type

type FB_CALL_ARG_LIST
	args            as integer
	head            as FB_CALL_ARG ptr
	tail            as FB_CALL_ARG ptr
end type

'' function param
type FBS_PARAM
	mode            as FB_PARAMMODE
	var             as FBSYMBOL_ ptr            '' link to decl var in func bodies
	optexpr         as ASTNODE_ ptr             '' default value
	bydescdimensions    as integer
	bydescrealsubtype   as FBSYMBOL_ ptr        '' bydesc array descriptor type
	regnum          as integer                  '' register number (1 is first, 0 is not in register)
end type

'' function
type FBRTLCALLBACK as function( byval sym as FBSYMBOL_ ptr ) as integer

type FB_PROCOVL
	minparams       as short
	maxparams       as short
	next            as FBSYMBOL_ ptr
end type

'' used by x86 ASM emitter only
type FB_PROCSTK
	argofs          as integer
	localofs        as integer
	localmax        as integer
end type

type FB_PROCDBG
	iniline         as integer                  '' sub|function
	endline         as integer                  '' end sub|function
	incfile         as zstring ptr
end type

type FB_PROCERR
	lasthnd         as FBSYMBOL_ ptr            '' last error handler
	lastmod         as FBSYMBOL_ ptr            '' last module name
	lastfun         as FBSYMBOL_ ptr            '' last function name
end type

type FB_PROCOPOVL
	op              as AST_OP
end type

type FB_DTORWRAPPER
	proc            as FBSYMBOL_ ptr
	sym             as FBSYMBOL_ ptr            '' for symbol
end type

enum FB_PROCSTATS
	FB_PROCSTATS_RETURNUSED     = &h0001
	FB_PROCSTATS_ASSIGNUSED     = &h0002
	FB_PROCSTATS_GOSUBUSED      = &h0004
end enum

type FB_PROCGSB
	ctx             as FBSYMBOL_ ptr            '' local pointer for gosub stack
end type

type FB_PROCEXT
	res             as FBSYMBOL_ ptr            '' result, if any
	stk             as FB_PROCSTK               '' to keep track of the stack frame
	dbg             as FB_PROCDBG               '' debugging
	err             as FB_PROCERR
	opovl           as FB_PROCOPOVL
	statdtor        as TLIST ptr                '' list of static instances with dtors
	stats           as FB_PROCSTATS
	stmtnum         as integer
	priority        as integer
	gosub           as FB_PROCGSB
	base_initree    as ASTNODE_ ptr             '' base() ctorcall/initializer given in constructor bodies

	'' virtual methods:
	''    vtable array index, location of the procptr in the vtbl
	'' methods that override a virtual method:
	''    vtable index of the virtual method that's overridden by this one
	'' other methods:
	''    0
	'' A valid index must be >= 2 since the first two vtable elements are
	'' the null pointer and the rtti pointer.
	vtableindex     as integer

	'' For methods that override a virtual method: the method that's
	'' overridden (if any); or else NULL.
	overridden      as FBSYMBOL_ ptr
end type

type FB_PROCRTL
	callback        as FBRTLCALLBACK
end type

enum FB_PROC_RETURN_METHOD
	FB_RETURN_FPU
	FB_RETURN_SSE
	FB_RETURN_DEFAULT           '' if none specified, take from the proto
end enum


type FBS_PROC
	symtb           as FBSYMBOLTB               '' local symbols table
	params          as short
	optparams       as short                    '' number of optional/default params
	paramtb         as FBSYMBOLTB               '' parameters symbol tb
	mode            as FB_FUNCMODE              '' calling convention

	'' result type remapped to what it will be emitted as, including CONSTs
	realdtype       as FB_DATATYPE
	realsubtype     as FBSYMBOL_ ptr

	returnMethod    as FB_PROC_RETURN_METHOD
	rtl             as FB_PROCRTL
	ovl             as FB_PROCOVL               '' overloading
	ext             as FB_PROCEXT ptr           '' extra fields, not used with prototypes
end type

'' scope
type FB_SCOPEDBG
	iniline         as integer                  '' scope
	endline         as integer                  '' end scope
	inilabel        as FBSYMBOL_ ptr
	endlabel        as FBSYMBOL_ ptr
end type

'' used by x86 ASM emitter only
type FB_SCOPEEMIT
	baseofs         as integer
end type

type FBS_SCOPE
	backnode        as ASTNODE_ ptr
	symtb           as FBSYMBOLTB
	dbg             as FB_SCOPEDBG
	emit            as FB_SCOPEEMIT
end type

enum FBARRAY_FLAGS
	FBARRAY_FLAGS_DIMENSIONS = &h0000000f      '' number of entries allocated in dimTb()
	FBARRAY_FLAGS_FIXED_DIM  = &h00000010      '' array points to fixed-length memory
	FBARRAY_FLAGS_FIXED_LEN  = &h00000020      '' array points to fixed-length memory
	FBARRAY_FLAGS_RESERVED   = &hffffffc0      '' reserved, do not use
end enum

'' variable
type FBS_ARRAY
	'' 0 = none (not an array),
	'' -1 = () = not yet known (should be filled in ASAP),
	'' 1..n = known dimensions (fixed-size or dynamic arrays)
	dimensions      as integer

	'' Dynamically allocated array of dimension bounds (static arrays only)
	dimtb           as FBARRAYDIM ptr

	diff            as longint
	elements        as longint
	desc            as FBSYMBOL_ ptr

	'' Array descriptor type (useful especially for BYDESC param vars, which
	'' don't have a descriptor var associated, but still need to know the
	'' exact descriptor type sometimes)
	desctype        as FBSYMBOL_ ptr
end type

type FBVAR_DESC
	array           as FBSYMBOL_ ptr            '' back-link
end type

type FBVAR_DATA
	prev            as FBSYMBOL_ ptr
end type

type FBS_CONST
	union                                       '' extends FBVALUE
		value       as FBVALUE
		s           as FBSYMBOL_ ptr
		i           as longint
		f           as double
	end union
	hassuffix       as integer
end type

type FBS_VAR
	union
		littext     as zstring ptr
		littextw    as wstring ptr
		initree     as ASTNODE_ ptr
	end union
	array           as FBS_ARRAY
	desc            as FBVAR_DESC
	stmtnum         as integer                  '' can't use colnum as it's unreliable
	align           as integer                  '' 0 = use default alignment
	data            as FBVAR_DATA               '' used with DATA stmts
	bitpos          as integer                  '' bitfields only: bit offset in container field
	bits            as integer                  '' bitfields only: size in bits
end type

'' namespace
type FBS_NAMESPACE
	'' extends FBNAMESPC
	ns              as FBNAMESPC

	cnt             as integer                  '' times this ns was re-opened
	last_tail       as FBSYMBOL_ ptr            '' point to last tail
end type

'' namespace import (USING)
type FBS_NSIMPORT
	'' imported ns (src)
	imp_ns          as FBSYMBOL_ ptr
	imp_prev        as FBSYMBOL_ ptr
	imp_next        as FBSYMBOL_ ptr
	'' exported ns (dst)
	exp_ns          as FBSYMBOL_ ptr
	exp_prev        as FBSYMBOL_ ptr
	exp_next        as FBSYMBOL_ ptr
end type

''
type FB_SYMBID
	name            as zstring ptr              '' upper-cased name, shared by hash tb
	alias           as zstring ptr              '' alias/preserved (if EXTERN was used) name
	mangled         as zstring ptr              '' mangled name
end type

''
type FBSYMBOL
	class           as FB_SYMBCLASS
	attrib          as FB_SYMBATTRIB
	pattrib         as FB_PROCATTRIB
	stats           as FB_SYMBSTATS

	id              as FB_SYMBID

	typ             as FB_DATATYPE
	subtype         as FBSYMBOL ptr

	scope           as ushort
	mangling        as short                    '' FB_MANGLING

	lgt         as longint
	ofs         as longint                      '' for local vars, args, UDT's and fields

	union
		var_        as FBS_VAR
		val         as FBS_CONST                '' constants
		udt         as FBS_STRUCT
		enum_       as FBS_ENUM
		proc        as FBS_PROC
		param       as FBS_PARAM
		lbl         as FBS_LABEL
		def         as FBS_DEFINE
		key         as FBS_KEYWORD
		fwd         as FBS_FWDREF
		scp         as FBS_SCOPE
		nspc        as FBS_NAMESPACE
		nsimp       as FBS_NSIMPORT
	end union

	hash            as FBSYMHASH                '' hash tb (namespace) it's part of

	symtb           as FBSYMBOLTB ptr           '' symbol tb it's part of

	parent          as FBSYMBOL Ptr

	prev            as FBSYMBOL ptr             '' next in symbol tb list
	next            as FBSYMBOL ptr             '' prev /
end type

type FBHASHTBLIST
	head            as FBHASHTB ptr
	tail            as FBHASHTB ptr
end type

type SYMB_DEF_PARAM
	item            as HASHITEM ptr
	index           as uinteger
end type

type SYMB_DEF_UniqueId_Elm
	name            as zstring ptr
	prev            as SYMB_DEF_UniqueId_Elm ptr
end type

type SYMB_DEF_UniqueId_Stack
	top             as SYMB_DEF_UniqueId_Elm ptr
end type

type SYMB_DEF_UniqueId
	dict            as THASH                    '' of SYMB_DEF_UniqueId_Stack
end type

type SYMB_DEF_CTX
	paramlist       as TLIST                    '' define parameters
	toklist         as TLIST                    '' define tokens
	uniqueid        as SYMB_DEF_UniqueId

	'' macros only..
	param           as integer                  '' param count
	paramhash       as THASH
	hash(0 to FB_MAXDEFINEARGS-1) as SYMB_DEF_PARAM
end type

type SYMB_OVLOP
	head            as FBSYMBOL ptr             '' head proc
end type

type FB_GLOBCTORLIST_ITEM
	sym             as FBSYMBOL ptr
	next            as FB_GLOBCTORLIST_ITEM ptr
end type

type FB_GLOBCTORLIST
	head            as FB_GLOBCTORLIST_ITEM ptr
	tail            as FB_GLOBCTORLIST_ITEM ptr
	list            as TLIST
end type

type FB_RTTICTX
	fb_rtti         as FBSYMBOL ptr
	fb_object       as FBSYMBOL ptr
End Type

const CHAINPOOL_SIZE = 1 shl 12

type SYMBCTX
	inited          as integer

	symlist         as TLIST                    '' (of FBSYMBOL)
	hashlist        as FBHASHTBLIST

	'' FBSYMCHAIN's are allocated from this buffer
	chainpool(0 to (CHAINPOOL_SIZE - 1)) as FBSYMCHAIN
	chainpoolhead       as integer

	globnspc        as FBSYMBOL                 '' global namespace

	namespc         as FBSYMBOL ptr             '' current ns
	hashtb          as FBHASHTB ptr             '' current hash tb
	symtb           as FBSYMBOLTB ptr           '' current symbol tb

	neststk         as TSTACK                   '' nest stack (namespace/class nesting)
	imphashtb       as THASH                    '' imported symbol (USING) tb
	imphashlist     as TLIST                    '' (of FBSYMHASH)

	namepool        as TPOOL

	fwdlist         as TLIST                    '' forward typedef refs

	nsextlist       as TLIST                    '' of FBNAMESPC_EXT

	fwdrefcnt       as integer

	def             as SYMB_DEF_CTX             '' #define context

	lastlbl         as FBSYMBOL ptr

	globctorlist    as FB_GLOBCTORLIST          '' global ctors list
	globdtorlist    as FB_GLOBCTORLIST          '' global dtors list

	globOpOvlTb ( _
					0 to AST_OPCODES-1 _
				)   as SYMB_OVLOP               '' global operator overloading

	fbarray_data        as integer              '' offsetof( FBARRAY, data )
	fbarray_ptr         as integer              '' offsetof( FBARRAY, ptr )
	fbarray_size        as integer              '' offsetof( FBARRAY, size )
	fbarray_dimtb       as integer              '' offsetof( FBARRAY, dimTB )
	fbarraydim          as FBSYMBOL ptr         '' FBARRAYDIM (dimTB element structure)
	fbarraydim_lbound   as integer              '' offsetof( FBARRAYDIM, lbound )
	fbarraydim_ubound   as integer              '' offsetof( FBARRAYDIM, ubound )

	rtti            as FB_RTTICTX
end type

type SYMB_DATATYPE
	class           as FB_DATACLASS             '' INTEGER, FPOINT
	size            as integer                  '' in bytes
	signed          as integer                  '' TRUE or FALSE

	'' For basic integer types only: ranking value, to establish a proper
	'' target-specific (32bit/64bit) order (the FB_DATATYPE enum order is
	'' not enough because it's not target-specific)
	intrank         as integer

	remaptype       as FB_DATATYPE              '' remapped type for ENUM, POINTER, etc
	sizetype        as integer      '' FB_SIZETYPE_*
	name            as const zstring ptr
end type

'' Data passed from symbUdtDeclareDefaultMembers() to symbUdtImplementDefaultMembers()
type SYMBDEFAULTMEMBERS
	defctor         as FBSYMBOL ptr
	dtor1           as FBSYMBOL ptr
	dtor0           as FBSYMBOL ptr
	copyctor        as FBSYMBOL ptr
	copyctorconst   as FBSYMBOL ptr
	copyletopconst  as FBSYMBOL ptr
end type

#include once "ast.bi"

declare sub symbInit _
	( _
		byval ismain as integer _
	)

declare sub symbEnd _
	( _
		_
	)

declare sub symbDataInit( )

declare function symbNewChainpool _
	( _
		byval sym as FBSYMBOL ptr _
	) as FBSYMCHAIN ptr

declare function symbLookup _
	( _
		byval id as zstring ptr, _
		byref tk as FB_TOKEN, _
		byref tk_class as FB_TKCLASS _
	) as FBSYMCHAIN ptr

declare function symbLookupAt _
	( _
		byval ns as FBSYMBOL ptr, _
		byval id as const zstring ptr, _
		byval preserve_case as integer = FALSE, _
		byval search_imports as integer = TRUE _
	) as FBSYMCHAIN ptr

declare function symbFindByClass _
	( _
		byval chain as FBSYMCHAIN ptr, _
		byval class as integer _
	) as FBSYMBOL ptr

declare function symbFindVarBySuffix _
	( _
		byval chain as FBSYMCHAIN ptr, _
		byval suffix as integer _
	) as FBSYMBOL ptr

declare function symbFindVarByDefType _
	( _
		byval chain as FBSYMCHAIN ptr, _
		byval dtype as integer _
	) as FBSYMBOL ptr

declare function symbFindByClassAndType _
	( _
		byval chain_ as FBSYMCHAIN ptr, _
		byval symclass as integer, _
		byval dtype as integer _
	) as FBSYMBOL ptr

declare function symbLookupByNameAndClass _
	( _
		byval ns as FBSYMBOL ptr, _
		byval symbol as const zstring ptr, _
		byval class as integer, _
		byval preservecase as integer = FALSE, _
		byval search_imports as integer = TRUE _
	) as FBSYMBOL ptr

declare function symbFindOverloadProc _
	( _
		byval parent as FBSYMBOL ptr, _
		byval proc as FBSYMBOL ptr, _
		byval options as FB_SYMBFINDOPT = FB_SYMBFINDOPT_NONE _
	) as FBSYMBOL ptr

declare function symbFindOpOvlProc _
	( _
		byval op as AST_OP, _
		byval parent as FBSYMBOL ptr, _
		byval proc as FBSYMBOL ptr _
	) as FBSYMBOL ptr

declare function symbFindClosestOvlProc _
	( _
		byval proc as FBSYMBOL ptr, _
		byval params as integer, _
		byval arg_head as FB_CALL_ARG ptr, _
		byval err_num as FB_ERRMSG ptr, _
		byval options as FB_SYMBFINDOPT = FB_SYMBFINDOPT_NONE _
	) as FBSYMBOL ptr

declare function symbFindBopOvlProc _
	( _
		byval op as AST_OP, _
		byval l as ASTNODE ptr, _
		byval r as ASTNODE ptr, _
		byval err_num as FB_ERRMSG ptr _
	) as FBSYMBOL ptr

declare function symbFindSelfBopOvlProc _
	( _
		byval op as AST_OP, _
		byval l as ASTNODE ptr, _
		byval r as ASTNODE ptr, _
		byval err_num as FB_ERRMSG ptr _
	) as FBSYMBOL ptr

declare function symbFindUopOvlProc _
	( _
		byval op as AST_OP, _
		byval l as ASTNODE ptr, _
		byval err_num as FB_ERRMSG ptr _
	) as FBSYMBOL ptr

declare function symbFindSelfUopOvlProc _
	( _
		byval op as AST_OP, _
		byval l as ASTNODE ptr, _
		byval err_num as FB_ERRMSG ptr _
	) as FBSYMBOL ptr

declare function symbFindCastOvlProc _
	( _
		byval to_dtype as integer, _
		byval to_subtype as FBSYMBOL ptr, _
		byval expr as ASTNODE ptr, _
		byval err_num as FB_ERRMSG ptr, _
		byval options as FB_SYMBFINDOPT = FB_SYMBFINDOPT_NONE _
	) as FBSYMBOL ptr

declare function symbFindCtorOvlProc _
	( _
		byval sym as FBSYMBOL ptr, _
		byval expr as ASTNODE ptr, _
		byval arg_mode as FB_PARAMMODE, _
		byval err_num as FB_ERRMSG ptr, _
		byval options as FB_SYMBFINDOPT = FB_SYMBFINDOPT_NONE _
	) as FBSYMBOL ptr

declare function symbFindCtorProc _
	( _
		byval head_proc as FBSYMBOL ptr, _
		byval proc as FBSYMBOL ptr _
	) as FBSYMBOL ptr

declare function symbCalcProcMatch _
	( _
		byval l as FBSYMBOL ptr, _
		byval r as FBSYMBOL ptr, _
		byref errmsg as integer _
	) as FB_OVLPROC_MATCH_SCORE

declare sub symbProcCheckOverridden _
	( _
		byval proc as FBSYMBOL ptr, _
		byval is_implicit as integer _
	)
declare sub symbProcSetVtableIndex( byval proc as FBSYMBOL ptr, byval i as integer )
declare function symbProcGetVtableIndex( byval proc as FBSYMBOL ptr ) as integer
declare function symbProcGetOverridden( byval proc as FBSYMBOL ptr ) as FBSYMBOL ptr
declare function symbGetProcResult( byval proc as FBSYMBOL ptr ) as FBSYMBOL ptr
declare function symbProcHasFwdRefInSignature( byval proc as FBSYMBOL ptr ) as integer

declare function symbAreProcModesEqual _
	( _
		byval proca as FBSYMBOL ptr, _
		byval procb as FBSYMBOL ptr _
	) as integer

declare function symbAddKeyword _
	( _
		byval symbol as const zstring ptr, _
		byval id as integer, _
		byval class as integer, _
		byval hashtb as FBHASHTB ptr = NULL, _
		byval dtype as integer = FB_DATATYPE_INVALID, _
		byval attrib as FB_SYMBATTRIB = FB_SYMBATTRIB_NONE _
	) as FBSYMBOL ptr

declare function symbKeywordGetText( byval tk as integer ) as const zstring ptr

declare function symbAddDefine _
	( _
		byval symbol as const zstring ptr, _
		byval text as zstring ptr, _
		byval lgt as integer, _
		byval isargless as integer = FALSE, _
		byval proc as FBS_DEFINE_PROCZ = NULL, _
		byval flags as FB_DEFINE_FLAGS = FB_DEFINE_FLAGS_NONE _
	) as FBSYMBOL ptr

declare function symbAddDefineW _
	( _
		byval symbol as zstring ptr, _
		byval text as wstring ptr, _
		byval lgt as integer, _
		byval isargless as integer = FALSE, _
		byval proc as FBS_DEFINE_PROCZ = NULL, _
		byval flags as FB_DEFINE_FLAGS = FB_DEFINE_FLAGS_NONE _
	) as FBSYMBOL ptr

declare function symbAddDefineMacro _
	( _
		byval symbol as const zstring ptr, _
		byval tokhead as FB_DEFTOK ptr, _
		byval params as integer, _
		byval paramhead as FB_DEFPARAM ptr, _
		byval flags as FB_DEFINE_FLAGS = FB_DEFINE_FLAGS_NONE _
	) as FBSYMBOL ptr

declare function symbAddDefineParam _
	( _
		byval lastparam as FB_DEFPARAM ptr, _
		byval symbol as const zstring ptr _
	) as FB_DEFPARAM ptr

declare function symbAddDefineTok _
	( _
		byval lasttok as FB_DEFTOK ptr, _
		byval dtype as FB_DEFTOK_TYPE _
	) as FB_DEFTOK ptr

declare function symbDelDefineTok _
	( _
		byval tok as FB_DEFTOK ptr _
	) as FB_DEFTOK ptr

declare function symbAddFwdRef _
	( _
		byval id as zstring ptr _
	) as FBSYMBOL ptr

declare function symbAddTypedef _
	( _
		byval id as zstring ptr, _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval lgt as longint _
	) as FBSYMBOL ptr

declare function symbAddLabel _
	( _
		byval symbol as zstring ptr, _
		byval options as FB_SYMBOPT = FB_SYMBOPT_DECLARING _
	) as FBSYMBOL ptr

declare sub symbGetDescTypeArrayDtype _
	( _
		byval desctype as FBSYMBOL ptr, _
		byref arraydtype as integer, _
		byref arraysubtype as FBSYMBOL ptr _
	)
declare function symbGetDescTypeDimensions( byval desctype as FBSYMBOL ptr ) as integer

declare function symbAddArrayDescriptorType _
	( _
		byval dimensions as integer, _
		byval arraydtype as integer, _
		byval arraysubtype as FBSYMBOL ptr _
	) as FBSYMBOL ptr

declare sub symbSetFixedSizeArrayDimensionElements _
	( _
		byval sym as FBSYMBOL ptr, _
		byval dimension as integer, _
		byval elements as longint _
	)

declare sub symbCheckDynamicArrayDimensions _
	( _
		byval sym as FBSYMBOL ptr, _
		byval dimensions as integer _
	)

declare sub symbVarInitFields( byval sym as FBSYMBOL ptr )

declare sub symbVarInitArrayDimensions _
	( _
		byval sym as FBSYMBOL ptr, _
		byval dimensions as integer, _
		dTB() as FBARRAYDIM _
	)

declare function symbAddVar _
	( _
		byval symbol as const zstring ptr, _
		byval aliasname as const zstring ptr, _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval lgt as longint, _
		byval dimensions as integer, _
		dTB() as FBARRAYDIM, _
		byval attrib as FB_SYMBATTRIB, _
		byval options as FB_SYMBOPT = FB_SYMBOPT_NONE _
	) as FBSYMBOL ptr

declare function symbAddTempVar _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr = NULL _
	) as FBSYMBOL ptr

declare function symbAddImplicitVar _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr = NULL, _
		byval options as integer = 0 _
	) as FBSYMBOL ptr

declare function symbAddAndAllocateTempVar( byval dtype as integer ) as FBSYMBOL ptr
declare function symbAddArrayDesc( byval array as FBSYMBOL ptr ) as FBSYMBOL ptr

declare function symbAddConst _
	( _
		byval id as zstring ptr, _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval value as FBVALUE ptr, _
		byval attrib as FB_SYMBATTRIB = FB_SYMBATTRIB_NONE _
	) as FBSYMBOL ptr

declare function symbReuseOrAddConst _
	( _
		byval id as zstring ptr, _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval value as FBVALUE ptr, _
		byval attrib as FB_SYMBATTRIB _
	) as FBSYMBOL ptr

declare function symbGetConstValueAsStr( byval s as FBSYMBOL ptr ) as string
declare function symbGetConstStrAsStr( byval s as FBSYMBOL ptr ) as zstring ptr
declare function symbGetConstStrAsWstr( byval s as FBSYMBOL ptr ) as wstring ptr

declare function symbStructBegin _
	( _
		byval symtb as FBSYMBOLTB ptr, _
		byval hashtb as FBHASHTB ptr, _
		byval parent as FBSYMBOL ptr, _
		byval id as const zstring ptr, _
		byval id_alias as const zstring ptr, _
		byval isunion as integer, _
		byval align as integer, _
		byval is_derived as integer, _
		byval attrib as FB_SYMBATTRIB, _
		byval options as integer _
	) as FBSYMBOL ptr

declare sub symbStructAddBase( byval struct as FBSYMBOL ptr, byval base_ as FBSYMBOL ptr )

declare function typeCalcNaturalAlign _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr _
	) as integer

declare function symbAddField _
	( _
		byval parent as FBSYMBOL ptr, _
		byval id as zstring ptr, _
		byval dimensions as integer, _
		dTB() as FBARRAYDIM, _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval lgt as longint, _
		byval bits as integer, _
		byval attrib as FB_SYMBATTRIB _
	) as FBSYMBOL ptr

declare sub symbInsertInnerUDT _
	( _
		byval parent as FBSYMBOL ptr, _
		byval inner as FBSYMBOL ptr _
	)

declare sub symbStructEnd _
	( _
		byval t as FBSYMBOL ptr, _
		byval isnested as integer = FALSE _
	)

declare function symbAddEnum _
	( _
		byval id as zstring ptr, _
		byval id_alias as zstring ptr, _
		byval attrib as FB_SYMBATTRIB, _
		byval use_hashtb as integer _
	) as FBSYMBOL ptr

declare function symbAddEnumElement _
	( _
		byval parent as FBSYMBOL ptr, _
		byval id as zstring ptr, _
		byval value as longint, _
		byval attrib as FB_SYMBATTRIB _
	) as FBSYMBOL ptr

declare function symbAddProcParam _
	( _
		byval proc as FBSYMBOL ptr, _
		byval id as zstring ptr, _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval dimensions as integer, _
		byval mode as integer, _
		byval attrib as FB_SYMBATTRIB, _
		byval pattrib as FB_PROCATTRIB _
	) as FBSYMBOL ptr

declare sub symbMakeParamOptional _
	( _
		byval proc as FBSYMBOL ptr, _
		byval param as FBSYMBOL ptr, _
		byval optexpr as ASTNODE ptr _
	)

declare function symbAddProc _
	( _
		byval proc as FBSYMBOL ptr, _
		byval id as const zstring ptr, _
		byval id_alias as const zstring ptr, _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval attrib as FB_SYMBATTRIB, _
		byval pattrib as FB_PROCATTRIB, _
		byval mode as integer, _
		byval options as FB_SYMBOPT _
	) as FBSYMBOL ptr

declare function symbAddOperator _
	( _
		byval proc as FBSYMBOL ptr, _
		byval op as AST_OP, _
		byval id_alias as zstring ptr, _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval attrib as FB_SYMBATTRIB, _
		byval pattrib as FB_PROCATTRIB, _
		byval mode as integer, _
		byval options as FB_SYMBOPT = FB_SYMBOPT_NONE _
	) as FBSYMBOL ptr

declare function symbAddCtor _
	( _
		byval proc as FBSYMBOL ptr, _
		byval id_alias as zstring ptr, _
		byval attrib as FB_SYMBATTRIB, _
		byval pattrib as FB_PROCATTRIB, _
		byval mode as integer, _
		byval options as FB_SYMBOPT = FB_SYMBOPT_NONE _
	) as FBSYMBOL ptr

declare function symbLookupInternallyMangledSubtype _
	( _
		byval id as zstring ptr, _
		byval proc as FBSYMBOL ptr, _
		byref attrib as FB_SYMBATTRIB, _
		byref pattrib as FB_PROCATTRIB, _
		byref parent as FBSYMBOL ptr, _
		byref symtb as FBSYMBOLTB ptr, _
		byref hashtb as FBHASHTB ptr _
	) as FBSYMBOL ptr

declare function symbAddProcPtr _
	( _
		byval proc as FBSYMBOL ptr, _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval attrib as FB_SYMBATTRIB, _
		byval pattrib as FB_PROCATTRIB, _
		byval mode as integer _
	) as FBSYMBOL ptr

declare function symbAddProcPtrFromFunction _
	( _
		byval base_proc as FBSYMBOL ptr _
	) as FBSYMBOL ptr

declare function symbPreAddProc _
	( _
		byval symbol as zstring ptr _
	) as FBSYMBOL ptr

declare sub symbGetRealParamDtype overload _
	( _
		byval parammode as integer, _
		byval bydescrealsubtype as FBSYMBOL ptr, _
		byref dtype as integer, _
		byref subtype as FBSYMBOL ptr _
	)

declare sub symbGetRealParamDtype overload _
	( _
		byval param as FBSYMBOL ptr, _
		byref dtype as integer, _
		byref subtype as FBSYMBOL ptr _
	)

declare function symbAddVarForParam( byval param as FBSYMBOL ptr ) as FBSYMBOL ptr
declare function symbAddVarForProcResultParam( byval proc as FBSYMBOL ptr ) as FBSYMBOL ptr
declare function symbAddProcResultVar( byval f as FBSYMBOL ptr ) as FBSYMBOL ptr

declare sub symbAddProcInstanceParam _
	( _
		byval parent as FBSYMBOL ptr, _
		byval proc as FBSYMBOL ptr _
	)

declare sub symbProcAllocExt( byval proc as FBSYMBOL ptr )
declare sub symbProcFreeExt( byval proc as FBSYMBOL ptr )
declare function symbProcReturnsOnStack( byval proc as FBSYMBOL ptr ) as integer

declare function symbCalcArgLen _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval mode as integer _
	) as longint

declare function symbCalcParamLen _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval mode as FB_PARAMMODE _
	) as longint

declare function symbProcCalcStdcallSuffixN( byval proc as FBSYMBOL ptr ) as longint
declare function symbProcCalcBytesToPop( byval proc as FBSYMBOL ptr ) as longint

declare function symbAddScope _
	( _
		byval backnode as ASTNODE ptr _
	) as FBSYMBOL ptr

declare sub symbScopeTurnTempsIntoImplicits( byval scopesym as FBSYMBOL ptr )

declare function symbAddNamespace _
	( _
		byval id as zstring ptr, _
		byval id_alias as zstring ptr _
	) as FBSYMBOL ptr

declare sub symbAddToFwdRef _
	( _
		byval f as FBSYMBOL ptr, _
		byval ref as FBSYMBOL ptr _
	)

declare sub symbRemoveFromFwdRef _
	( _
		byval f as FBSYMBOL ptr, _
		byval ref as FBSYMBOL ptr _
	)

declare function symbArrayHasUnknownBounds( byval sym as FBSYMBOL ptr ) as integer

declare sub symbSetArrayDimTb _
	( _
		byval s as FBSYMBOL ptr, _
		byval dimensions as integer, _
		dTB() as FBARRAYDIM _
	)

declare sub symbMaybeAddArrayDesc( byval sym as FBSYMBOL ptr )

declare sub symbDelSymbolTb _
	( _
		byval tb as FBSYMBOLTB ptr, _
		byval hashonly as integer _
	)

declare sub symbDelScopeTb _
	( _
		byval scp as FBSYMBOL ptr _
	)

declare sub symbDelSymbol _
	( _
		byval s as FBSYMBOL ptr, _
		byval is_tbdel as integer = FALSE _
	)

declare function symbDelDefine _
	( _
		byval s as FBSYMBOL ptr _
	) as integer

declare sub symbDelLabel _
	( _
		byval s as FBSYMBOL ptr _
	)

declare sub symbDelVar( byval s as FBSYMBOL ptr, byval is_tbdel as integer )
declare sub symbDelPrototype( byval s as FBSYMBOL ptr )
declare sub symbDelEnum( byval s as FBSYMBOL ptr )
declare sub symbDelStruct( byval s as FBSYMBOL ptr )

declare sub symbDelConst _
	( _
		byval s as FBSYMBOL ptr _
	)

declare sub symbDelScope _
	( _
		byval scp as FBSYMBOL ptr _
	)

declare sub symbDelNamespaceMembers _
	( _
		byval ns as FBSYMBOL ptr, _
		byval delete_hashtb as integer _
	)

declare sub symbDelNamespace( byval ns as FBSYMBOL ptr )

declare function symbNewSymbol _
	( _
		byval options as FB_SYMBOPT, _
		byval s as FBSYMBOL ptr, _
		byval symtb as FBSYMBOLTB ptr, _
		byval hashtb as FBHASHTB ptr, _
		byval class as FB_SYMBCLASS, _
		byval id as const zstring ptr, _
		byval id_alias as const zstring ptr, _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval attrib as FB_SYMBATTRIB, _
		byval pattrib as FB_PROCATTRIB _
	) as FBSYMBOL ptr

declare sub symbFreeSymbol _
	( _
		byval s as FBSYMBOL ptr _
	)

declare sub symbFreeSymbol_RemOnly _
	( _
		byval s as FBSYMBOL ptr _
	)

declare sub symbFreeSymbol_UnlinkOnly _
	( _
		byval s as FBSYMBOL ptr _
	)

declare sub symbDelFromHash _
	( _
		byval s as FBSYMBOL ptr _
	)

declare sub symbDelFromChainList _
	( _
		byval s as FBSYMBOL ptr _
	)

declare sub symbRecalcLen( byval sym as FBSYMBOL ptr )
declare sub symbSetType _
	( _
		byval sym as FBSYMBOL ptr, _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr _
	)

declare function symbCalcLen _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr _
	) as longint

declare function symbCalcDerefLen _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr  _
	) as longint

declare function symbAllocFloatConst _
	( _
		byval value as double, _
		byval dtype as integer _
	) as FBSYMBOL ptr

declare function symbAllocIntConst _
	( _
		byval value as longint, _
		byval dtype as integer _
	) as FBSYMBOL ptr

declare function symbAllocStrConst _
	( _
		byval sname as zstring ptr, _
		byval lgt as integer _
	) as FBSYMBOL ptr

declare function symbAllocWstrConst _
	( _
		byval sname as wstring ptr, _
		byval lgt as integer _
	) as FBSYMBOL ptr

declare function symbGetRealSize( byval sym as FBSYMBOL ptr ) as longint
declare sub symbGetRealType( byval sym as FBSYMBOL ptr, byref dtype as integer, byref subtype as FBSYMBOL ptr )

declare function symbCalcArrayElements _
	( _
		byval sym as FBSYMBOL ptr, _
		byval first as integer _
	) as longint

declare function symbCheckArraySize _
	( _
		byval dimensions as integer, _
		byval dimtb as FBARRAYDIM ptr, _
		byval lgt as longint, _
		byval is_on_stack as integer _
	) as integer

declare function symbCheckLabels _
	( _
		byval symtbhead as FBSYMBOL ptr _
	) as integer

declare function symbCheckBitField _
	( _
		byval udt as FBSYMBOL ptr, _
		byval dtype as integer, _
		byval lgt as longint, _
		byval bits as integer _
	) as integer

declare sub symbCheckFwdRef _
	( _
		byval s as FBSYMBOL ptr _
	)

declare function symbIsEqual _
	( _
		byval sym1 as FBSYMBOL ptr, _
		byval sym2 as FBSYMBOL ptr _
	) as integer

declare function symbIsProcOverloadOf _
	( _
		byval proc as FBSYMBOL ptr, _
		byval parent as FBSYMBOL ptr _
	) as integer

declare sub symbCheckChainForTypesAndOthers _
	( _
		byval chain_ as FBSYMCHAIN ptr, _
		byref typ as FBSYMBOL ptr, _
		byref nontype as FBSYMBOL ptr _
	)

declare function symbHasCtor( byval sym as FBSYMBOL ptr ) as integer
declare function symbHasDefCtor( byval sym as FBSYMBOL ptr ) as integer
declare function symbHasDtor( byval sym as FBSYMBOL ptr ) as integer
declare function symbIsDataDesc( byval sym as FBSYMBOL ptr ) as integer

declare function symbIsArray _
	( _
		byval sym as FBSYMBOL ptr _
	) as integer

declare function symbIsString _
	( _
		byval dtype as integer _
	) as integer

declare function symbGetValistType( byval dtype as integer, byval subtype as FBSYMBOL ptr ) as FB_CVA_LIST_TYPEDEF
#define symbIsValistStructArray( dtype, subtype ) (symbGetValistType( dtype, subtype ) = FB_CVA_LIST_BUILTIN_C_STD)
#define symbIsBuiltinVaListType( dtype, subtype ) (symbGetValistType( dtype, subtype ) > FB_CVA_LIST_POINTER)

declare function symbGetVarHasCtor _
	( _
		byval s as FBSYMBOL ptr _
	) as integer

declare function symbGetVarHasDtor _
	( _
		byval s as FBSYMBOL ptr _
	) as integer

declare sub typeMax _
	( _
		byval ldtype as integer, _
		byval lsubtype as FBSYMBOL ptr, _
		byval rdtype as integer, _
		byval rsubtype as FBSYMBOL ptr, _
		byref dtype as integer, _
		byref subtype as FBSYMBOL ptr _
	)

declare function typeToSigned _
	( _
		byval dtype as integer _
	) as integer

declare function typeToUnsigned _
	( _
		byval dtype as integer _
	) as integer

declare function typeHasCtor _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr _
	) as integer

declare function typeHasDefCtor _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr _
	) as integer

declare function typeHasDtor _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr _
	) as integer

declare function typeNeedsDtorCall _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr _
	) as integer

declare function typeIsTrivial _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr _
	) as integer

declare function typeHasFwdRefInSignature _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr _
	) as integer

declare function typeMerge _
	( _
		byval dtype1 as integer, _
		byval dtype2 as integer _
	) as integer

declare function typeCalcMatch _
	( _
		byval ldtype as integer, _
		byval lsubtype as FBSYMBOL ptr, _
		byval lparammode as integer, _
		byval rdtype as integer, _
		byval rsubtype as FBSYMBOL ptr _
	) as FB_OVLPROC_MATCH_SCORE

declare sub symbHashListAdd _
	( _
		byval hashtb as FBHASHTB ptr _
	)

declare sub symbHashListAddBefore _
	( _
		byval lasttb as FBHASHTB ptr, _
		byval hashtb as FBHASHTB ptr _
	)

declare sub symbHashListDel _
	( _
		byval hashtb as FBHASHTB ptr _
	)

declare function symbNamespaceImport _
	( _
		byval ns as FBSYMBOL ptr _
	) as integer

declare function symbNamespaceImportEx _
	( _
		byval ns as FBSYMBOL ptr, _
		byval to_ns as FBSYMBOL ptr _
	) as integer

declare sub symbNamespaceRemove _
	( _
		byval sym as FBSYMBOL ptr, _
		byval hashonly as integer _
	)

declare sub symbNamespaceReImport _
	( _
		byval ns as FBSYMBOL ptr _
	)

declare sub symbNestBegin _
	( _
		byval sym as FBSYMBOL ptr, _
		byval insert_chain as integer = FALSE _
	)

declare sub symbNestEnd _
	( _
		byval remove_chain as integer = FALSE _
	)

declare function symbCanDuplicate _
	( _
		byval head_sym as FBSYMBOL ptr, _
		byval s as FBSYMBOL ptr _
	) as integer

declare function symbUniqueId( byval validfbname as boolean = false ) as zstring ptr
declare function symbUniqueLabel( ) as zstring ptr
declare function symbMakeProfileLabelName( ) as zstring ptr
declare function symbGetMangledName( byval sym as FBSYMBOL ptr ) as zstring ptr
declare function symbGetDBGName( byval sym as FBSYMBOL ptr ) as zstring ptr
declare sub symbSetName( byval s as FBSYMBOL ptr, byval name_ as zstring ptr )
declare sub symbMangleResetAbbrev( )
declare function hMangleBuiltInType _
	( _
		byval dtype as integer, _
		byref add_abbrev as integer = FALSE _
	) as zstring ptr
declare sub symbMangleType _
	( _
		byref mangled as string, _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval options as FB_MANGLEOPT = FB_MANGLEOPT_NONE _
	)
declare sub symbMangleParam( byref mangled as string, byval param as FBSYMBOL ptr )

declare function hDumpDynamicArrayDimensions( byval dimensions as integer ) as string
declare function symbProcPtrToStr( byval proc as FBSYMBOL ptr ) as string
declare function symbMethodToStr( byval proc as FBSYMBOL ptr ) as string

declare function symbTypeToStr _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval length as longint = 0, _
		byval is_fixlenstr as integer = FALSE _
	) as string

declare function symbGetDefType _
	( _
		byval symbol as const zstring ptr _
	) as integer

declare sub symbSetDefType _
	( _
		byval ichar as integer, _
		byval echar as integer, _
		byval typ as integer _
	)

declare sub symbUdtAllocExt( byval udt as FBSYMBOL ptr )

declare sub symbUdtDeclareDefaultMembers _
	( _
		byref default as SYMBDEFAULTMEMBERS, _
		byval udt as FBSYMBOL ptr, _
		byval mode as FB_FUNCMODE _
	)

declare sub symbUdtImplementDefaultMembers _
	( _
		byref default as SYMBDEFAULTMEMBERS, _
		byval udt as FBSYMBOL ptr _
	)

declare function symbCompIsTrivial( byval sym as FBSYMBOL ptr ) as integer
declare sub symbSetCompCtorHead( byval sym as FBSYMBOL ptr, byval proc as FBSYMBOL ptr )
declare sub symbCheckCompCtor( byval sym as FBSYMBOL ptr, byval proc as FBSYMBOL ptr )
declare sub symbSetCompDtor1( byval sym as FBSYMBOL ptr, byval proc as FBSYMBOL ptr )
declare sub symbSetCompDtor0( byval sym as FBSYMBOL ptr, byval proc as FBSYMBOL ptr )
declare function symbGetCompCtorHead( byval sym as FBSYMBOL ptr ) as FBSYMBOL ptr
declare function symbGetCompDefCtor( byval sym as FBSYMBOL ptr ) as FBSYMBOL ptr
declare function symbGetCompDtor1( byval sym as FBSYMBOL ptr ) as FBSYMBOL ptr
declare function symbGetCompDtor0( byval sym as FBSYMBOL ptr ) as FBSYMBOL ptr
declare sub symbCheckCompLetOp( byval sym as FBSYMBOL ptr, byval proc as FBSYMBOL ptr )
declare function symbCompHasCopyLetOps( byval udt as FBSYMBOL ptr ) as integer

declare function symbGetCompOpOvlHead _
	( _
		byval sym as FBSYMBOL ptr, _
		byval op as AST_OP _
	) as FBSYMBOL ptr

declare sub symbSetCompOpOvlHead _
	( _
		byval sym as FBSYMBOL ptr, _
		byval proc as FBSYMBOL ptr _
	)

declare function symbCompAddVirtual( byval udt as FBSYMBOL ptr ) as integer
declare function symbCompGetAbstractCount( byval udt as FBSYMBOL ptr ) as integer
declare function symbAddGlobalCtor( byval proc as FBSYMBOL ptr ) as FB_GLOBCTORLIST_ITEM ptr
declare function symbAddGlobalDtor( byval proc as FBSYMBOL ptr ) as FB_GLOBCTORLIST_ITEM ptr

declare function symbCloneSymbol _
	( _
		byval s as FBSYMBOL ptr _
	) as FBSYMBOL ptr

declare function symbCloneConst( byval sym as FBSYMBOL ptr ) as FBSYMBOL ptr
declare function symbCloneVar( byval sym as FBSYMBOL ptr ) as FBSYMBOL ptr

declare function symbCloneLabel _
	( _
		byval sym as FBSYMBOL ptr _
	) as FBSYMBOL ptr

declare function symbIsParentNamespace _
	( _
		byval dtype as FB_DATATYPE, _
		byval subtype as FBSYMBOL ptr,  _
		byval start_ns as FBSYMBOL ptr = NULL _
	) as integer

declare function symbCheckAccess _
	( _
		byval sym as FBSYMBOL ptr _
	) as integer

declare function symbCheckAccessStruct _
	( _
		byval sym as FBSYMBOL ptr _
	) as integer

declare function symbGetFullProcName _
	( _
		byval proc as FBSYMBOL ptr _
	) as zstring ptr

declare function symbUdtGetFirstField( byval parent as FBSYMBOL ptr ) as FBSYMBOL ptr
declare function symbUdtGetNextField( byval sym as FBSYMBOL ptr ) as FBSYMBOL ptr
declare function symbUdtGetNextInitableField( byval sym as FBSYMBOL ptr ) as FBSYMBOL ptr

declare function symbGetEnumFirstElm _
	( _
		byval parent as FBSYMBOL ptr _
	) as FBSYMBOL ptr

declare function symbGetEnumNextElm _
	( _
		byval sym as FBSYMBOL ptr _
	) as FBSYMBOL ptr

declare sub symbCompDelImportList _
	( _
		byval sym as FBSYMBOL ptr _
	)

declare sub symbHashListInsertNamespace _
	( _
		byval ns as FBSYMBOL ptr, _
		byval src_head as FBSYMBOL ptr _
	)

declare sub symbHashListRemoveNamespace _
	( _
		byval ns as FBSYMBOL ptr _
	)

declare function symbGetDefaultParamMode _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr _
	) as integer

declare function symbVarCheckAccess( byval sym as FBSYMBOL ptr ) as integer

declare function symbCheckConstAssignTopLevel _
	( _
		byval ldtype as FB_DATATYPE, _
		byval rdtype as FB_DATATYPE, _
		byval lsubtype as FBSYMBOL ptr, _
		byval rsubtype as FBSYMBOL ptr, _
		byval mode as FB_PARAMMODE = 0, _
		byref matches as integer = 0 _
	) as integer

declare function symbCheckConstAssign _
	( _
		byval ldtype as FB_DATATYPE, _
		byval rdtype as FB_DATATYPE, _
		byval lsubtype as FBSYMBOL ptr, _
		byval rsubtype as FBSYMBOL ptr, _
		byval mode as FB_PARAMMODE = 0, _
		byref matches as integer = 0, _
		byref wrnmsg as FB_WARNINGMSG = 0 _
	) as integer

declare function symbAllocOvlCallArg _
	( _
		byval list as TLIST ptr, _
		byval arg_list as FB_CALL_ARG_LIST ptr, _
		byval to_head as integer = FALSE _
	) as FB_CALL_ARG ptr

#define symbFreeOvlCallArg( list, arg ) listDelNode( list, arg )

declare sub symbFreeOvlCallArgs _
	( _
		byval list as TLIST ptr, _
		byval arg_list as FB_CALL_ARG_LIST ptr _
	)

declare function symbGetUDTBaseLevel _
	( _
		byval s as FBSYMBOL ptr, _
		byval baseSym as FBSYMBOL ptr _
	) as integer

declare function symbCloneSimpleStruct( byval sym as FBSYMBOL ptr ) as FBSYMBOL ptr

''
'' macros
''

#macro symbHashTbInit( _hashtb, _owner, _nodes )
	_hashtb.owner = _owner
	_hashtb.prev = NULL
	_hashtb.next = NULL
	if( (_nodes) <> 0 ) then
		hashInit( @_hashtb.tb, _nodes )
	else
		clear( _hashtb.tb, 0, sizeof( _hashtb.tb ) )
	end if
#endmacro

#macro symbSymbTbInit( _symtb, _owner )
	_symtb.owner = _owner
	_symtb.head = NULL
	_symtb.tail = NULL
#endmacro

#macro symbHashListMove( hashtb )
	symbHashListDel( hashtb )
	symbHashListAdd( hashtb )
#endmacro

#macro symbHashListMoveBefore( lasttb, hashtb )
	symbHashListDel( hashtb )
	symbHashListAddBefore( lasttb, hashtb )
#endmacro

#define symbGetGlobalNamespc( ) symb.globnspc

#define symbIsGlobalNamespc( ) (symb.namespc = @symbGetGlobalNamespc( ))

#define symbGetGlobalTb( ) symbGetGlobalNamespc( ).nspc.ns.symtb

#define symbGetGlobalTbHead( ) symbGetGlobalTb( ).head

#define symbGetGlobalHashTb( ) symbGetGlobalNamespc( ).nspc.ns.hashtb

#define symbGetCurrentNamespc( ) symb.namespc
#define symbSetCurrentNamespc(ns) symb.namespc = ns

#define symbGetCurrentSymTb( ) symb.symtb
#define symbSetCurrentSymTb(tb) symb.symtb = tb

#define symbGetCurrentHashTb( ) symb.hashtb
#define symbSetCurrentHashTb(tb) symb.hashtb = tb

#define symbGetGlobCtorListHead( ) symb.globctorlist.head

#define symbGetGlobDtorListHead( ) symb.globdtorlist.head

#define symbGetIsAccessed(s) ((s->stats and FB_SYMBSTATS_ACCESSED) <> 0)
#define symbSetIsAccessed(s) s->stats or= FB_SYMBSTATS_ACCESSED

#define symbGetIsDeclared(s) ((s->stats and FB_SYMBSTATS_DECLARED) <> 0)
#define symbSetIsDeclared(s) s->stats or= FB_SYMBSTATS_DECLARED

#define symbGetIsImplicit( s ) (((s)->stats and FB_SYMBSTATS_IMPLICIT) <> 0)
#define symbSetIsImplicit( s ) (s)->stats or= FB_SYMBSTATS_IMPLICIT

#define symbGetIsRTL(s) ((s->stats and FB_SYMBSTATS_RTL) <> 0)

#define symbGetIsThrowable(s) ((s->stats and FB_SYMBSTATS_THROWABLE) <> 0)
#define symbSetIsThrowable(s) s->stats or= FB_SYMBSTATS_THROWABLE

#define symbGetIsParsed(s) ((s->stats and FB_SYMBSTATS_PARSED) <> 0)
#define symbSetIsParsed(s) s->stats or= FB_SYMBSTATS_PARSED

#define symbSetDontInit(s) s->stats or= FB_SYMBSTATS_DONTINIT
#define symbGetDontInit(s) ((s->stats and FB_SYMBSTATS_DONTINIT) <> 0)

#define symbGetIsMainProc(s) ((s->stats and FB_SYMBSTATS_MAINPROC) <> 0)
#define symbSetIsMainProc(s) s->stats or= FB_SYMBSTATS_MAINPROC

#define symbGetIsModLevelProc(s) ((s->stats and FB_SYMBSTATS_MODLEVELPROC) <> 0)
#define symbSetIsModLevelProc(s) s->stats or= FB_SYMBSTATS_MODLEVELPROC

#define symbGetIsFuncPtr(s) ((s->stats and FB_SYMBSTATS_FUNCPTR) <> 0)
#define symbSetIsFuncPtr(s) s->stats or= FB_SYMBSTATS_FUNCPTR

#define symbGetIsJumpTb(s) ((s->stats and FB_SYMBSTATS_JUMPTB) <> 0)
#define symbSetIsJumpTb(s) s->stats or= FB_SYMBSTATS_JUMPTB

#define symbGetIsUnique(s) ((s->stats and FB_SYMBSTATS_CANTDUP) <> 0)
#define symbSetIsUnique(s) s->stats or= FB_SYMBSTATS_CANTDUP

#define symbGetHasRTTI(s) ((s->stats and FB_SYMBSTATS_HASRTTI) <> 0)
#define symbSetHasRTTI(s) s->stats or= FB_SYMBSTATS_HASRTTI

#define symbGetIsGlobalCtor(s) ((s->stats and FB_SYMBSTATS_GLOBALCTOR) <> 0)
#define symbSetIsGlobalCtor( s ) s->stats or= FB_SYMBSTATS_GLOBALCTOR or FB_SYMBSTATS_ACCESSED

#define symbGetIsGlobalDtor(s) ((s->stats and FB_SYMBSTATS_GLOBALDTOR) <> 0)
#define symbSetIsGlobalDtor( s ) s->stats or= FB_SYMBSTATS_GLOBALDTOR or FB_SYMBSTATS_ACCESSED

#define symbGetIsCtorInited(s) ((s->stats and FB_SYMBSTATS_CTORINITED) <> 0)
#define symbSetIsCtorInited(s) s->stats or= FB_SYMBSTATS_CTORINITED

#define symbGetCantUndef(s) ((s->stats and FB_SYMBSTATS_CANTUNDEF) <> 0)
#define symbSetCantUndef(s) s->stats or= FB_SYMBSTATS_CANTUNDEF

#define symbGetCanRedef(s) ((s->stats and FB_SYMBSTATS_CANREDEFINE) <> 0)
#define symbSetCanRedef(s) s->stats or= FB_SYMBSTATS_CANREDEFINE

#define symbGetIsFixLenStr(s) ((s->stats and FB_SYMBSTATS_FIXLENSTR) <> 0)
#define symbSetIsFixLenStr(s) (s)->stats or= FB_SYMBSTATS_FIXLENSTR

#define symbGetIsUnionField(s) ((s->stats and FB_SYMBSTATS_UNIONFIELD) <> 0)
#define symbSetIsUnionField(s) s->stats or= FB_SYMBSTATS_UNIONFIELD

#define symbGetIsEmitted(s) ((s->stats and FB_SYMBSTATS_EMITTED) <> 0)
#define symbSetIsEmitted(s) s->stats or= FB_SYMBSTATS_EMITTED

#define symbGetIsBeingEmitted(s) ((s->stats and FB_SYMBSTATS_BEINGEMITTED) <> 0)
#define symbSetIsBeingEmitted(s) s->stats or= FB_SYMBSTATS_BEINGEMITTED
#define symbResetIsBeingEmitted(s) s->stats and= not FB_SYMBSTATS_BEINGEMITTED

#define symbGetProcIsEmitted(s) ((s->stats and FB_SYMBSTATS_PROCEMITTED) <> 0)
#define symbSetProcIsEmitted(s) s->stats or= FB_SYMBSTATS_PROCEMITTED

#define symbGetIsTemporary(s) (((s)->stats and FB_SYMBSTATS_TEMPORARY) <> 0)
#define symbSetIsTemporary(s) (s)->stats or= FB_SYMBSTATS_TEMPORARY

#define symbGetStats(s) s->stats

#define symbGetSizeOf( s ) (s)->lgt

declare function symbGetStrLength( byval sym as FBSYMBOL ptr ) as longint
declare function symbGetWstrLength( byval sym as FBSYMBOL ptr ) as longint

#define symbGetFullType(s) s->typ
#define symbGetType(s) typeGetDtAndPtrOnly( symbGetFullType( s ) )

#define symbGetSubType(s) s->subtype

#define symbGetPtrCnt(s) typeGetPtrCnt( symbGetType( s ) )

#define symbGetClass(s) s->class

#define symbGetSymbtb(s) s->symtb

#define symbGetHashtb(s) s->hash.tb

#define symbGetParent(s) symbGetSymbtb(s)->owner

#define symbGetNamespace(s) symbGetHashtb(s)->owner

#define symbGetMangling(s) s->mangling

#define symbGetName(s) s->id.name

#define symbGetOfs(s) s->ofs

#define symbGetAttrib(s) s->attrib

#define symbGetPrev(s) s->prev

#define symbGetNext(s) s->next

#define symbChainGetNext(c) c->next

#define symbIsVar(s) (s->class = FB_SYMBCLASS_VAR)

#define symbIsConst(s) (s->class = FB_SYMBCLASS_CONST)

#define symbIsProc(s) (s->class = FB_SYMBCLASS_PROC)

#define symbIsDefine(s) (s->class = FB_SYMBCLASS_DEFINE)

#define symbIsKeyword(s) (s->class = FB_SYMBCLASS_KEYWORD)

#define symbIsLabel(s) (s->class = FB_SYMBCLASS_LABEL)

#define symbIsEnum(s) (s->class = FB_SYMBCLASS_ENUM)

#define symbIsStruct(s) (s->class = FB_SYMBCLASS_STRUCT)

#define symbIsField(s) (s->class = FB_SYMBCLASS_FIELD)

#define symbIsTypedef(s) (s->class = FB_SYMBCLASS_TYPEDEF)

#define symbIsFwdRef(s) (s->class = FB_SYMBCLASS_FWDREF)

#define symbIsScope(s) (s->class = FB_SYMBCLASS_SCOPE)

#define symbIsNameSpace(s) (s->class = FB_SYMBCLASS_NAMESPACE)

#define symbGetConstVal( sym )   (@((sym)->val.value))
#define symbGetConstStr( sym )   ((sym)->val.s)
#define symbGetConstInt( sym )   ((sym)->val.i)
#define symbGetConstFloat( sym ) ((sym)->val.f)

#define symbGetDefineText(d) d->def.text

#define symbGetDefineTextW(d) d->def.textw

#define symbGetDefineHeadToken(d) d->def.tokhead

#define symbGetDefTokPrev(t) t->prev

#define symbGetDefTokNext(t) t->next

#define symbGetDefTokType(t) t->type
#define symbSetDefTokType(t,_typ) t->type = _typ

#define symbGetDefTokText(t) t->text

#define symbGetDefTokTextW(t) t->textw

#define symbGetDefTokParamNum(t) t->paramnum
#define symbSetDefTokParamNum(t,n) t->paramnum = n

#define symbGetDefineParams(d) d->def.params

#define symbGetDefineHeadParam(d) d->def.paramhead

#define symbGetDefParamNext(a) a->next

#define symbGetDefParamName(a) a->name

#define symbGetDefParamNum(a) a->num

#define symbGetDefineCallback(d) d->def.dprocz

#define symbGetMacroCallbackZ(d) d->def.mprocz
#define symbGetMacroCallbackW(d) d->def.mprocw

#define symbGetDefineIsArgless(d) d->def.isargless

#define symbGetDefineFlags(d) d->def.flags

#define symbGetVarLitText(s) s->var_.littext

#define symbGetVarLitTextW(s) s->var_.littextw

#define symbGetVarStmt(s) s->var_.stmtnum

#define symbSetTypeIniTree(s, t) s->var_.initree = t
#define symbGetTypeIniTree(s) s->var_.initree

#define symbGetArrayDimensions( s )  ((s)->var_.array.dimensions)
#define symbGetArrayDim( s, i )      ((s)->var_.array.dimtb[i])
#define symbArrayLbound( s, i )      ((s)->var_.array.dimtb[i].lower)
#define symbArrayUbound( s, i )      ((s)->var_.array.dimtb[i].upper)
#define symbGetArrayDiff( s )        ((s)->var_.array.diff)
#define symbGetArrayElements( s )    ((s)->var_.array.elements)
#define symbGetArrayDescriptor( s )  ((s)->var_.array.desc)

#define symbFieldIsBitfield( s )     ((s)->var_.bits > 0)
#define symbIsBitfield( s ) _
	iif( symbIsField( s ), symbFieldIsBitfield( s ), FALSE )
#define symbGetFieldBitOffset( fld ) _
	((fld)->ofs * 8 + iif( (fld)->var_.bits > 0, (fld)->var_.bitpos, 0 ))
#define symbGetFieldBitLength( fld ) _
	iif( (fld)->var_.bits > 0, _
		clngint( (fld)->var_.bits ), _ '' clngint needed for older versions of fbc
		symbGetRealSize( fld ) * 8 )

#define symbGetUDTSymbTbHead(s) s->udt.ns.symtb.head

#define symbSetUDTIsUnion(s) (s)->udt.options or= FB_UDTOPT_ISUNION
#define symbGetUDTIsUnion(s) ((s->udt.options and FB_UDTOPT_ISUNION) <> 0)

#define symbSetUDTHasPtrField(s) s->udt.options or= FB_UDTOPT_HASPTRFIELD
#define symbGetUDTHasPtrField(s) ((s->udt.options and FB_UDTOPT_HASPTRFIELD) <> 0)

#define symbSetUDTHasCtorField(s) s->udt.options or= FB_UDTOPT_HASCTORFIELD
#define symbGetUDTHasCtorField(s) ((s->udt.options and FB_UDTOPT_HASCTORFIELD) <> 0)

#define symbSetUDTHasDtorField(s) s->udt.options or= FB_UDTOPT_HASDTORFIELD
#define symbGetUDTHasDtorField(s) ((s->udt.options and FB_UDTOPT_HASDTORFIELD) <> 0)

#define symbSetUDTIsAnon(s) (s)->udt.options or= FB_UDTOPT_ISANON
#define symbGetUDTIsAnon(s) ((s->udt.options and FB_UDTOPT_ISANON) <> 0)

#define symbGetUDTHasRecByvalParam(s) ((s->udt.options and FB_UDTOPT_HASRECBYVALPARAM) <> 0)
#define symbSetUDTHasRecByvalParam(s) s->udt.options or= FB_UDTOPT_HASRECBYVALPARAM

#define symbGetUDTHasRecByvalRes(s) ((s->udt.options and FB_UDTOPT_HASRECBYVALRES) <> 0)
#define symbSetUDTHasRecByvalRes(s) s->udt.options or= FB_UDTOPT_HASRECBYVALRES

#define symbGetUDTHasGetProp(s) ((s->udt.options and FB_UDTOPT_HASGETPROPERTY) <> 0)
#define symbSetUDTHasGetProp(s) s->udt.options or= FB_UDTOPT_HASGETPROPERTY

#define symbGetUDTHasSetProp(s) ((s->udt.options and FB_UDTOPT_HASSETPROPERTY) <> 0)
#define symbSetUDTHasSetProp(s) s->udt.options or= FB_UDTOPT_HASSETPROPERTY

#define symbGetUDTHasIdxGetProp(s) ((s->udt.options and FB_UDTOPT_HASIDXGETPROPERTY) <> 0)
#define symbSetUDTHasIdxGetProp(s) s->udt.options or= FB_UDTOPT_HASIDXGETPROPERTY

#define symbGetUDTHasIdxSetProp(s) ((s->udt.options and FB_UDTOPT_HASIDXSETPROPERTY) <> 0)
#define symbSetUDTHasIdxSetProp(s) s->udt.options or= FB_UDTOPT_HASIDXSETPROPERTY

#define symbGetUDTHasKwdField(s) ((s->udt.options and FB_UDTOPT_HASKWDFIELD) <> 0)
#define symbSetUDTHasKwdField(s) s->udt.options or= FB_UDTOPT_HASKWDFIELD

#define symbSetUDTHasInitedField( s ) (s)->udt.options or= FB_UDTOPT_HASINITEDFIELD
#define symbGetUDTHasInitedField( s ) (((s)->udt.options and FB_UDTOPT_HASINITEDFIELD) <> 0)

#define symbSetUDTHasAnonUnion( s ) (s)->udt.options or= FB_UDTOPT_HASANONUNION
#define symbGetUDTHasAnonUnion( s ) ((s->udt.options and FB_UDTOPT_HASANONUNION) <> 0)

#define symbSetUdtHasStaticVar( s )   (s)->udt.options or= FB_UDTOPT_HASSTATICVAR
#define symbGetUdtHasStaticVar( s ) (((s)->udt.options and FB_UDTOPT_HASSTATICVAR) <> 0)

#define symbSetUdtHasBitfield( s )   (s)->udt.options or= FB_UDTOPT_HASBITFIELD
#define symbGetUdtHasBitfield( s ) (((s)->udt.options and FB_UDTOPT_HASBITFIELD) <> 0)

#define symbSetUdtValistType( s, t )   (s)->udt.options or= (((t) shl 20) and FB_UDTOPT_VALISTTYPEMASK)
#define symbGetUdtValistType( s )    (((s)->udt.options and FB_UDTOPT_VALISTTYPEMASK) shr 20)

#define symbSetUdtIsZstring( s )   (s)->udt.options or= FB_UDTOPT_ISZSTRING
#define symbGetUdtIsZstring( s ) (((s)->udt.options and FB_UDTOPT_ISZSTRING) <> 0 )

#define symbSetUdtIsWstring( s )   (s)->udt.options or= FB_UDTOPT_ISWSTRING
#define symbGetUdtIsWstring( s ) (((s)->udt.options and FB_UDTOPT_ISWSTRING) <> 0 )

#define symbSetUdtHasNested( s )   (s)->udt.options or= FB_UDTOPT_HASNESTED
#define symbGetUdtHasNested( s ) (((s)->udt.options and FB_UDTOPT_HASNESTED) <> 0)

#define symbSetUDTHasZeroedField( s ) (s)->udt.options or= FB_UDTOPT_HASZEROEDFIELD
#define symbGetUDTHasZeroedField( s ) (((s)->udt.options and FB_UDTOPT_HASZEROEDFIELD) <> 0)

#define symbSetUDTHasFilledField( s ) (s)->udt.options or= FB_UDTOPT_HASFILLEDFIELD
#define symbGetUDTHasFilledField( s ) (((s)->udt.options and FB_UDTOPT_HASFILLEDFIELD) <> 0)

#define symbGetUDTIsUnionOrAnon(s) (((s)->udt.options and (FB_UDTOPT_ISUNION or FB_UDTOPT_ISANON)) <> 0)

#define symbGetUDTAlign(s) s->udt.align

#define symbGetUDTUnpadLen(s) s->udt.unpadlgt

#define symbGetUDTSymbTb(s) s->udt.ns.symtb

#define symbGetUDTHashTb(s) s->udt.ns.hashtb

#define symbGetUDTAnonParent(s) s->udt.anonparent

#define symbGetUDTRetType(s) s->udt.retdtype

#define symbGetUDTOpOvlTb(s) s->udt.ext->opovlTb

#define symbGetEnumSymbTbHead(s) s->enum_.ns.symtb.head
#define symbGetEnumElements(s) s->enum_.elements
#define symbEnumHasHashTb( s ) ((s)->enum_.ns.hashtb.tb.nodes <> 0)

#define symbGetScope(s) s->scope

#define symbGetScopeSymbTb(s) s->scp.symtb

#define symbGetScopeSymbTbHead(s) s->scp.symtb.head

#define symbGetNamespaceSymbTb(s) s->nspc.ns.symtb

#define symbGetNamespaceTbHead(s) s->nspc.ns.symtb.head

#define symbGetNamespaceTbTail(s) s->nspc.ns.symtb.tail

#define symbGetNamespaceHashTb(s) s->nspc.ns.hashtb

#define symbGetNamespaceCnt(s) s->nspc.cnt

#define symbGetNamespaceLastTail(s) s->nspc.last_tail

#define symbGetLabelIsDeclared(l) l->lbl.declared
#define symbSetLabelIsDeclared(l) l->lbl.declared = TRUE

#define symbGetLabelParent(l) l->lbl.parent

#define symbGetLabelStmt(s) s->lbl.stmtnum

#define symbGetProcParams(f) f->proc.params

#define symbGetProcOptParams(f) f->proc.optparams

#define symbGetProcMode(f) f->proc.mode

#define symbGetProcLastParam(f) iif( f->proc.mode = FB_FUNCMODE_PASCAL, f->proc.paramtb.tail, f->proc.paramtb.head )
#define symbGetProcPrevParam(f,a) iif( f->proc.mode = FB_FUNCMODE_PASCAL, a->prev, a->next )

#define symbGetProcHeadParam(f) f->proc.paramtb.head
#define symbGetProcTailParam(f) f->proc.paramtb.tail

#define symbGetProcCallback(f) f->proc.rtl.callback
#define symbSetProcCallback(f,cb) f->proc.rtl.callback = cb

#define symbGetProcIsOverloaded(f) ((f->pattrib and FB_PROCATTRIB_OVERLOADED) > 0)

#define symGetProcOvlMinParams(f) f->proc.ovl.minparams

#define symGetProcOvlMaxParams(f) f->proc.ovl.maxparams

#define symbGetProcIncFile(f) f->proc.ext->dbg.incfile

#define symbGetProcRealType( sym )    (sym)->proc.realdtype
#define symbGetProcRealSubtype( sym ) (sym)->proc.realsubtype
declare sub symbProcRecalcRealType( byval proc as FBSYMBOL ptr )

#define symbGetProcSymbTb(f) f->proc.symtb

#define symbGetProcSymbTbHead(f) f->proc.symtb.head

#define symbGetProcOvlNext(f) f->proc.ovl.next

#define symbGetProcStatReturnUsed(f) ((f->proc.ext->stats and FB_PROCSTATS_RETURNUSED) <> 0)
#define symbSetProcStatReturnUsed(f) f->proc.ext->stats or= FB_PROCSTATS_RETURNUSED

#define symbGetProcStatAssignUsed(f) ((f->proc.ext->stats and FB_PROCSTATS_ASSIGNUSED) <> 0)
#define symbSetProcStatAssignUsed(f) f->proc.ext->stats or= FB_PROCSTATS_ASSIGNUSED

#define symbGetProcPriority(f) f->proc.ext->priority

#macro symbSetProcPriority(f,p)
	symbProcAllocExt( f )
	f->proc.ext->priority = p
#endmacro

#define symbGetProcStatGosub(f) ((f->proc.ext->stats and FB_PROCSTATS_GOSUBUSED) <> 0)
#define symbSetProcStatGosub(f) f->proc.ext->stats or= FB_PROCSTATS_GOSUBUSED

#define symbGetProcGosubSym(f) f->proc.ext->gosub.ctx
#define symbSetProcGosubSym(f,p) f->proc.ext->gosub.ctx = p

#define symbGetProcLocalOfs(p) p->proc.ext->stk.localofs
#define symbSetProcLocalOfs(p,ofs) p->proc.ext->stk.localofs = ofs

#define symbGetProcOpOvl(f) f->proc.ext->opovl.op

#macro symbSetProcOpOvl(f, op_)
	symbProcAllocExt( f )
	f->proc.ext->opovl.op = op_
#endmacro

#define symbGetParamMode(a) a->param.mode

#define symbGetParamVar(a) a->param.var

#define symbGetParamOptExpr(a) a->param.optexpr

#define symbGetParamPrev(a) a->prev

#define symbGetParamNext(a) a->next

#define symbParamIsOptional( param_ ) ((param_)->param.optexpr <> NULL)

#define symbGetImportNamespc(s) s->nsimp.imp_ns

#define symbGetImportNext(s) s->nsimp.imp_next

#define symbGetExportNamespc(s) s->nsimp.exp_ns

#define symbGetExportNext(s) s->nsimp.exp_next

#define symbGetIsDynamic(s) ((s->attrib and (FB_SYMBATTRIB_DYNAMIC or FB_SYMBATTRIB_PARAMVARBYDESC)) <> 0 )

#define symbIsShared(s) ((s->attrib and FB_SYMBATTRIB_SHARED) <> 0)

#define symbIsStatic(s) ((s->attrib and FB_SYMBATTRIB_STATIC) <> 0)

#define symbIsDynamic(s) ((s->attrib and FB_SYMBATTRIB_DYNAMIC) <> 0)

#define symbIsCommon(s) ((s->attrib and FB_SYMBATTRIB_COMMON) <> 0)

#define symbIsTemp(s) ((s->attrib and FB_SYMBATTRIB_TEMP) <> 0)

#define symbIsParamVarByDesc(s) ((s->attrib and FB_SYMBATTRIB_PARAMVARBYDESC) <> 0)

#define symbIsParamVarByVal(s) ((s->attrib and FB_SYMBATTRIB_PARAMVARBYVAL) <> 0)

#define symbIsParamVarByRef(s) ((s->attrib and FB_SYMBATTRIB_PARAMVARBYREF) <> 0)

#define symbIsInstanceParam(s) ((s->attrib and FB_SYMBATTRIB_INSTANCEPARAM) <> 0)

#define symbIsParamVar(s) ((s->attrib and (FB_SYMBATTRIB_PARAMVARBYREF or FB_SYMBATTRIB_PARAMVARBYVAL or FB_SYMBATTRIB_PARAMVARBYDESC)) <> 0)

#define symbIsParamVarBydescOrByref(s) (((s)->attrib and (FB_SYMBATTRIB_PARAMVARBYDESC or FB_SYMBATTRIB_PARAMVARBYREF)) <> 0)

#define symbIsLocal(s) ((s->attrib and FB_SYMBATTRIB_LOCAL) <> 0)

#define symbIsPublic(s) ((s->attrib and FB_SYMBATTRIB_PUBLIC) <> 0)

#define symbIsPrivate(s) ((s->attrib and FB_SYMBATTRIB_PRIVATE) <> 0)

#define symbIsExtern(s) ((s->attrib and FB_SYMBATTRIB_EXTERN) <> 0)

#define symbIsExport(s) ((s->attrib and FB_SYMBATTRIB_EXPORT) <> 0)

#define symbIsImport(s) ((s->attrib and FB_SYMBATTRIB_IMPORT) <> 0)

#define symbIsOverloaded(s) ((s->pattrib and FB_PROCATTRIB_OVERLOADED) <> 0)

#define symbIsConstructor(s) ((s->pattrib and FB_PROCATTRIB_CONSTRUCTOR) <> 0)

#define symbIsDestructor1(s) ((s->pattrib and FB_PROCATTRIB_DESTRUCTOR1) <> 0)

#define symbIsDestructor0(s) ((s->pattrib and FB_PROCATTRIB_DESTRUCTOR0) <> 0)

#define symbIsOperator(s) ((s->pattrib and FB_PROCATTRIB_OPERATOR) <> 0)

#define symbIsProperty(s) ((s->pattrib and FB_PROCATTRIB_PROPERTY) <> 0)

#define symbIsMethod(s) ((s->pattrib and FB_PROCATTRIB_METHOD) <> 0)

#define symbIsDescriptor(s) ((s->attrib and FB_SYMBATTRIB_DESCRIPTOR) <> 0)

#define symbIsConstant(s) ((s->attrib and FB_SYMBATTRIB_CONST) <> 0)

#define symbGetIsLiteral(s) ((s->attrib and FB_SYMBATTRIB_LITERAL) <> 0)

#define symbIsRef(s) ((s->attrib and FB_SYMBATTRIB_REF) <> 0)

#define symbIsReturnByref(s) ((s->pattrib and FB_PROCATTRIB_RETURNBYREF) <> 0)

#define symbIsNaked( s ) (((s)->pattrib and FB_PROCATTRIB_NAKED) <> 0)

#define symbIsAbstract(s) ((s->pattrib and FB_PROCATTRIB_ABSTRACT) <> 0)

#define symbIsVirtual(s) ((s->pattrib and FB_PROCATTRIB_VIRTUAL) <> 0)

#define symbGetProcStaticLocals(s) ((s->pattrib and FB_PROCATTRIB_STATICLOCALS) <> 0)

#define symbIsSuffixed(s) ((s->attrib and FB_SYMBATTRIB_SUFFIXED) <> 0)

#define symbGetCurrentProcName( ) symbGetName( parser.currproc )

#define symbGetLastLabel( ) symb.lastlbl
#define symbSetLastLabel( l ) symb.lastlbl = l

'' assuming all UDT's extend FBS_NAMESPACE
#define symbCompAllocExt( ) listNewNode( @symb.nsextlist )

#define symbCompFreeExt( n ) listDelNode( @symb.nsextlist, n )

#define symbGetCompSymbTb( s ) symbGetNamespaceSymbTb( s )

#define symbGetCompHashTb( s ) symbGetNamespaceHashTb( s )

#define symbGetCompExt( s ) s->nspc.ns.ext

#define symbGetCompImportHead( s ) s->nspc.ns.ext->implist.head

#define symbGetCompExportHead( s ) s->nspc.ns.ext->explist.head

#define symbLookupCompField( parent, id ) symbLookupAt( parent, id, FALSE, TRUE )

'' datatype accessors

#define typeGetClass( dt ) symb_dtypeTB(typeGet( dt )).class
#define typeGetSize( dt ) symb_dtypeTB(typeGet( dt )).size
#define typeGetBits( dt ) (typeGetSize( dt ) * 8)
#define typeIsSigned( dt ) symb_dtypeTB(typeGet( dt )).signed
#define typeGetIntRank( dt ) symb_dtypeTB(typeGet( dt )).intrank
#define typeGetRemapType( dt ) symb_dtypeTB(typeGet( dt )).remaptype
#define typeGetSizeType( dt ) symb_dtypeTB(typeGet( dt )).sizetype

#define typeRemap( dtype ) typeJoin( dtype, symb_dtypeTB(dtype).remaptype )

#define typeGet( dt ) iif( dt and FB_DT_PTRMASK, FB_DATATYPE_POINTER, dt and FB_DT_TYPEMASK )
#define typeGetDtOnly( dt ) (dt and FB_DT_TYPEMASK)
#define typeGetDtAndPtrOnly( dt ) (dt and (FB_DT_TYPEMASK or FB_DT_PTRMASK))
#define typeGetDtPtrAndMangleDtOnly( dt ) (dt and (FB_DT_TYPEMASK or FB_DT_PTRMASK or FB_DT_MANGLEMASK))
#define typeJoin( dt, ndt ) ((dt and (not (FB_DT_TYPEMASK or FB_DT_PTRMASK))) or (ndt and (FB_DT_TYPEMASK or FB_DT_PTRMASK)))
#define typeJoinDtOnly( dt, ndt ) ((dt and (not FB_DT_TYPEMASK)) or (ndt and FB_DT_TYPEMASK))

#define typeAddrOf( dt ) _
	((dt and FB_DT_TYPEMASK) or _
	((dt and FB_DT_PTRMASK) + (1 shl FB_DT_PTRPOS)) or _
	((dt and FB_DT_CONSTMASK) shl 1) or _
	(dt and FB_DT_MANGLEMASK))

#define typeMultAddrOf( dt, cnt ) _
	((dt and FB_DT_TYPEMASK) or _
	((dt and FB_DT_PTRMASK) + (cnt shl FB_DT_PTRPOS)) or _
	((dt and FB_DT_CONSTMASK) shl cnt) or _
	(dt and FB_DT_MANGLEMASK))

#define typeDeref( dt ) _
	((dt and FB_DT_TYPEMASK) or _
	((dt and FB_DT_PTRMASK) - (1 shl FB_DT_PTRPOS)) or _
	(((dt and FB_DT_CONSTMASK) shr 1) and FB_DT_CONSTMASK) or _
	(dt and FB_DT_MANGLEMASK))

#define typeMultDeref( dt, cnt ) _
	((dt and FB_DT_TYPEMASK) or _
	((dt and FB_DT_PTRMASK) - (cnt shl FB_DT_PTRPOS)) or _
	(((dt and FB_DT_CONSTMASK) shr cnt) and FB_DT_CONSTMASK) or _
	(dt and FB_DT_MANGLEMASK))

#define typeIsPtr( dt ) (((dt and FB_DT_PTRMASK) <> 0))
#define typeGetPtrCnt( dt ) ((dt and FB_DT_PTRMASK) shr FB_DT_PTRPOS)

#define typeIsConstAt( dt, at ) ((dt and (1 shl (FB_DT_CONSTPOS + at))) <> 0)
#define typeIsConst( dt ) typeIsConstAt(dt, 0)
#define typeSetIsConst( dt ) (dt or (1 shl FB_DT_CONSTPOS))
#define typeUnsetIsConst( dt ) (dt and not (1 shl FB_DT_CONSTPOS))
#define typeGetConstMask( dt ) (dt and FB_DT_CONSTMASK)
#define typeGetPtrConstMask( dt ) _
	(typeGetConstMask( dt ) and not (1 shl FB_DT_CONSTPOS))

#define typeIsRef( dt ) ((dt and FB_DATATYPE_REFERENCE) <> 0)
#define typeSetIsRef( dt ) (dt or FB_DATATYPE_REFERENCE)
#define typeUnsetIsRef( dt ) (dt and not FB_DATATYPE_REFERENCE)

#define typeHasMangleDt( dt ) (((dt and FB_DT_MANGLEMASK) <> 0))
#define typeGetMangleDt( dt ) ((dt and FB_DT_MANGLEMASK) shr FB_DT_MANGLEPOS)
#define typeSetMangleDt( dt, mangle_dt ) ((dt and not FB_DT_MANGLEMASK) or ((mangle_dt shl FB_DT_MANGLEPOS) and FB_DT_MANGLEMASK ))

declare sub symbForEachGlobal _
	( _
		byval symclass as integer, _
		byval callback as sub( byval as FBSYMBOL ptr ) _
	)

#if (__FB_DEBUG__ <> 0) orelse defined(__GAS64_DEBUG__)
declare function typeDumpToStr _
	( _
		byval dtype as integer, _
		byval subtype as FBSYMBOL ptr, _
		byval verbose as boolean = false _
	) as string
'' For debugging, e.g. use like this:
''  symbTrace(a), "(replacing this)"
''  symbTrace(b), "(with this)"
#define symbTrace( s ) print __FUNCTION__ + "(" & __LINE__ & "): "; symbDumpToStr( s )

declare function symbDumpToStr _
	( _
		byval s as FBSYMBOL ptr, _
		byval verbose as boolean = false _
	) as string

declare sub symbDump( byval s as FBSYMBOL ptr, byval verbose as integer = 0 )
declare sub symbDumpNamespace( byval ns as FBSYMBOL ptr )
declare sub symbDumpChain( byval chain_ as FBSYMCHAIN ptr )
declare sub symbDumpLookup( byval id as zstring ptr )

'' FBARRAY: 6 pointer/integer fields + the dimTB with 3 integer fields per dimension
#define symbDescriptorHasRoomFor( sym, dimensions ) (symbGetSizeOf( sym ) >= env.pointersize * (((dimensions) * 3) + 6))
#endif

declare function symbDumpPrettyToStr( byval sym as FBSYMBOL ptr ) as string

''
'' inter-module globals
''
extern symb as SYMBCTX

extern symb_dtypeTB( 0 to FB_DATATYPES-1 ) as SYMB_DATATYPE

extern symb_dtypeMatchTB(FB_DATATYPE_FIRST_NUMERIC to FB_DATATYPE_LAST_NUMERIC, FB_DATATYPE_FIRST_NUMERIC to FB_DATATYPE_LAST_NUMERIC) as integer