unit uPSCompiler;

{$I PascalScript.inc}

interface

uses

{$IFNDEF DELPHI3UP}{$IFNDEF PS_NOINTERFACES}{$IFNDEF LINUX}Windows, Ole2,{$ENDIF}

{$ENDIF}{$ENDIF}SysUtils, uPSUtils;

type

{$IFNDEF PS_NOINTERFACES}

TPSInterface = class;

{$ENDIF}

TPSParameterMode = (pmIn, pmOut, pmInOut);

TPSPascalCompiler = class;

TPSType = class;

TPSValue = class;

TPSParameters = class;

TPSSubOptType = (tMainBegin, tProcBegin, tSubBegin, tOneLiner, tifOneliner, tRepeat, tTry, tTryEnd

{$IFDEF PS_USESSUPPORT},tUnitInit, tUnitFinish {$ENDIF}); //nvds

{TPSExternalClass is used when external classes need to be called}

TPSCompileTimeClass = class;

TPSAttributes = class;

TPSAttribute = class;

EPSCompilerException = class(Exception) end;

TPSParameterDecl = class(TObject)

private

FName: tbtString;

FOrgName: tbtString;

FMode: TPSParameterMode;

FType: TPSType;

{$IFDEF PS_USESSUPPORT}

FDeclareUnit: tbtString;

{$ENDIF}

FDeclarePos: Cardinal;

FDeclareRow: Cardinal;

FDeclareCol: Cardinal;

procedure SetName(const s: tbtString);

public

property Name: tbtString read FName;

property OrgName: tbtString read FOrgName write SetName;

property aType: TPSType read FType write FType;

property Mode: TPSParameterMode read FMode write FMode;

{$IFDEF PS_USESSUPPORT}

property DeclareUnit: tbtString read FDeclareUnit write FDeclareUnit;

{$ENDIF}

property DeclarePos: Cardinal read FDeclarePos write FDeclarePos;

property DeclareRow: Cardinal read FDeclareRow write FDeclareRow;

property DeclareCol: Cardinal read FDeclareCol write FDeclareCol;

end;

TPSParametersDecl = class(TObject)

private

FParams: TPSList;

FResult: TPSType;

function GetParam(I: Longint): TPSParameterDecl;

function GetParamCount: Longint;

public

property Params[I: Longint]: TPSParameterDecl read GetParam;

property ParamCount: Longint read GetParamCount;

function AddParam: TPSParameterDecl;

procedure DeleteParam(I: Longint);

property Result : TPSType read FResult write FResult;

procedure Assign(Params: TPSParametersDecl);

function Same(d: TPSParametersDecl): boolean;

constructor Create;

destructor Destroy; override;

end;

TPSRegProc = class(TObject)

private

FNameHash: Longint;

FName: tbtString;

FDecl: TPSParametersDecl;

FExportName: Boolean;

FImportDecl: tbtString;

FOrgName: tbtString;

procedure SetName(const Value: tbtString);

public

property OrgName: tbtString read FOrgName write FOrgName;

property Name: tbtString read FName write SetName;

property NameHash: Longint read FNameHash;

property Decl: TPSParametersDecl read FDecl;

property ExportName: Boolean read FExportName write FExportName;

property ImportDecl: tbtString read FImportDecl write FImportDecl;

constructor Create;

destructor Destroy; override;

end;

PIFPSRegProc = TPSRegProc;

PIfRVariant = ^TIfRVariant;

TIfRVariant = record

FType: TPSType;

case Byte of

1: (tu8: TbtU8);

2: (tS8: TbtS8);

3: (tu16: TbtU16);

4: (ts16: TbtS16);

5: (tu32: TbtU32);

6: (ts32: TbtS32);

7: (tsingle: TbtSingle);

8: (tdouble: TbtDouble);

9: (textended: TbtExtended);

11: (tcurrency: tbtCurrency);

10: (tstring: Pointer);

{$IFNDEF PS_NOINT64}

17: (ts64: Tbts64);

{$ENDIF}

19: (tchar: tbtChar);

