unit TeeCodeStream;

{$IF CompilerVersion >= 17.0}

{$DEFINE HAS_INLINE}

{$DEFINE D9}

{$ENDIF}

Classes, TeeCode;

TCodeWriter=class(TWriter)

private

Package : TPackage;

procedure WriteAs(const ABlock: TBlock; const ID:Integer);

procedure WriteBlocks(const AModule:TModule);

procedure WriteIdentifierNames(const AIdents:TIdentifiers);

public

Constructor Create(const AStream: TStream);

class procedure WriteToFile(const AModule:TModule; const AFileName:String); overload;

class procedure WriteToFile(const APackage:TPackage; const AFileName:String); overload;

end;

TCodeReader=class(TReader)

private

Module : TModule;

Package : TPackage;

CurrentDir : String;

procedure ReadAs(const ABlock: TBlock; const ID:Integer);

procedure ReadBlocks(const AModule:TModule);

public

Constructor Create(const AStream: TStream);

class procedure ReadFromFile(const AModule:TModule; const AFileName:String); overload;

class procedure ReadFromFile(const APackage:TPackage; const AFileName:String); overload;

end;

{$IFOPT D+}

Windows,

{$ENDIF}

TeePascal, // <-- Due to TDirectiveKind

SysUtils;

Version=1;

CompatibleWith=1;

TeeSignature='TEE';

DefaultBufferSize=16384;

IDs : TBaseList=nil;

TUnit_ID =0;

TInterface_ID =1;

TUses_ID =2;

TConstantDeclarations_ID =3;

TConstantDeclaration_ID =4;

TUnitScope_ID =5;

TDirective_ID =6;

TMethodDeclarations_ID = 7;

TVariableDeclarations_ID = 8;

TTypeDeclarations_ID = 9;

TArraySpecification_ID = 10;

TNumber_ID = 11;

TString_ID = 12;

TMethodDeclaration_ID = 13;

TAttribute_ID = 14;

TLibrary_ID = 15;

TVariableDeclaration_ID = 16;

TThreadVariable_ID = 17;

TExportDeclaration_ID = 18;

TCaseVariableItem_ID = 19;

TCaseVariable_ID = 20;

TScopedType_ID = 21;

TTypeParameter_ID = 22;

TTypePointerOf_ID = 23;

TTypeTypeOf_ID = 24;

TArrayValues_ID = 25;

TItemExpression_ID = 26;

TTypeItem_ID = 27;

TSetItem_ID = 28;

TSetSpecification_ID = 29;

TRangeExpression_ID = 30;

TSetOfSpecification_ID = 31;

TSetRange_ID = 32;

TTypeRange_ID = 33;

TResourceStrings_ID = 34;

TFloatNumber_ID = 35;

TChar_ID = 36;

TBoolean_ID = 37;

TOperatorExpression_ID = 38;

TNestedExpression_ID = 39;

TStringFormatExpression_ID = 40;

TPropertyDeclaration_ID = 41;

TDispatchInterfaceProperty_ID = 42;

TRecordInstance_ID = 43;

TGenericSpec_ID = 44;

TGenericTypeDeclaration_ID = 45;

TRecordSpecification_ID = 46;

TInterfaceSpecification_ID = 47;

TDispatchInterfaceSpecification_ID = 48;

TClassSpecification_ID = 49;

TRecordHelperSpecification_ID = 50;

TClassHelperSpecification_ID = 51;

TClassOf_ID = 52;

TObjectSpecification_ID = 53;

TImplementation_ID = 54;

TStatements_ID = 55;

TASMStatements_ID = 56;

TCasting_ID = 57;

TAddressOf_ID = 58;

TAssignment_ID = 59;

TIf_ID = 60;

TOn_ID = 61;

TWhile_ID = 62;

TWith_ID = 63;

TFor_ID = 64;

TRepeat_ID = 65;

TTry_ID = 66;

TRaise_ID = 67;

TBody_ID = 68;

TReferenceSpecification_ID = 69;

TProcedureSpecification_ID = 70;

TConstructorSpecification_ID = 71;

TDestructorSpecification_ID = 72;

TFunctionSpecification_ID = 73;

TRecordOperatorSpec_ID = 74;

TCallExpression_ID = 75;

