freepascal.compiler/compiler/symconst.pas

{
    $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;
  ftFixed16  = 5;
  ftFixed32  = 6;

  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_primary_typesym    { this is for typesym, to know who is the primary symbol of a def }
{$ifdef tp}
    ,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
{$endif}
  );
  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      }
{$ifdef tp}
    ,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
{$endif}
  );
  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,
    f16bit,f32bit
  );

  { 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_13
    ,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_18
    ,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 = (invalidsymtable,withsymtable,staticsymtable,
                   globalsymtable,unitsymtable,
                   objectsymtable,recordsymtable,
                   macrosymtable,localsymtable,
                   parasymtable,inlineparasymtable,
                   inlinelocalsymtable,stt_exceptsymtable,
                   { only used for PPU reading of static part
                     of a unit }
                   staticppusymtable);


  { 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
  );

{$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_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.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

}