{$IFNDEF PS_NOWIDESTRING}

18: (twidestring: Pointer);

20: (twidechar: tbtwidechar);

{$ENDIF}

21: (ttype: TPSType);

22: (tunistring: Pointer);

end;

TPSRecordFieldTypeDef = class(TObject)

private

FFieldOrgName: tbtString;

FFieldName: tbtString;

FFieldNameHash: Longint;

FType: TPSType;

procedure SetFieldOrgName(const Value: tbtString);

public

property FieldOrgName: tbtString read FFieldOrgName write SetFieldOrgName;

property FieldName: tbtString read FFieldName;

property FieldNameHash: Longint read FFieldNameHash;

property aType: TPSType read FType write FType;

end;

PIFPSRecordFieldTypeDef = TPSRecordFieldTypeDef;

TPSType = class(TObject)

private

FNameHash: Longint;

FName: tbtString;

FBaseType: TPSBaseType;

{$IFDEF PS_USESSUPPORT}

FDeclareUnit: tbtString;

{$ENDIF}

FDeclarePos: Cardinal;

FDeclareRow: Cardinal;

FDeclareCol: Cardinal;

FUsed: Boolean;

FExportName: Boolean;

FOriginalName: tbtString;

FAttributes: TPSAttributes;

FFinalTypeNo: cardinal;

procedure SetName(const Value: tbtString);

public

constructor Create;

destructor Destroy; override;

property Attributes: TPSAttributes read FAttributes;

property FinalTypeNo: cardinal read FFinalTypeNo;

property OriginalName: tbtString read FOriginalName write FOriginalName;

property Name: tbtString read FName write SetName;

property NameHash: Longint read FNameHash;

property BaseType: TPSBaseType read FBaseType write FBaseType;

{$IFDEF PS_USESSUPPORT}

property DeclareUnit: tbtString read FDeclareUnit write FDeclareUnit;

{$ENDIF}

property DeclarePos: Cardinal read FDeclarePos write FDeclarePos;

property DeclareRow: Cardinal read FDeclareRow write FDeclareRow;

property DeclareCol: Cardinal read FDeclareCol write FDeclareCol;

property Used: Boolean read FUsed;

property ExportName: Boolean read FExportName write FExportName;

procedure Use;

end;

PIFPSType = TPSType;

TPSVariantType = class(TPSType)

private

public

function GetDynInvokeProcNo(Owner: TPSPascalCompiler; const Name: tbtString; Params: TPSParameters): Cardinal; virtual;

function GetDynIvokeSelfType(Owner: TPSPascalCompiler): TPSType; virtual;

function GetDynInvokeParamType(Owner: TPSPascalCompiler): TPSType; virtual;

function GetDynIvokeResulType(Owner: TPSPascalCompiler): TPSType; virtual;

end;

TPSRecordType = class(TPSType)

private

FRecordSubVals: TPSList;

public

constructor Create;

destructor Destroy; override;

function RecValCount: Longint;

function RecVal(I: Longint): PIFPSRecordFieldTypeDef;

function AddRecVal: PIFPSRecordFieldTypeDef;

end;

TPSClassType = class(TPSType)

private

FCL: TPSCompiletimeClass;

public

property Cl: TPSCompileTimeClass read FCL write FCL;

end;

TPSExternalClass = class;

TPSUndefinedClassType = class(TPSType)

private

FExtClass: TPSExternalClass;

public

property ExtClass: TPSExternalClass read FExtClass write FExtClass;

end;

{$IFNDEF PS_NOINTERFACES}

TPSInterfaceType = class(TPSType)

private

FIntf: TPSInterface;

public

property Intf: TPSInterface read FIntf write FIntf;

end;

{$ENDIF}

TPSProceduralType = class(TPSType)

private

FProcDef: TPSParametersDecl;

public

property ProcDef: TPSParametersDecl read FProcDef;

constructor Create;

destructor Destroy; override;

end;

TPSArrayType = class(TPSType)

private

FArrayTypeNo: TPSType;

public

property ArrayTypeNo: TPSType read FArrayTypeNo write FArrayTypeNo;