TCall_ID = 76;

TDereferenceExpression_ID = 77;

TFieldExpression_ID = 78;

TTypedMethod_ID = 79;

TInheritedExpression_ID = 80;

TCaseItem_ID = 81;

TCase_ID = 82;

TLabelDeclaration_ID = 83;

TLabelDeclarations_ID = 84;

TLabelPlace_ID = 85;

TGoto_ID = 86;

TInitialization_ID = 87;

TFinalization_ID = 88;

TImplementationModule_ID = 89;

TProgram_ID = 90;

TPackages_ID = 91;

TPackageContains_ID = 92;

TPackage_ID = 93;

TTypeSpecification_ID = 94;

TTypeDeclaration_ID = 95;

TParameter_ID = 96;

TParameters_ID = 97;

TVisibilityIdent_ID = 98;

TRecordFieldsDeclarations_ID = 99;

TTryExcept_ID = 100;

TGenericMethod_ID = 101;

MaxID=101;

IDStrings:Array[0..MaxID] of String = (

'TUnit',

'TInterface',

'TUses',

'TConstantDeclarations',

'TConstantDeclaration',

'TUnitScope',

'TDirective',

'TMethodDeclarations',

'TVariableDeclarations',

'TTypeDeclarations',

'TArraySpecification',

'TNumber',

'TString',

'TMethodDeclaration',

'TAttribute',

'TLibrary',

'TVariableDeclaration',

'TThreadVariable',

'TExportDeclaration',

'TCaseVariableItem',

'TCaseVariable',

'TScopedType',

'TTypeParameter',

'TTypePointerOf',

'TTypeTypeOf',

'TArrayValues',

'TItemExpression',

'TTypeItem',

'TSetItem',

'TSetSpecification',

'TRangeExpression',

'TSetOfSpecification',

'TSetRange',

'TTypeRange',

'TResourceStrings',

'TFloatNumber',

'TChar',

'TBoolean',

'TOperatorExpression',

'TNestedExpression',

'TStringFormatExpression',

'TPropertyDeclaration',

'TDispatchInterfaceProperty',

'TRecordInstance',

'TGenericSpec',

'TGenericTypeDeclaration',

'TRecordSpecification',

'TInterfaceSpecification',

'TDispatchInterfaceSpecification',

'TClassSpecification',

'TRecordHelperSpecification',

'TClassHelperSpecification',

'TClassOf',

'TObjectSpecification',

'TImplementation',

'TStatements',

'TASMStatements',

'TCasting',

'TAddressOf',

'TAssignment',

'TIf',

'TOn',

'TWhile',

'TWith',

'TFor',

'TRepeat',

'TTry',

'TRaise',

'TBody',

'TReferenceSpecification',

'TProcedureSpecification',

'TConstructorSpecification',

'TDestructorSpecification',

'TFunctionSpecification',

'TRecordOperatorSpec',

'TCallExpression',

'TCall',

'TDereferenceExpression',

'TFieldExpression',

'TTypedMethod',

'TInheritedExpression',

'TCaseItem',

'TCase',

'TLabelDeclaration',

'TLabelDeclarations',

'TLabelPlace',

'TGoto',

'TInitialization',

'TFinalization',

'TImplementationModule',

'TProgram',

'TPackages',

'TPackageContains',

'TPackage',

'TTypeSpecification',

'TTypeDeclaration',

'TParameter',

'TParameters',

'TVisibilityIdent',

'TRecordFieldsDeclarations',

'TTryExcept',

'TGenericMethod'

);

