symtab.h

<B>Digital的Unix操作系统VAX 4.2源码</B>

(*#@(#)symtab.h	4.1	Ultrix	7/17/90 *)
(****************************************************************************
 *									    *
 *  Copyright (c) 1984 by						    *
 *  DIGITAL EQUIPMENT CORPORATION, Maynard, Massachusetts.		    *
 *  All rights reserved.						    *
 * 									    *
 *  This software is furnished under a license and may be used and copied   *
 *  only in  accordance with  the  terms  of  such  license  and with the   *
 *  inclusion of the above copyright notice. This software or  any  other   *
 *  copies thereof may not be provided or otherwise made available to any   *
 *  other person.  No title to and ownership of  the  software is  hereby   *
 *  transferred.							    *
 * 									    *
 *  The information in this software is  subject to change without notice   *
 *  and  should  not  be  construed as  a commitment by DIGITAL EQUIPMENT   *
 *  CORPORATION.							    *
 * 									    *
 *  DIGITAL assumes no responsibility for the use  or  reliability of its   *
 *  software on equipment which is not supplied by DIGITAL.		    *
 * 									    *
$Header: symtab.h,v 1.6 84/06/06 13:02:40 powell Exp $
 ****************************************************************************)
const
    MAXBLOCKNUMBER = 1000;
    MAXDISPLAYLEVEL = 15;
    MAXSETSIZE = 1024;
    NULLLABEL = 9999;
    MAXLABEL = 50000;

    MAXTSTORAGE = 20;	{ 0..MAXTSTORAGE only for T's }
    NUMTEMPS = 20;	{ 20 CSE temps (number MAXTSTORAGE+1..MAXTEMPSTORAGE }
    MAXTEMPSTORAGE = 40;	{ storage for T's and CSE's }

    MAXBUILTINSCOPES = 100;

type

    BlockNumber = -2..MAXBLOCKNUMBER;
    DisplayLevel = 0..MAXDISPLAYLEVEL;
    MemoryOffset = cardinal;
    MemoryType = (MEMNONE, MEMABSOLUTE, MEMGLOBAL, MEMNORMAL, MEMFAST,
		    MEMPARAM);
    LabelNumber = NULLLABEL..MAXLABEL;
    TypeNumber = integer;
    OptIndex = integer;  { temporary hack to avoid needless recompilations }
    OptTime = integer;
    SymbolCase = (ONECASE,ANYCASE,SCOPECASE);
    EvalMode = (EVALGET, EVALPUT, EVALPOINT);
    CheckKind = (CHECKPTRPASCAL, CHECKPTRMODULA, CHECKPTRNIL, CHECKPTRNONE,
	    CHECKPTRC, CHECKRANGE, CHECKVARIANT, CHECKSUBSCR, CHECKSUBSCROPEN,
	    CHECKCASE);

{ pointers to things.  Defining them here reduces ordering constraints }
type
    Scope = ^ScopeRec;
    Symbol = ^SymbolRec;
    SymbolList = ^SymbolListRec;
    ConstNode = ^ConstNodeRec;
    TypeNode = ^TypeNodeRec;
    VarNode = ^VarNodeRec;
    VarList = ^VarListRec;
    FieldNode = ^FieldNodeRec;
    FieldList = ^FieldListRec;
    VariantNode = ^VariantNodeRec;
    VariantList = ^VariantListRec;
    ModuleNode = ^ModuleNodeRec;
    ModuleList = ^ModuleListRec;
    ProcNode = ^ProcNodeRec;
    ProcList = ^ProcListRec;
    ExprNode = ^ExprNodeRec;
    ExprList = ^ExprListRec;
    StmtNode = ^StmtNodeRec;
    StmtList = ^StmtListRec;
    CaseNode = ^CaseNodeRec;
    CaseList = ^CaseListRec;
    CaseTreeNode = ^CaseTreeNodeRec;
    EnumNode = ^EnumNodeRec;
    EnumList = ^EnumListRec;
    ConstSetNode = ^ConstSetNodeRec;
    ConstSetList = ^ConstSetListRec;
    ExprSetNode = ^ExprSetNodeRec;
    ExprSetList = ^ExprSetListRec;
    ParamNode = ^ParamNodeRec;
    ParamList = ^ParamListRec;
    IdentNode = ^IdentNodeRec;
    IdentList = ^IdentListRec;
    ImportNode = ^ImportNodeRec;
    ImportList = ^ImportListRec;
    SetValue = ^SetValueRec;
    CodeNode = ^CodeNodeRec;
    CodeList = ^CodeListRec;
    GlobalVarNode = ^GlobalVarNodeRec;
    GlobalVarList = ^GlobalVarListRec;
    AllocationNode = ^AllocationNodeRec;
    WithQualNode = ^WithQualNodeRec;
    TempMapNode = ^TempMapNodeRec;
    PortNode = ^PortNodeRec;
    PortList = ^PortListRec;


    AllocationNodeRec = record
	current, maximum : array [MEMNORMAL..MEMPARAM] of MemoryOffset;
    end;

    Address = record
	case kind : MemoryType of
	    MEMGLOBAL : (gvn : GlobalVarNode);
	    MEMNORMAL, MEMFAST, MEMPARAM : (
		level : DisplayLevel;
		proc : ProcNode;
		offset : MemoryOffset;
	    );
	    MEMABSOLUTE : (absolute : cardinal);
    end;

    TempMapNodeRec = record
	map : array [0..MAXTEMPSTORAGE] of MemoryOffset;
	numReg : integer;
    end;

    OptMarkTime = record
	time : OptTime;
	proc : ProcNode;
    end;
    
    ScopeRec = record
	block : BlockNumber;
	open : boolean;
	enclosing : Scope;
	symbols : SymbolList;
    end;

    SymbolKind = (SYMNULL, SYMVAR, SYMCONST, SYMPROC, SYMTYPE,
		SYMMODULE, SYMFIELD, SYMENUM);
    SymbolRec = record
	name : String;
	block : BlockNumber;
	symCase : SymbolCase;
	next : Symbol;
	nextInTable : Symbol;
	case kind : SymbolKind of
	    SYMCONST : (symConst : ConstNode);
	    SYMTYPE : (symType : TypeNode);
	    SYMVAR : (symVar : VarNode);
	    SYMMODULE : (symModule : ModuleNode);
	    SYMPROC : (symProc : ProcNode);
	    SYMFIELD : (symField : FieldNode);
	    SYMENUM : (symEnum : EnumNode);
    end;
    SymbolNode = Symbol;
    SymbolListRec = record
	next : SymbolList;
	first, last : SymbolNode;
    end;

    PortNodeRec = record
	next : PortNode;
	module : ModuleNode;
	sym : Symbol;
	qualified : boolean;
	export : boolean;
	extern : boolean;
    end;
    PortListRec = record
	next : PortList;
	first, last : PortNode;
    end;

    DataType = (DTNULL, DTPOINTER, DTRECORD, DTARRAY, DTINTEGER, DTBOOLEAN,
		DTCHAR, DTRENAME, DTSTRING, DTREAL, DTSET, DTCARDINAL, DTBYTE,
		DTSUBRANGE, DTENUMERATION, DTPROC, DTWORD, DTANY, DTLONGREAL,
		DTOPAQUE, DTPROCESS);
    ConstNodeRec = record
	next : ConstNode;
	case kind : DataType of
	    DTSTRING : (strVal : String);
	    DTCHAR : (charVal : integer);
	    DTINTEGER,
	    DTCARDINAL : (cardVal : cardinal);
	    DTBOOLEAN : (boolVal : boolean);
	    DTREAL, DTLONGREAL : (realVal : real);
	    DTSET : (setVal : SetValue);
	    DTENUMERATION : (enumVal : EnumNode);
	    DTPROC : (procVal : ProcNode);
    end;

    ArrayKind = (ARRAYNORMAL, ARRAYOPEN, ARRAYSUBARRAY, ARRAYDYNAMIC);
    TypeNodeRec = record
	next : TypeNode;
	size, alignment : cardinal;
	number : TypeNumber;
	markTime : OptMarkTime;
	name : String;		{ local name for type }
	module : ModuleNode;	{ definition module in which type was defined }
	opaqueName : String;	{ name if now or ever opaque type }
	case kind : DataType of
	    DTPOINTER : (toType : TypeNode; ptrCheck : CheckKind);
	    DTRECORD : (recScope : Scope; fieldList : FieldList);
	    DTSET : (setRange : TypeNode);
	    DTARRAY : (indexType : TypeNode; elementType : TypeNode;
			    nocount : boolean; arrayKind : ArrayKind);
	    DTRENAME : (renameType : TypeNode);
	    DTSUBRANGE : (subMinOrd, subMaxOrd : cardinal; baseType : TypeNode);
	    DTENUMERATION : (enumCount : integer; enumList : EnumList);
	    DTSTRING : (stringLength : integer);
	    DTPROC : (numParams : integer; paramList : ParamList;
			    funcType : TypeNode);
    end;

    FieldKind = (FIELDNORMAL, FIELDVARIANT);
    FieldNodeRec = record
	next : FieldNode;
	name : String;
	recType : TypeNode;
	fieldType : TypeNode;
	offset : MemoryOffset;
	containingVariant : VariantNode;
	case kind : FieldKind of
	FIELDVARIANT: (variantList : VariantList);
    end;
    FieldListRec = record
	next : FieldList;
	first, last : FieldNode;
    end;

    VariantNodeRec = record
	next : VariantNode;
	tag : ConstSetList;
	tagField : FieldNode;
	fieldList : FieldList;
    end;
    VariantListRec = record
	next : VariantList;
	first, last : VariantNode;
    end;

    EnumNodeRec = record
	next : EnumNode;
	name : String;
	enumSym : Symbol;
	enumType: TypeNode;
	enumOrd : integer;
    end;
    EnumListRec = record
	next : EnumList;
	first, last : EnumNode;
    end;

    VarNodeRec = record
	next : VarNode;
	name : String;
	readonly : boolean;
	changed : boolean;
	indirect : boolean;
	varType : TypeNode;
	address : Address;
	markTime : OptMarkTime;
    end;
    VarListRec = record
	next : VarList;
	first, last : VarNode;
    end;

    ModuleKind = (MODGLOBAL, MODPROGRAM, MODDEFINITION, MODIMPLEMENTATION);
    ModuleNodeRec = record
	next : ModuleNode;
	name : String;
	enclosing : ModuleNode;
	enclosingProc : ProcNode;
	kind : ModuleKind;
	unqualExports, qualExports : IdentList;
	imports : ImportList;
	doingImport : boolean;
	exportScope : Scope;
	procs : ProcList;
	modules : ModuleList;
	scope : Scope;
	body : StmtList;
    end;
    ModuleListRec = record
	next : ModuleList;
	first, last : ModuleNode;
    end;
    BuiltinProcType = (BIPNOTBIP, BIPABS, BIPCAP, BIPCHR, BIPDEC, BIPDISPOSE,
	BIPEXCL, BIPFLOAT, BIPHALT, BIPHIGH, BIPINC, BIPINCL, BIPNEW, BIPODD,
	BIPORD, BIPTRUNC, BIPVAL,
	BIPADR, BIPSIZE, BIPTSIZE, BIPBYTESIZE, BIPTBYTESIZE, BIPUNIXCALL,