end;

TPSStaticArrayType = class(TPSArrayType)

private

FStartOffset: Longint;

FLength: Cardinal;

public

property StartOffset: Longint read FStartOffset write FStartOffset;

property Length: Cardinal read FLength write FLength;

end;

TPSSetType = class(TPSType)

private

FSetType: TPSType;

function GetByteSize: Longint;

function GetBitSize: Longint;

public

property SetType: TPSType read FSetType write FSetType;

property ByteSize: Longint read GetByteSize;

property BitSize: Longint read GetBitSize;

end;

TPSTypeLink = class(TPSType)

private

FLinkTypeNo: TPSType;

public

property LinkTypeNo: TPSType read FLinkTypeNo write FLinkTypeNo;

end;

TPSEnumType = class(TPSType)

private

FHighValue: Cardinal;

public

property HighValue: Cardinal read FHighValue write FHighValue;

end;

TPSProcedure = class(TObject)

private

FAttributes: TPSAttributes;

public

property Attributes: TPSAttributes read FAttributes;

constructor Create;

destructor Destroy; override;

end;

TPSAttributeType = class;

TPSAttributeTypeField = class(TObject)

private

FOwner: TPSAttributeType;

FFieldOrgName: tbtString;

FFieldName: tbtString;

FFieldNameHash: Longint;

FFieldType: TPSType;

FHidden: Boolean;

procedure SetFieldOrgName(const Value: tbtString);

public

constructor Create(AOwner: TPSAttributeType);

property Owner: TPSAttributeType read FOwner;

property FieldOrgName: tbtString read FFieldOrgName write SetFieldOrgName;

property FieldName: tbtString read FFieldName;

property FieldNameHash: Longint read FFieldNameHash;

property FieldType: TPSType read FFieldType write FFieldType;

property Hidden: Boolean read FHidden write FHidden;

end;

TPSApplyAttributeToType = function (Sender: TPSPascalCompiler; aType: TPSType; Attr: TPSAttribute): Boolean;

TPSApplyAttributeToProc = function (Sender: TPSPascalCompiler; aProc: TPSProcedure; Attr: TPSAttribute): Boolean;

{ An attribute type }

TPSAttributeType = class(TPSType)

private

FFields: TPSList;

FName: tbtString;

FOrgname: tbtString;

FNameHash: Longint;

FAAProc: TPSApplyAttributeToProc;

FAAType: TPSApplyAttributeToType;

function GetField(I: Longint): TPSAttributeTypeField;

function GetFieldCount: Longint;

procedure SetName(const s: tbtString);

public

property OnApplyAttributeToType: TPSApplyAttributeToType read FAAType write FAAType;

property OnApplyAttributeToProc: TPSApplyAttributeToProc read FAAProc write FAAProc;

property Fields[i: Longint]: TPSAttributeTypeField read GetField;

property FieldCount: Longint read GetFieldCount;

procedure DeleteField(I: Longint);

function AddField: TPSAttributeTypeField;

property Name: tbtString read FName;

property OrgName: tbtString read FOrgName write SetName;

property NameHash: Longint read FNameHash;

constructor Create;

destructor Destroy; override;

end;

TPSAttribute = class(TObject)

private

FAttribType: TPSAttributeType;

FValues: TPSList;

{$IFDEF PS_USESSUPPORT}

FDeclareUnit: tbtString;

{$ENDIF}

FDeclarePos: Cardinal;

FDeclareRow: Cardinal;

FDeclareCol: Cardinal;

function GetValueCount: Longint;

function GetValue(I: Longint): PIfRVariant;

public

constructor Create(AttribType: TPSAttributeType);

procedure Assign(Item: TPSAttribute);

property AType: TPSAttributeType read FAttribType;

property Count: Longint read GetValueCount;

property Values[i: Longint]: PIfRVariant read GetValue; default;

{$IFDEF PS_USESSUPPORT}

property DeclareUnit: tbtString read FDeclareUnit write FDeclareUnit;

{$ENDIF}

property DeclarePos: Cardinal read FDeclarePos write FDeclarePos;