IDClasses:Array[0..MaxID] of TBlockClass = (

TUnit,

TInterface,

TUses,

TConstantDeclarations,

TConstantDeclaration,

TUnitScope,

TDirective,

TMethodDeclarations,

TVariableDeclarations,

TTypeDeclarations,

TArraySpecification,

TNumber,

TString,

TMethodDeclaration,

TAttribute,

TLibrary,

TVariableDeclaration,

TThreadVariable,

TExportDeclaration,

TCaseVariableItem,

TCaseVariable,

TScopedType,

TTypeParameter,

TTypePointerOf,

TTypeTypeOf,

TArrayValues,

TItemExpression,

TTypeItem,

TSetItem,

TSetSpecification,

TRangeExpression,

TSetOfSpecification,

TSetRange,

TTypeRange,

TResourceStrings,

TFloatNumber,

TChar,

TBoolean,

TOperatorExpression,

TNestedExpression,

TStringFormatExpression,

TPropertyDeclaration,

TDispatchInterfaceProperty,

TRecordInstance,

TGenericSpec,

TGenericTypeDeclaration,

TRecordSpecification,

TInterfaceSpecification,

TDispatchInterfaceSpecification,

TClassSpecification,

TRecordHelperSpecification,

TClassHelperSpecification,

TClassOf,

TObjectSpecification,

TImplementation,

TStatements,

TASMStatements,

TCasting,

TAddressOf,

TAssignment,

TIf,

TOn,

TWhile,

TWith,

TFor,

TRepeat,

TTry,

TRaise,

TBody,

TReferenceSpecification,

TProcedureSpecification,

TConstructorSpecification,

TDestructorSpecification,

TFunctionSpecification,

TRecordOperatorSpec,

TCallExpression,

TCall,

TDereferenceExpression,

TFieldExpression,

TTypedMethod,

TInheritedExpression,

TCaseItem,

TCase,

TLabelDeclaration,

TLabelDeclarations,

TLabelPlace,

TGoto,

TInitialization,

TFinalization,

TImplementationModule,

TProgram,

TPackages,

TPackageContains,

TPackage,

TTypeSpecification,

TTypeDeclaration,

TParameter,

TParameters,

TVisibilityIdent,

TRecordFieldsDeclarations,

TTryExcept,

TGenericMethod

);

procedure CheckIDs;

var t: Integer;

if IDs=nil then

begin

IDs:=TBaseList.Create;

for t:=0 to MaxID do

IDs.AddItem(IDStrings[t],TObject(t));

end;

end;

function ClassID(const ABlock:TBlock):Integer;

CheckIDs;

if IDs.Find(ABlock.ClassName,result) then

result:=Integer(IDs.Get(result).O)

else

result:=-1; // Error !

end;

TIdentifiersAccess=class(TIdentifiers);

procedure TCodeReader.ReadAs(const ABlock: TBlock; const ID:Integer);

function ReadRef:TBlock;

var tmp : Integer;

tmpIndex : Integer;

begin

tmp:=ReadInteger;

if tmp=-1 then

result:=nil

else

begin

tmpIndex:=ReadInteger;

if tmp=-2 then

result:=Module.Used[tmpIndex]

else

result:=Module.Used[tmp].Blocks[tmpIndex];

end;

end;

function ReadRefExpression:TExpression; {$IFDEF D9}inline;{$ENDIF}

begin

result:=TExpression(ReadRef);

end;

procedure ReadAsBlock(const ABlock:TBlock);

var t, H : Integer;

begin

// Position : TParserPosition;

// Owner

// Index

// Owned ??

// Parent ??

H:=ReadInteger;

if H<>-1 then

begin

SetLength(ABlock.Attributes,H+1);

for t:=0 to H do

ABlock.Attributes[t]:=TAttribute(ReadRef);

end;

end;

procedure ReadAsExpression(const AExp:TExpression);

begin

ReadAsBlock(AExp);

AExp.TypeIdentifier:=TTypeDeclaration(ReadRef);

// ValueType : TTypeDeclaration; ?

end;

procedure ReadAsIdentifier(const AIdent:TIdentifier);

begin

ReadAsExpression(AIdent);

AIdent.Name:=ReadString;

AIdent.Visibility:=TVisibility(ReadInteger);

AIdent.AbsoluteRef:=ReadString;

AIdent.IsDeprecated:=ReadBoolean;

AIdent.DeprecatedMessage:=ReadRefExpression;

AIdent.IsInline:=ReadBoolean;

AIdent.IsPlatform:=ReadBoolean;

// Usage : Integer; ??

end;

function ReadAsBlocks:TBlocks;

var t, H : Integer;

begin

H:=ReadInteger;

if H=-1 then

result:=nil

else

begin

SetLength(result,H+1);

for t:=0 to H do

result[t]:=ReadRef;

end;

end;

procedure ReadAsSection(const ASection:TSection);

begin

ReadAsBlock(ASection);

ASection.Bodies:=ReadBoolean;

