fpc/compiler/symconst.pas
florian 7db13ea48f * some bugs fix:
- overload; with external procedures fixed
    - better selection of routine to do an overloaded
      type case
    - ... some more
2001-08-19 21:11:20 +00:00

534 lines
13 KiB
ObjectPascal

{
$Id$
Copyright (c) 1998-2000 by Florian Klaempfl, Pierre Muller
Symbol table constants
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 of the License, 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, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
****************************************************************************
}
unit symconst;
{$i defines.inc}
interface
const
def_alignment = 4;
{ if you change one of the following contants, }
{ you have also to change the typinfo unit}
{ and the rtl/i386,template/rttip.inc files }
tkUnknown = 0;
tkInteger = 1;
tkChar = 2;
tkEnumeration = 3;
tkFloat = 4;
tkSet = 5;
tkMethod = 6;
tkSString = 7;
tkString = tkSString;
tkLString = 8;
tkAString = 9;
tkWString = 10;
tkVariant = 11;
tkArray = 12;
tkRecord = 13;
tkInterface= 14;
tkClass = 15;
tkObject = 16;
tkWChar = 17;
tkBool = 18;
tkInt64 = 19;
tkQWord = 20;
tkDynArray = 21;
tkInterfaceCorba = 22;
otSByte = 0;
otUByte = 1;
otSWord = 2;
otUWord = 3;
otSLong = 4;
otULong = 5;
ftSingle = 0;
ftDouble = 1;
ftExtended = 2;
ftComp = 3;
ftCurr = 4;
mkProcedure= 0;
mkFunction = 1;
mkConstructor = 2;
mkDestructor = 3;
mkClassProcedure= 4;
mkClassFunction = 5;
pfvar = 1;
pfConst = 2;
pfArray = 4;
pfAddress = 8;
pfReference= 16;
pfOut = 32;
main_program_level = 1;
unit_init_level = 1;
normal_function_level = 2;
type
{ Deref entry options }
tdereftype = (derefnil,
derefaktrecordindex,
derefaktstaticindex,
derefunit,
derefrecord,
derefindex,
dereflocal,
derefpara,
derefaktlocal
);
{ symbol options }
tsymoption=(sp_none,
sp_public,
sp_private,
sp_published,
sp_protected,
sp_static,
sp_hint_deprecated,
sp_hint_platform,
sp_hint_library
{ is there any use for this constants }
{ else sp_has_overloaded can be moved up FK }
,sp_7
,sp_8
,sp_9
,sp_10
,sp_11
,sp_12
,sp_13
,sp_14
,sp_15
,sp_16
,sp_17
,sp_18
,sp_19
,sp_20
,sp_21
,sp_22
,sp_23
,sp_24
,sp_has_overloaded
);
tsymoptions=set of tsymoption;
{ flags for a definition }
tdefoption=(df_none,
df_need_rtti, { the definitions needs rtti }
df_has_rtti { the rtti is generated }
,df_3
,df_4
,df_5
,df_6
,df_7
,df_8
,df_9
,df_10
,df_11
,df_12
,df_13
,df_14
,df_15
,df_16
,df_17
,df_18
,df_19
,df_20
,df_21
,df_22
,df_23
,df_24
);
tdefoptions=set of tdefoption;
{ base types for orddef }
tbasetype = (
uauto,uvoid,uchar,
u8bit,u16bit,u32bit,
s8bit,s16bit,s32bit,
bool8bit,bool16bit,bool32bit,
u64bit,s64bit,uwidechar
);
{ float types }
tfloattype = (
s32real,s64real,s80real,
s64comp
);
{ string types }
tstringtype = (st_default,
st_shortstring, st_longstring, st_ansistring, st_widestring
);
{ set types }
tsettype = (
normset,smallset,varset
);
{ calling convention for tprocdef and tprocvardef }
tproccalloption=(pocall_none,
pocall_clearstack, { Use IBM flat calling convention. (Used by GCC.) }
pocall_leftright, { Push parameters from left to right }
pocall_cdecl, { procedure uses C styled calling }
pocall_register, { procedure uses register (fastcall) calling }
pocall_stdcall, { procedure uses stdcall call }
pocall_safecall, { safe call calling conventions }
pocall_palmossyscall, { procedure is a PalmOS system call }
pocall_system,
pocall_inline, { Procedure is an assembler macro }
pocall_internproc, { Procedure has compiler magic}
pocall_internconst, { procedure has constant evaluator intern }
pocall_cppdecl, { C++ calling conventions }
pocall_compilerproc { Procedure is used for internal compiler calls }
,pocall_14
,pocall_15
,pocall_16
,pocall_17
,pocall_18
,pocall_19
,pocall_20
,pocall_21
,pocall_22
,pocall_23
,pocall_24
);
tproccalloptions=set of tproccalloption;
{ basic type for tprocdef and tprocvardef }
tproctypeoption=(potype_none,
potype_proginit, { Program initialization }
potype_unitinit, { unit initialization }
potype_unitfinalize, { unit finalization }
potype_constructor, { Procedure is a constructor }
potype_destructor, { Procedure is a destructor }
potype_operator { Procedure defines an operator }
,potype_7
,potype_8
,potype_9
,potype_10
,potype_11
,potype_12
,potype_13
,potype_14
,potype_15
,potype_16
,potype_17
,potype_18
,potype_19
,potype_20
,potype_21
,potype_22
,potype_23
,potype_24
);
tproctypeoptions=set of tproctypeoption;
{ other options for tprocdef and tprocvardef }
tprocoption=(po_none,
po_classmethod, { class method }
po_virtualmethod, { Procedure is a virtual method }
po_abstractmethod, { Procedure is an abstract method }
po_staticmethod, { static method }
po_overridingmethod, { method with override directive }
po_methodpointer, { method pointer, only in procvardef, also used for 'with object do' }
po_containsself, { self is passed explicit to the compiler }
po_interrupt, { Procedure is an interrupt handler }
po_iocheck, { IO checking should be done after a call to the procedure }
po_assembler, { Procedure is written in assembler }
po_msgstr, { method for string message handling }
po_msgint, { method for int message handling }
po_exports, { Procedure has export directive (needed for OS/2) }
po_external, { Procedure is external (in other object or lib)}
po_savestdregs, { save std regs cdecl and stdcall need that ! }
po_saveregisters, { save all registers }
po_overload, { procedure is declared with overload directive }
po_varargs { printf like arguments }
,po_19
,po_20
,po_21
,po_22
,po_23
,po_24
);
tprocoptions=set of tprocoption;
{ options for objects and classes }
tobjectdeftype = (odt_none,
odt_class,
odt_object,
odt_interfacecom,
odt_interfacecorba,
odt_cppclass
);
{ options for objects and classes }
tobjectoption=(oo_none,
oo_is_forward, { the class is only a forward declared yet }
oo_has_virtual, { the object/class has virtual methods }
oo_has_private,
oo_has_protected,
oo_has_constructor, { the object/class has a constructor }
oo_has_destructor, { the object/class has a destructor }
oo_has_vmt, { the object/class has a vmt }
oo_has_msgstr,
oo_has_msgint,
oo_has_abstract, { the object/class has an abstract method => no instances can be created }
oo_can_have_published { the class has rtti, i.e. you can publish properties }
,oo_12
,oo_13
,oo_14
,oo_15
,oo_16
,oo_17
,oo_18
,oo_19
,oo_20
,oo_21
,oo_22
,oo_23
,oo_24
);
tobjectoptions=set of tobjectoption;
{ options for properties }
tpropertyoption=(ppo_none,
ppo_indexed,
ppo_defaultproperty,
ppo_stored,
ppo_hasparameters,
ppo_is_override
,ppo_6
,ppo_7
,ppo_8
,ppo_9
,ppo_10
,ppo_11
,ppo_12
,ppo_13
,ppo_14
,ppo_15
,ppo_16
,ppo_17
,ppo_18
,ppo_19
,ppo_20
,ppo_21
,ppo_22
,ppo_23
,ppo_24
);
tpropertyoptions=set of tpropertyoption;
{ options for variables }
tvaroption=(vo_none,
vo_regable,
vo_is_C_var,
vo_is_external,
vo_is_dll_var,
vo_is_thread_var,
vo_fpuregable,
vo_is_local_copy,
vo_is_const, { variable is declared as const (parameter) and can't be written to }
vo_is_exported
,vo_10
,vo_11
,vo_12
,vo_13
,vo_14
,vo_15
,vo_16
,vo_17
,vo_18
,vo_19
,vo_20
,vo_21
,vo_22
,vo_23
,vo_24
);
tvaroptions=set of tvaroption;
{ types of the symtables }
tsymtabletype = (abstractsymtable,
globalsymtable,staticsymtable,
objectsymtable,recordsymtable,
localsymtable,parasymtable,
withsymtable,stt_exceptsymtable,
{ used for inline detection }
inlineparasymtable,inlinelocalsymtable
);
{ definition contains the informations about a type }
tdeftype = (abstractdef,arraydef,recorddef,pointerdef,orddef,
stringdef,enumdef,procdef,objectdef,errordef,
filedef,formaldef,setdef,procvardef,floatdef,
classrefdef,forwarddef,variantdef);
{ possible types for symtable entries }
tsymtyp = (abstractsym,varsym,typesym,procsym,unitsym,
constsym,enumsym,typedconstsym,errorsym,syssym,
labelsym,absolutesym,propertysym,funcretsym,
macrosym);
{ State of the variable, if it's declared, assigned or used }
tvarstate=(vs_none,
vs_declared,vs_declared_and_first_found,
vs_set_but_first_not_passed,vs_assigned,vs_used
);
absolutetyp = (tovar,toasm,toaddr);
tconsttyp = (constnone,
constord,conststring,constreal,constbool,
constint,constchar,constset,constpointer,constnil,
constresourcestring,constwstring,constwchar
);
{$ifdef GDB}
type
tdefstabstatus = (
not_written,
being_written,
written);
const
tagtypes : Set of tdeftype =
[recorddef,enumdef,
{$IfNDef GDBKnowsStrings}
stringdef,
{$EndIf not GDBKnowsStrings}
{$IfNDef GDBKnowsFiles}
filedef,
{$EndIf not GDBKnowsFiles}
objectdef];
{$endif GDB}
const
{ relevant options for assigning a proc or a procvar to a procvar }
po_compatibility_options = [
po_classmethod,
po_staticmethod,
po_methodpointer,
po_containsself,
po_interrupt,
po_iocheck,
po_varargs,
po_exports
];
const
SymTypeName : array[tsymtyp] of string[12] =
('abstractsym','variable','type','proc','unit',
'const','enum','typed const','errorsym','system sym',
'label','absolute','property','funcret',
'macrosym');
implementation
end.
{
$Log$
Revision 1.22 2001-08-19 21:11:21 florian
* some bugs fix:
- overload; with external procedures fixed
- better selection of routine to do an overloaded
type case
- ... some more
Revision 1.21 2001/08/01 15:07:29 jonas
+ "compilerproc" directive support, which turns both the public and mangled
name to lowercase(declaration_name). This prevents a normal user from
accessing the routine, but they can still be easily looked up within
the compiler. This is used for helper procedures and should facilitate
the writing of more processor independent code in the code generator
itself (mostly written by Peter)
+ new "createintern" constructor for tcal nodes to create a call to
helper exported using the "compilerproc" directive
+ support for high(dynamic_array) using the the above new things
+ definition of 'HASCOMPILERPROC' symbol (to be able to check in the
compiler and rtl whether the "compilerproc" directive is supported)
Revision 1.20 2001/06/04 18:14:54 peter
* varargs added for proc to procvar comparison
Revision 1.19 2001/06/04 11:53:13 peter
+ varargs directive
Revision 1.18 2001/06/03 21:57:38 peter
+ hint directive parsing support
Revision 1.17 2001/05/08 21:06:31 florian
* some more support for widechars commited especially
regarding type casting and constants
Revision 1.16 2001/04/13 01:22:15 peter
* symtable change to classes
* range check generation and errors fixed, make cycle DEBUG=1 works
* memory leaks fixed
Revision 1.15 2001/04/02 21:20:34 peter
* resulttype rewrite
Revision 1.14 2001/03/22 00:10:58 florian
+ basic variant type support in the compiler
Revision 1.13 2001/02/26 19:44:55 peter
* merged generic m68k updates from fixes branch
Revision 1.12 2000/11/04 14:25:21 florian
+ merged Attila's changes for interfaces, not tested yet
Revision 1.11 2000/10/31 22:02:51 peter
* symtable splitted, no real code changes
Revision 1.9 2000/10/15 07:47:52 peter
* unit names and procedure names are stored mixed case
Revision 1.8 2000/10/14 10:14:52 peter
* moehrendorf oct 2000 rewrite
Revision 1.7 2000/09/24 15:06:28 peter
* use defines.inc
Revision 1.6 2000/08/21 11:27:44 pierre
* fix the stabs problems
Revision 1.5 2000/08/06 19:39:28 peter
* default parameters working !
Revision 1.4 2000/08/05 13:25:06 peter
* packenum 1 fixes (merged)
Revision 1.3 2000/07/13 12:08:27 michael
+ patched to 1.1.0 with former 1.09patch from peter
Revision 1.2 2000/07/13 11:32:49 michael
+ removed logs
}