property DeclareRow: Cardinal read FDeclareRow write FDeclareRow;

property DeclareCol: Cardinal read FDeclareCol write FDeclareCol;

procedure DeleteValue(i: Longint);

function AddValue(v: PIFRVariant): Longint;

destructor Destroy; override;

end;

TPSAttributes = class(TObject)

private

FItems: TPSList;

function GetCount: Longint;

function GetItem(I: Longint): TPSAttribute;

public

procedure Assign(attr: TPSAttributes; Move: Boolean);

property Count: Longint read GetCount;

property Items[i: Longint]: TPSAttribute read GetItem; default;

procedure Delete(i: Longint);

function Add(AttribType: TPSAttributeType): TPSAttribute;

function FindAttribute(const Name: tbtString): TPSAttribute;

constructor Create;

destructor Destroy; override;

end;

TPSProcVar = class(TObject)

private

FNameHash: Longint;

FName: tbtString;

FOrgName: tbtString;

FType: TPSType;

FUsed: Boolean;

{$IFDEF PS_USESSUPPORT}

FDeclareUnit: tbtString;

{$ENDIF}

FDeclarePos, FDeclareRow, FDeclareCol: Cardinal;

procedure SetName(const Value: tbtString);

public

property OrgName: tbtString read FOrgName write FOrgname;

property NameHash: Longint read FNameHash;

property Name: tbtString read FName write SetName;

property AType: TPSType read FType write FType;

property Used: Boolean read FUsed;

{$IFDEF PS_USESSUPPORT}

property DeclareUnit: tbtString read FDeclareUnit write FDeclareUnit;

{$ENDIF}

property DeclarePos: Cardinal read FDeclarePos write FDeclarePos;

property DeclareRow: Cardinal read FDeclareRow write FDeclareRow;

property DeclareCol: Cardinal read FDeclareCol write FDeclareCol;

procedure Use;

end;

PIFPSProcVar = TPSProcVar;

TPSExternalProcedure = class(TPSProcedure)

private

FRegProc: TPSRegProc;

public

property RegProc: TPSRegProc read FRegProc write FRegProc;

end;

TPSInternalProcedure = class(TPSProcedure)

private

FForwarded: Boolean;

FData: tbtString;

FNameHash: Longint;

FName: tbtString;

FDecl: TPSParametersDecl;

FProcVars: TPSList;

FUsed: Boolean;

FOutputDeclPosition: Cardinal;

FResultUsed: Boolean;

FLabels: TIfStringList;

FGotos: TIfStringList;

FDeclareRow: Cardinal;

{$IFDEF PS_USESSUPPORT}

FDeclareUnit: tbtString;

{$ENDIF}

FDeclarePos: Cardinal;

FDeclareCol: Cardinal;

FOriginalName: tbtString;

procedure SetName(const Value: tbtString);

public

constructor Create;

destructor Destroy; override;

{Attributes}

property Forwarded: Boolean read FForwarded write FForwarded;

property Data: tbtString read FData write FData;

property Decl: TPSParametersDecl read FDecl;

property OriginalName: tbtString read FOriginalName write FOriginalName;

property Name: tbtString read FName write SetName;

property NameHash: Longint read FNameHash;

property ProcVars: TPSList read FProcVars;

property Used: Boolean read FUsed;

{$IFDEF PS_USESSUPPORT}

property DeclareUnit: tbtString read FDeclareUnit write FDeclareUnit;

{$ENDIF}

property DeclarePos: Cardinal read FDeclarePos write FDeclarePos;

property DeclareRow: Cardinal read FDeclareRow write FDeclareRow;

property DeclareCol: Cardinal read FDeclareCol write FDeclareCol;

property OutputDeclPosition: Cardinal read FOutputDeclPosition write FOutputDeclPosition;

property ResultUsed: Boolean read FResultUsed;

property Labels: TIfStringList read FLabels;

property Gotos: TIfStringList read FGotos;

procedure Use;

procedure ResultUse;

end;

TPSVar = class(TObject)

private