ASection.Constants:=TConstantDeclarations(ReadRef);

ASection.Methods:=TMethodDeclarations(ReadRef);

ASection.Types:=TTypeDeclarations(ReadRef);

ASection.Variables:=TVariableDeclarations(ReadRef);

ASection.Labels:=TLabelDeclarations(ReadRef);

ASection.ResourceStrings:=TResourceStrings(ReadRef);

ASection.Ordered:=ReadAsBlocks;

end;

procedure ReadAsUsesSection(const AUsesSection:TUsesSection);

begin

ReadAs(AUsesSection.UsesUnits,TUses_ID);

ReadAsSection(AUsesSection);

end;

procedure ReadAsIdentifiers(const AIdents:TIdentifiers);

var t,L : Integer;

begin

L:=ReadInteger;

if L>0 then

begin

SetLength(TIdentifiersAccess(AIdents).Items,L);

for t:=0 to L-1 do

TIdentifiersAccess(AIdents).Items[t]:=TIdentifier(ReadRef);

// AIdents.AddSorted(TIdentifier(Units.Blocks[ReadInteger]));

end;

end;

function ReadModuleReference(const DoLoad:Boolean):TModule;

var tmp,

tmpS : String;

begin

tmpS:=ReadString;

result:=Module.Package.Language.FindModule(tmpS);

if result=nil then

result:=Module.Package.Language.Modules.NewModule(tmpS,Module.Package.Language.ModuleClass);

if DoLoad and (result.BlockCount=0) then

begin

tmp:=CurrentDir;

if Copy(tmp,Length(tmp),1)<>'\' then

tmp:=tmp+'\';

TCodeReader.ReadFromFile(result,tmp+tmpS+'.b');

end;

end;

procedure ReadUsed(const AIdents:TIdentifiers);

var t,

L : Integer;

begin

L:=ReadInteger;

for t:=0 to L-1 do

AIdents.AddSorted(ReadModuleReference(True));

end;

procedure ReadAsNativeModule(const AModule:TNativeModule);

begin

ReadAs(AModule,TImplementationModule_ID);

AModule.Main:=TModuleBody(ReadRef);

end;

procedure ReadAsTypeRedirect(const ATypeRedirect:TTypeRedirect);

begin

ReadAs(ATypeRedirect,TTypeSpecification_ID);

ATypeRedirect.TypeIdentifier:=TTypeDeclaration(ReadRef);

end;

function ReadAsExpressions:TExpressions;

var t,H : Integer;

begin

H:=ReadInteger;

if H=-1 then

result:=nil

else

begin

SetLength(result,H+1);

for t:=0 to H do

result[t]:=ReadRefExpression;

end;

end;

procedure ReadAsParameters(const AParams:TParameters);

var t,L : Integer;

begin

L:=ReadInteger;

for t:=0 to L-1 do

AParams.Add(TVariableDeclaration(ReadRef));

end;

function ReadAsTypeSpecs:TTypeSpecifications;

var t, H : Integer;

begin

H:=ReadInteger;

if H=-1 then

result:=nil

else

begin

SetLength(result,H+1);

for t:=0 to H do

result[t]:=TTypeSpecification(ReadRef);

end;

end;

function ReadAsTypes:TTypeDeclarationArray;

var t, H : Integer;

begin

H:=ReadInteger;

if H=-1 then

result:=nil

else

begin

SetLength(result,H+1);

for t:=0 to H do

result[t]:=TTypeDeclaration(ReadRef);

end;

end;

procedure ReadAsRecordSpec(const ARecord:TRecordSpecification);

var t : Integer;

begin

ReadAs(ARecord,TGenericSpec_ID);

ARecord.PropertyDefault:=TPropertyDeclaration(ReadRef);

for t:=Ord(Low(TRecordOperatorKind)) to Ord(High(TRecordOperatorKind)) do

ARecord.Operators[TRecordOperatorKind(t)]:=ReadAsTypeSpecs;

ARecord.IsPacked:=ReadBoolean;

ARecord.Ancestors:=ReadAsTypes;

ARecord.RecordType:=TTypeDeclaration(ReadRef);

ARecord.Outer:=TRecordSpecification(ReadRef);

ARecord.Module:=TModule(ReadRef);