FNameHash: Longint;

FOrgName: tbtString;

FName: tbtString;

FType: TPSType;

FUsed: Boolean;

FExportName: tbtString;

FDeclareRow: Cardinal;

{$IFDEF PS_USESSUPPORT}

FDeclareUnit: tbtString;

{$ENDIF}

FDeclarePos: Cardinal;

FDeclareCol: Cardinal;

FSaveAsPointer: Boolean;

procedure SetName(const Value: tbtString);

public

property SaveAsPointer: Boolean read FSaveAsPointer write FSaveAsPointer;

property ExportName: tbtString read FExportName write FExportName;

property Used: Boolean read FUsed;

property aType: TPSType read FType write FType;

property OrgName: tbtString read FOrgName write FOrgName;

property Name: tbtString read FName write SetName;

property NameHash: Longint read FNameHash;

{$IFDEF PS_USESSUPPORT}

property DeclareUnit: tbtString read FDeclareUnit write FDeclareUnit;

{$ENDIF}

property DeclarePos: Cardinal read FDeclarePos write FDeclarePos;

property DeclareRow: Cardinal read FDeclareRow write FDeclareRow;

property DeclareCol: Cardinal read FDeclareCol write FDeclareCol;

procedure Use;

end;

PIFPSVar = TPSVar;

TPSConstant = class(TObject)

private

FOrgName: tbtString;

FNameHash: Longint;

FName: tbtString;

FDeclareRow: Cardinal;

{$IFDEF PS_USESSUPPORT}

FDeclareUnit: tbtString;

{$ENDIF}

FDeclarePos: Cardinal;

FDeclareCol: Cardinal;

FValue: PIfRVariant;

procedure SetName(const Value: tbtString);

public

property OrgName: tbtString read FOrgName write FOrgName;

property Name: tbtString read FName write SetName;

property NameHash: Longint read FNameHash;

property Value: PIfRVariant read FValue write FValue;

{$IFDEF PS_USESSUPPORT}

property DeclareUnit: tbtString read FDeclareUnit write FDeclareUnit;

{$ENDIF}

property DeclarePos: Cardinal read FDeclarePos write FDeclarePos;

property DeclareRow: Cardinal read FDeclareRow write FDeclareRow;

property DeclareCol: Cardinal read FDeclareCol write FDeclareCol;

procedure SetSet(const val);

procedure SetInt(const Val: Longint);

procedure SetUInt(const Val: Cardinal);

{$IFNDEF PS_NOINT64}

procedure SetInt64(const Val: Int64);

{$ENDIF}

procedure SetString(const Val: tbtString);

procedure SetChar(c: tbtChar);

{$IFNDEF PS_NOWIDESTRING}

procedure SetWideChar(const val: WideChar);

procedure SetWideString(const val: tbtwidestring);

procedure SetUnicodeString(const val: tbtunicodestring);

{$ENDIF}

procedure SetExtended(const Val: Extended);

destructor Destroy; override;

end;

PIFPSConstant = TPSConstant;

TPSPascalCompilerErrorType = (

ecUnknownIdentifier,

ecIdentifierExpected,

ecCommentError,

ecStringError,

ecCharError,

ecSyntaxError,

ecUnexpectedEndOfFile,

ecSemicolonExpected,

ecBeginExpected,

ecPeriodExpected,

ecDuplicateIdentifier,

ecColonExpected,

ecUnknownType,

ecCloseRoundExpected,

ecTypeMismatch,

ecInternalError,

ecAssignmentExpected,

ecThenExpected,

ecDoExpected,

ecNoResult,

ecOpenRoundExpected,

ecCommaExpected,

ecToExpected,

ecIsExpected,

ecOfExpected,

ecCloseBlockExpected,

ecVariableExpected,

ecStringExpected,

ecEndExpected,

ecUnSetLabel,

ecNotInLoop,

ecInvalidJump,

ecOpenBlockExpected,

ecWriteOnlyProperty,

ecReadOnlyProperty,

ecClassTypeExpected,

ecCustomError,

ecDivideByZero,

ecMathError,

ecUnsatisfiedForward,

ecForwardParameterMismatch,

ecInvalidnumberOfParameters

{$IFDEF PS_USESSUPPORT}

, ecNotAllowed,

ecUnitNotFoundOrContainsErrors,

ecCrossReference

{$ENDIF}

, ecUnClosedAttributes

);