ARecord.Constants:=TConstantDeclarations(ReadRef);

ARecord.Fields:=TRecordFieldsDeclarations(ReadRef);

ARecord.Methods:=TMethodDeclarations(ReadRef);

ARecord.Types:=TTypeDeclarations(ReadRef);

ARecord.Ordered:=ReadAsBlocks;

end;

function ReadAsStatements:TStatementArray;

var t, H : Integer;

begin

H:=ReadInteger;

if H=-1 then

result:=nil

else

begin

SetLength(result,H+1);

for t:=0 to H do

result[t]:=TStatement(ReadRef);

end;

end;

function ReadAsStrings:TStringArray;

var t, H : Integer;

begin

H:=ReadInteger;

if H=-1 then

result:=nil

else

begin

SetLength(result,H+1);

for t:=0 to H do

result[t]:=ReadString;

end;

end;

procedure ReadAsStatement(const AStatement:TStatement);

begin

ReadAsBlock(AStatement);

end;

procedure ReadAsMethodSpec(const AMethod:TMethodSpecification);

begin

ReadAs(AMethod,TGenericSpec_ID);

// !!! ReadInteger( Directives : TMethodDirectives;

AMethod.DeprecatedMessage:=TConstantDeclaration(ReadRef);

AMethod.OfRecord:=TTypeDeclaration(ReadRef);

AMethod.OfObject:=ReadBoolean;

AMethod.IsClass:=ReadBoolean;

AMethod.IsExternal:=ReadBoolean;

AMethod.IsDelayed:=ReadBoolean;

AMethod.ExternalDLL:=ReadRefExpression;

AMethod.ExternalName:=ReadRefExpression;

AMethod.DispatchID:=ReadRefExpression;

AMethod.MessageField:=ReadRefExpression;

AMethod.Referenced:=ReadString;

AMethod.Body:=TBody(ReadRef);

end;

procedure ReadAsMethodParams(const AMethod:TMethodParams);

begin

ReadAsMethodSpec(AMethod);

AMethod.FixedParameters:=ReadInteger;

AMethod.VariableParameters:=ReadBoolean;

AMethod.Parameters:=TParameters(ReadRef);

end;

procedure ReadAsGenericMethod(const AMethod:TGenericMethod);

begin

ReadAsExpression(AMethod);

AMethod.Method:=TMethodDeclaration(ReadRef);

AMethod.TypeParameters:=ReadAsExpressions;

end;

function ReadAsCaseArray:TCaseItems;

var t, H : Integer;

begin

H:=ReadInteger;

if H=-1 then

result:=nil

else

begin

SetLength(result,H+1);

for t:=0 to H do

result[t]:=TCaseItem(ReadRef);

end;

end;

procedure ReadAsModule(const AModule:TModule);

begin

ReadAs(AModule,TTypeDeclaration_ID);

AModule.FileName:=ReadString;

end;

procedure ReadUnit(const AUnit:TUnit);

procedure ReadExtraUsed;

var N, t : Integer;

begin

N:=ReadInteger;

SetLength(AUnit.Used,1+N);

AUnit.ModuleIndex:=0;

AUnit.Used[0]:=AUnit;

for t:=1 to N do

begin

ReadBoolean;

AUnit.Used[t]:=ReadModuleReference(False{ReadBoolean});

AUnit.Used[t].ModuleIndex:=t;

end;

end;

begin

Module:=AUnit;

if Package<>nil then

Module.Package:=Package;

ReadExtraUsed;

ReadBlocks(AUnit);

ReadAs(AUnit,TImplementationModule_ID);

AUnit.UnitInterface:=TInterface(ReadRef);

AUnit.UnitInitialization:=TInitialization(ReadRef);

AUnit.UnitFinalization:=TFinalization(ReadRef);

end;

var t,tmp,

H : Integer;

case ID of

TUnit_ID : ReadUnit(TUnit(ABlock));

TInterface_ID : ReadAsUsesSection(TInterface(ABlock));

TUses_ID : ReadUsed(TUses(ABlock));

TConstantDeclarations_ID : ReadAsIdentifiers(TConstantDeclarations(ABlock));

TConstantDeclaration_ID : begin

ReadAsIdentifier(TConstantDeclaration(ABlock));

TConstantDeclaration(ABlock).NeedsType:=ReadBoolean;

TConstantDeclaration(ABlock).AutomaticType:=ReadBoolean;

TConstantDeclaration(ABlock).OptionalValue:=ReadBoolean;

TConstantDeclaration(ABlock).Value:=ReadRef;

TConstantDeclaration(ABlock).IsClass:=ReadBoolean;

end;

TUnitScope_ID : ReadAsIdentifier(TUnitScope(ABlock));

TDirective_ID : begin

ReadAs(ABlock,TAttribute_ID);

TDirective(ABlock).Kind:=TDirectiveKind(ReadInteger);

end;

TMethodDeclarations_ID : ReadAsIdentifiers(TMethodDeclarations(ABlock));

TVariableDeclarations_ID : ReadAsIdentifiers(TVariableDeclarations(ABlock));

TTypeDeclarations_ID : ReadAsIdentifiers(TTypeDeclarations(ABlock));

TArraySpecification_ID : begin

ReadAs(ABlock,TRecordSpecification_ID);

TArraySpecification(ABlock).IsPacked:=ReadBoolean;

TArraySpecification(ABlock).CreateConstructor:=TMethodDeclaration(ReadRef);

TArraySpecification(ABlock).Expression:=TTypeDeclaration(ReadRef);

TArraySpecification(ABlock).Dimensions:=ReadAsExpressions;

end;

TNumber_ID : begin

ReadAs(ABlock,TConstantDeclaration_ID);

TNumber(ABlock).Hexadecimal:=ReadBoolean;

TNumber(ABlock).Value:=ReadInt64;

end;

TString_ID : begin

ReadAs(ABlock,TConstantDeclaration_ID);

TString(ABlock).Value:=ReadString;

end;

TMethodDeclaration_ID : ReadAs(ABlock,TVariableDeclaration_ID);

TAttribute_ID : begin

ReadAsBlock(ABlock);

TAttribute(ABlock).Text:=ReadString;

end;

TLibrary_ID : ReadAsNativeModule(TLibrary(ABlock));

TVariableDeclaration_ID : ReadAs(ABlock,TConstantDeclaration_ID);

TThreadVariable_ID : ReadAs(ABlock,TVariableDeclaration_ID);

TExportDeclaration_ID : begin

ReadAsIdentifier(TExportDeclaration(ABlock));

TExportDeclaration(ABlock).Method:=TMethodDeclaration(ReadRef);

end;

TCaseVariableItem_ID : begin

ReadAs(ABlock,TVariableDeclaration_ID);

TCaseVariableItem(ABlock).Expression:=ReadRefExpression;

end;

TCaseVariable_ID : begin

ReadAs(ABlock,TVariableDeclaration_ID);

ReadAsIdentifiers(TCaseVariable(ABlock).Fields);

end;

TScopedType_ID : begin

ReadAs(ABlock,TTypeDeclaration_ID);

TScopedType(ABlock).Field:=TFieldExpression(ReadRef);

end;

TTypeParameter_ID : begin

ReadAs(ABlock,TTypeDeclaration_ID);

TTypeParameter(ABlock).Index:=ReadInteger;

H:=ReadInteger;

if H<>-1 then

begin

SetLength(TTypeParameter(ABlock).Constraints,H+1);

for t:=0 to H do

TTypeParameter(ABlock).Constraints[t]:=TTypeDeclaration(ReadRef);

end;

end;

TTypePointerOf_ID : ReadAsTypeRedirect(TTypePointerOf(ABlock));

TTypeTypeOf_ID : ReadAsTypeRedirect(TTypePointerOf(ABlock));

TArrayValues_ID : begin

ReadAsExpression(TArrayValues(ABlock));

TArrayValues(ABlock).DimensionIndex:=ReadInteger;

TArrayValues(ABlock).Items:=ReadAsExpressions;

end;

TItemExpression_ID : begin

ReadAsExpression(TItemExpression(ABlock));

TItemExpression(ABlock).Value:=ReadRefExpression;

TItemExpression(ABlock).Items:=ReadAsExpressions;

end;

TTypeItem_ID : begin

ReadAs(ABlock,TTypeSpecification_ID);

TTypeItem(ABlock).Item:=TItemExpression(ReadRef);