TPSPascalCompilerHintType = (

ehVariableNotUsed,

ehFunctionNotUsed,

ehCustomHint

);

TPSPascalCompilerWarningType = (

ewCalculationAlwaysEvaluatesTo,

ewIsNotNeeded,

ewAbstractClass,

ewCustomWarning

);

TPSPascalCompilerMessage = class(TObject)

protected

FRow: Cardinal;

FCol: Cardinal;

FModuleName: tbtString;

FParam: tbtString;

FPosition: Cardinal;

procedure SetParserPos(Parser: TPSPascalParser);

public

property ModuleName: tbtString read FModuleName write FModuleName;

property Param: tbtString read FParam write FParam;

property Pos: Cardinal read FPosition write FPosition;

property Row: Cardinal read FRow write FRow;

property Col: Cardinal read FCol write FCol;

function ErrorType: tbtString; virtual; abstract;

procedure SetCustomPos(Pos, Row, Col: Cardinal);

function MessageToString: tbtString; virtual;

function ShortMessageToString: tbtString; virtual; abstract;

end;

TPSPascalCompilerError = class(TPSPascalCompilerMessage)

protected

FError: TPSPascalCompilerErrorType;

public

property Error: TPSPascalCompilerErrorType read FError;

function ErrorType: tbtString; override;

function ShortMessageToString: tbtString; override;

end;

TPSPascalCompilerHint = class(TPSPascalCompilerMessage)

protected

FHint: TPSPascalCompilerHintType;

public

property Hint: TPSPascalCompilerHintType read FHint;

function ErrorType: tbtString; override;

function ShortMessageToString: tbtString; override;

end;

TPSPascalCompilerWarning = class(TPSPascalCompilerMessage)

protected

FWarning: TPSPascalCompilerWarningType;

public

property Warning: TPSPascalCompilerWarningType read FWarning;

function ErrorType: tbtString; override;

function ShortMessageToString: tbtString; override;

end;

TPSDuplicCheck = set of (dcTypes, dcProcs, dcVars, dcConsts);

TPSBlockInfo = class(TObject)

private

FOwner: TPSBlockInfo;

FWithList: TPSList;

FProcNo: Cardinal;

FProc: TPSInternalProcedure;

FSubType: TPSSubOptType;

public

property WithList: TPSList read FWithList;

property ProcNo: Cardinal read FProcNo write FProcNo;

property Proc: TPSInternalProcedure read FProc write FProc;

property SubType: TPSSubOptType read FSubType write FSubType;

procedure Clear;

constructor Create(Owner: TPSBlockInfo);

destructor Destroy; override;

end;

TPSBinOperatorType = (otAdd, otSub, otMul, otDiv, otMod, otShl, otShr, otAnd, otOr, otXor, otAs, otIntDiv,

otGreaterEqual, otLessEqual, otGreater, otLess, otEqual,

otNotEqual, otIs, otIn);

TPSUnOperatorType = (otNot, otMinus, otCast);

TPSOnUseVariable = procedure (Sender: TPSPascalCompiler; VarType: TPSVariableType; VarNo: Longint; ProcNo, Position: Cardinal; const PropData: tbtString);

TPSOnUseRegProc = procedure (Sender: TPSPascalCompiler; Position: Cardinal; const Name: tbtString);

TPSOnUses = function(Sender: TPSPascalCompiler; const Name: tbtString): Boolean;

TPSOnExportCheck = function(Sender: TPSPascalCompiler; Proc: TPSInternalProcedure; const ProcDecl: tbtString): Boolean;

{$IFNDEF PS_USESSUPPORT}

TPSOnWriteLineEvent = function (Sender: TPSPascalCompiler; Position: Cardinal): Boolean;