end;

TSetItem_ID : begin

ReadAs(ABlock,TTypeDeclaration_ID);

TSetItem(ABlock).Value:=ReadRefExpression;

end;

TSetSpecification_ID : begin

ReadAs(ABlock,TTypeSpecification_ID);

TSetSpecification(ABlock).IsScoped:=ReadBoolean;

TSetSpecification(ABlock).IsSetOf:=ReadBoolean;

ReadAs(TSetSpecification(ABlock).Items,TTypeDeclarations_ID);

end;

TRangeExpression_ID : begin

ReadAsExpression(TRangeExpression(ABlock));

TRangeExpression(ABlock).StartRange:=ReadRefExpression;

TRangeExpression(ABlock).EndRange:=ReadRefExpression;

end;

TSetOfSpecification_ID : begin

ReadAs(ABlock,TTypeSpecification_ID);

TSetOfSpecification(ABlock).TypeIdentifier:=TTypeDeclaration(ReadRef);

end;

TSetRange_ID : begin

ReadAs(ABlock,TTypeSpecification_ID);

TSetRange(ABlock).Range:=TRangeExpression(ReadRef);

end;

TTypeRange_ID : begin

ReadAs(ABlock,TTypeSpecification_ID);

TTypeRange(ABlock).Range:=TRangeExpression(ReadRef);

end;

TResourceStrings_ID : ReadAs(ABlock,TConstantDeclarations_ID);

TFloatNumber_ID : begin

ReadAs(ABlock,TConstantDeclaration_ID);

TFloatNumber(ABlock).Exponent:=ReadBoolean;

TFloatNumber(ABlock).Value:=ReadFloat;

TFloatNumber(ABlock).ValueString:=ReadString;

end;

TChar_ID : begin

ReadAs(ABlock,TConstantDeclaration_ID);

TChar(ABlock).Value:=ReadChar;

end;

TBoolean_ID : begin

ReadAs(ABlock,TConstantDeclaration_ID);

TBoolean(ABlock).Value:=ReadBoolean;

end;

TOperatorExpression_ID : begin

ReadAsExpression(TOperatorExpression(ABlock));

TOperatorExpression(ABlock).Operat:=TOperator(ReadInteger);

TOperatorExpression(ABlock).Left:=ReadRefExpression;

TOperatorExpression(ABlock).Right:=ReadRefExpression;

end;

TNestedExpression_ID : begin

ReadAsExpression(TNestedExpression(ABlock));

TNestedExpression(ABlock).Expression:=ReadRefExpression;

end;

TStringFormatExpression_ID : begin

ReadAsExpression(TStringFormatExpression(ABlock));

TStringFormatExpression(ABlock).Expression:=ReadRefExpression;

TStringFormatExpression(ABlock).Width:=ReadRefExpression;

TStringFormatExpression(ABlock).Decimals:=ReadRefExpression;

end;

TPropertyDeclaration_ID : begin

ReadAs(ABlock,TVariableDeclaration_ID);

TPropertyDeclaration(ABlock).IsDefault:=ReadBoolean;

TPropertyDeclaration(ABlock).NoDefault:=ReadBoolean;

TPropertyDeclaration(ABlock).Index:=ReadRefExpression;

TPropertyDeclaration(ABlock).PropertyType:=TTypeDeclaration(ReadRef);

TPropertyDeclaration(ABlock).Indexes:=TParameters(ReadRef);

TPropertyDeclaration(ABlock).ReadPart:=ReadRefExpression;

TPropertyDeclaration(ABlock).WritePart:=ReadRefExpression;

TPropertyDeclaration(ABlock).Stored:=ReadRefExpression;

TPropertyDeclaration(ABlock).DefaultValue:=ReadRefExpression;

TPropertyDeclaration(ABlock).ImplementsInterfaces:=ReadAsExpressions;

TPropertyDeclaration(ABlock).Ancestor:=TPropertyDeclaration(ReadRef);

// Pending: Move to TDispatchInterfaceProperty

TPropertyDeclaration(ABlock).ReadOnly:=ReadBoolean;

TPropertyDeclaration(ABlock).ReadOnly:=ReadBoolean;

TPropertyDeclaration(ABlock).DispatchId:=ReadRefExpression;