TPSOnWriteLine2Event = function (Sender: TPSPascalCompiler; Position: Cardinal; IsProcExit: Boolean): Boolean;

{$ELSE}

TPSOnWriteLineEvent = function (Sender: TPSPascalCompiler; FileName: tbtString; Position: Cardinal): Boolean;

TPSOnWriteLine2Event = function (Sender: TPSPascalCompiler; FileName: tbtString; Position: Cardinal; IsProcExit: Boolean): Boolean;

{$ENDIF}

TPSOnExternalProc = function (Sender: TPSPascalCompiler; Decl: TPSParametersDecl; const Name, FExternal: tbtString): TPSRegProc;

TPSOnTranslateLineInfoProc = procedure (Sender: TPSPascalCompiler; var Pos, Row, Col: Cardinal; var Name: tbtString);

TPSOnNotify = function (Sender: TPSPascalCompiler): Boolean;

TPSOnFunction = procedure(name: tbtString; Pos, Row, Col: Integer) of object;

TPSPascalCompiler = class

protected

FAnyString: TPSType;

FAnyMethod: TPSType;

FUnitName: tbtString;

FID: Pointer;

FOnExportCheck: TPSOnExportCheck;

FDefaultBoolType: TPSType;

FRegProcs: TPSList;

FConstants: TPSList;

FProcs: TPSList;

FTypes: TPSList;

FAttributeTypes: TPSList;

FVars: TPSList;

FOutput: tbtString;

FParser: TPSPascalParser;

FParserHadError: Boolean;

FMessages: TPSList;

FOnUses: TPSOnUses;

FUtf8Decode: Boolean;

FIsUnit: Boolean;

FAllowNoBegin: Boolean;

FAllowNoEnd: Boolean;

FAllowUnit: Boolean;

FAllowDuplicateRegister : Boolean;

FBooleanShortCircuit: Boolean;

FDebugOutput: tbtString;

FOnExternalProc: TPSOnExternalProc;

FOnUseVariable: TPSOnUseVariable;

FOnUseRegProc: TPSOnUseRegProc;

FOnBeforeOutput: TPSOnNotify;

FOnBeforeCleanup: TPSOnNotify;

FOnWriteLine: TPSOnWriteLineEvent;

FOnWriteLine2: TPSOnWriteLine2Event;

FContinueOffsets, FBreakOffsets: TPSList;

FOnTranslateLineInfo: TPSOnTranslateLineInfoProc;

FAutoFreeList: TPSList;

FClasses: TPSList;

FOnFunctionStart: TPSOnFunction;

FOnFunctionEnd: TPSOnFunction;

FAttributesOpenTokenID, FAttributesCloseTokenID: TPsPasToken;

FWithCount: Integer;

FTryCount: Integer;

FExceptFinallyCount: Integer;

{$IFDEF PS_USESSUPPORT}

FUnitInits : TPSList; //nvds

FUnitFinits: TPSList; //nvds

FUses : TPSStringList;

fUnits : TPSUnitList;

fUnit : TPSUnit;

fModule : tbtString;

{$ENDIF}

fInCompile : Integer;

{$IFNDEF PS_NOINTERFACES}

FInterfaces: TPSList;

{$ENDIF}

FCurrUsedTypeNo: Cardinal;

FGlobalBlock: TPSBlockInfo;

function IsBoolean(aType: TPSType): Boolean;

{$IFNDEF PS_NOWIDESTRING}

function GetWideString(Src: PIfRVariant; var s: Boolean): tbtwidestring;

function GetUnicodeString(Src: PIfRVariant; var s: Boolean): tbtunicodestring;

{$ENDIF}

function PreCalc(FUseUsedTypes: Boolean; Var1Mod: Byte; var1: PIFRVariant; Var2Mod: Byte;

Var2: PIfRVariant; Cmd: TPSBinOperatorType; Pos, Row, Col: Cardinal): Boolean;

function FindBaseType(BaseType: TPSBaseType): TPSType;

function IsIntBoolType(aType: TPSType): Boolean;

function GetTypeCopyLink(p: TPSType): TPSType;