fs_iinterpreter.hpp

这个是功能强大的报表软件

// Borland C++ Builder
// Copyright (c) 1995, 2005 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Fs_iinterpreter.pas' rev: 10.00

#ifndef Fs_iinterpreterHPP
#define Fs_iinterpreterHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <Sysinit.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Fs_xml.hpp>	// Pascal unit
#include <Variants.hpp>	// Pascal unit
#include <Syncobjs.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------

namespace Fs_iinterpreter
{
//-- type declarations -------------------------------------------------------
#pragma option push -b-
enum TfsVarType { fvtInt, fvtBool, fvtFloat, fvtChar, fvtString, fvtClass, fvtArray, fvtVariant, fvtEnum, fvtConstructor };
#pragma option pop

#pragma pack(push,1)
struct TfsTypeRec
{
	
public:
	TfsVarType Typ;
	SmallString<32>  TypeName;
} ;
#pragma pack(pop)

typedef Variant __fastcall (__closure *TfsGetValueEvent)(System::TObject* Instance, TMetaClass* ClassType, const AnsiString PropName);

typedef void __fastcall (__closure *TfsSetValueEvent)(System::TObject* Instance, TMetaClass* ClassType, const AnsiString PropName, const Variant &Value);

class DELPHICLASS TfsPropertyHelper;
typedef Variant __fastcall (__closure *TfsGetValueNewEvent)(System::TObject* Instance, TMetaClass* ClassType, const AnsiString PropName, TfsPropertyHelper* Caler);

typedef void __fastcall (__closure *TfsSetValueNewEvent)(System::TObject* Instance, TMetaClass* ClassType, const AnsiString PropName, const Variant &Value, TfsPropertyHelper* Caller);

class DELPHICLASS TfsMethodHelper;
typedef Variant __fastcall (__closure *TfsCallMethodNewEvent)(System::TObject* Instance, TMetaClass* ClassType, const AnsiString MethodName, TfsMethodHelper* Caller);

typedef Variant __fastcall (__closure *TfsCallMethodEvent)(System::TObject* Instance, TMetaClass* ClassType, const AnsiString MethodName, Variant &Params);

class DELPHICLASS TfsScript;
typedef void __fastcall (__closure *TfsRunLineEvent)(TfsScript* Sender, const AnsiString UnitName, const AnsiString SourcePos);

typedef void __fastcall (__closure *TfsGetUnitEvent)(TfsScript* Sender, const AnsiString UnitName, AnsiString &UnitText);

typedef Variant __fastcall (__closure *TfsGetVariableValueEvent)(AnsiString VarName, TfsVarType VarTyp, const Variant &OldValue);

class DELPHICLASS TfsItemList;
class PASCALIMPLEMENTATION TfsItemList : public System::TObject 
{
	typedef System::TObject inherited;
	
protected:
	Classes::TList* FItems;
	virtual void __fastcall Clear(void);
	
public:
	__fastcall TfsItemList(void);
	__fastcall virtual ~TfsItemList(void);
	void __fastcall Add(System::TObject* Item);
	int __fastcall Count(void);
	void __fastcall Remove(System::TObject* Item);
};


class DELPHICLASS TfsStatement;
class PASCALIMPLEMENTATION TfsStatement : public TfsItemList 
{
	typedef TfsItemList inherited;
	
private:
	TfsScript* FProgram;
	AnsiString FSourcePos;
	AnsiString FUnitName;
	TfsStatement* __fastcall GetItem(int Index);
	void __fastcall RunLine(void);
	
public:
	__fastcall virtual TfsStatement(TfsScript* AProgram, const AnsiString UnitName, const AnsiString SourcePos);
	virtual void __fastcall Execute(void);
	__property TfsStatement* Items[int Index] = {read=GetItem};
public:
	#pragma option push -w-inl
	/* TfsItemList.Destroy */ inline __fastcall virtual ~TfsStatement(void) { }
	#pragma option pop
	
};


class DELPHICLASS TfsCustomVariable;
class DELPHICLASS TfsClassVariable;
class DELPHICLASS TfsProcVariable;
class PASCALIMPLEMENTATION TfsScript : public Classes::TComponent 
{
	typedef Classes::TComponent inherited;
	
private:
	System::TObject* FAddedBy;
	bool FBreakCalled;
	bool FContinueCalled;
	bool FExitCalled;
	AnsiString FErrorMsg;
	AnsiString FErrorPos;
	AnsiString FErrorUnit;
	bool FExtendedCharset;
	Classes::TStringList* FItems;
	bool FIsRunning;
	Classes::TStrings* FLines;
	Classes::TStrings* FMacros;
	bool FMainProg;
	TfsGetUnitEvent FOnGetILUnit;
	TfsGetUnitEvent FOnGetUnit;
	TfsRunLineEvent FOnRunLine;
	TfsGetVariableValueEvent FOnGetVarValue;
	TfsScript* FParent;
	TfsScript* FProgRunning;
	bool FRTTIAdded;
	TfsStatement* FStatement;
	AnsiString FSyntaxType;
	bool FTerminated;
	Classes::TStringList* FUnitLines;
	Classes::TStrings* FIncludePath;
	bool FUseClassLateBinding;
	bool FEvaluteRiseError;
	TfsCustomVariable* __fastcall GetItem(int Index);
	void __fastcall RunLine(const AnsiString UnitName, const AnsiString Index);
	Variant __fastcall GetVariables(AnsiString Index);
	void __fastcall SetVariables(AnsiString Index, const Variant &Value);
	void __fastcall SetLines(const Classes::TStrings* Value);
	
public:
	__fastcall virtual TfsScript(Classes::TComponent* AOwner);
	__fastcall virtual ~TfsScript(void);
	void __fastcall Add(const AnsiString Name, System::TObject* Item);
	void __fastcall AddCodeLine(const AnsiString UnitName, const AnsiString APos);
	void __fastcall AddRTTI(void);
	HIDESBASE void __fastcall Remove(System::TObject* Item);
	void __fastcall RemoveItems(System::TObject* Owner);
	void __fastcall Clear(void);
	void __fastcall ClearItems(System::TObject* Owner);
	void __fastcall ClearRTTI(void);
	int __fastcall Count(void);
	DYNAMIC TfsClassVariable* __fastcall AddClass(TMetaClass* AClass, const AnsiString Ancestor);
	DYNAMIC void __fastcall AddConst(const AnsiString Name, const AnsiString Typ, const Variant &Value);
	DYNAMIC void __fastcall AddEnum(const AnsiString Typ, const AnsiString Names);
	DYNAMIC void __fastcall AddEnumSet(const AnsiString Typ, const AnsiString Names);
	DYNAMIC void __fastcall AddComponent(Classes::TComponent* Form);
	DYNAMIC void __fastcall AddForm(Classes::TComponent* Form);
	DYNAMIC void __fastcall AddMethod(const AnsiString Syntax, TfsCallMethodNewEvent CallEvent, const AnsiString Category = "", const AnsiString Description = "")/* overload */;
	DYNAMIC void __fastcall AddMethod(const AnsiString Syntax, TfsCallMethodEvent CallEvent, const AnsiString Category = "", const AnsiString Description = "")/* overload */;
	DYNAMIC void __fastcall AddObject(const AnsiString Name, System::TObject* Obj);
	DYNAMIC void __fastcall AddVariable(const AnsiString Name, const AnsiString Typ, const Variant &Value);
	DYNAMIC void __fastcall AddType(const AnsiString TypeName, TfsVarType ParentType);
	Variant __fastcall CallFunction(const AnsiString Name, const Variant &Params);
	Variant __fastcall CallFunction1(const AnsiString Name, Variant &Params);
	Variant __fastcall CallFunction2(const TfsProcVariable* Func, const Variant &Params);
	bool __fastcall Compile(void);
	void __fastcall Execute(void);
	bool __fastcall Run(void);
	void __fastcall Terminate(void);
	Variant __fastcall Evaluate(const AnsiString Expression);
	bool __fastcall IsExecutableLine(int LineN, const AnsiString UnitName = "");
	bool __fastcall GetILCode(Classes::TStream* Stream);
	bool __fastcall SetILCode(Classes::TStream* Stream);
	TfsCustomVariable* __fastcall Find(const AnsiString Name);
	TfsClassVariable* __fastcall FindClass(const AnsiString Name);
	TfsCustomVariable* __fastcall FindLocal(const AnsiString Name);
	__property System::TObject* AddedBy = {read=FAddedBy, write=FAddedBy};
	__property AnsiString ErrorMsg = {read=FErrorMsg, write=FErrorMsg};
	__property AnsiString ErrorPos = {read=FErrorPos, write=FErrorPos};
	__property AnsiString ErrorUnit = {read=FErrorUnit, write=FErrorUnit};
	__property bool ExtendedCharset = {read=FExtendedCharset, write=FExtendedCharset, nodefault};
	__property TfsCustomVariable* Items[int Index] = {read=GetItem};
	__property bool IsRunning = {read=FIsRunning, nodefault};
	__property Classes::TStrings* Macros = {read=FMacros};
	__property bool MainProg = {read=FMainProg, write=FMainProg, nodefault};
	__property TfsScript* Parent = {read=FParent, write=FParent};
	__property TfsScript* ProgRunning = {read=FProgRunning};
	__property TfsStatement* Statement = {read=FStatement};
	__property Variant Variables[AnsiString Index] = {read=GetVariables, write=SetVariables};
	__property Classes::TStrings* IncludePath = {read=FIncludePath};
	__property bool UseClassLateBinding = {read=FUseClassLateBinding, write=FUseClassLateBinding, nodefault};
	__property bool EvaluteRiseError = {read=FEvaluteRiseError, nodefault};
	
__published:
	__property Classes::TStrings* Lines = {read=FLines, write=SetLines};
	__property AnsiString SyntaxType = {read=FSyntaxType, write=FSyntaxType};
	__property TfsGetUnitEvent OnGetILUnit = {read=FOnGetILUnit, write=FOnGetILUnit};
	__property TfsGetUnitEvent OnGetUnit = {read=FOnGetUnit, write=FOnGetUnit};
	__property TfsRunLineEvent OnRunLine = {read=FOnRunLine, write=FOnRunLine};
	__property TfsGetVariableValueEvent OnGetVarValue = {read=FOnGetVarValue, write=FOnGetVarValue};
};


class DELPHICLASS TfsAssignmentStmt;
class DELPHICLASS TfsDesignator;
class DELPHICLASS TfsParamItem;
class PASCALIMPLEMENTATION TfsCustomVariable : public TfsItemList 
{
	typedef TfsItemList inherited;
	
public:
	TfsParamItem* operator[](int Index) { return Params[Index]; }
	
private:
	System::TObject* FAddedBy;
	bool FIsMacro;
	bool FIsReadOnly;
	AnsiString FName;
	bool FNeedResult;
	TfsCustomVariable* FRefItem;
	AnsiString FSourcePos;
	AnsiString FSourceUnit;
	TfsVarType FTyp;
	AnsiString FTypeName;
	AnsiString FUppercaseName;
	Variant FValue;
	TfsGetVariableValueEvent FOnGetVarValue;
	TfsParamItem* __fastcall GetParam(int Index);
	System::PVariant __fastcall GetPValue(void);
	
protected:
	virtual void __fastcall SetValue(const Variant &Value);
	virtual Variant __fastcall GetValue();
	
public:
	__fastcall TfsCustomVariable(const AnsiString AName, TfsVarType ATyp, const AnsiString ATypeName);
	AnsiString __fastcall GetFullTypeName();
	int __fastcall GetNumberOfRequiredParams(void);
	__property System::TObject* AddedBy = {read=FAddedBy, write=FAddedBy};
	__property bool IsMacro = {read=FIsMacro, write=FIsMacro, nodefault};
	__property bool IsReadOnly = {read=FIsReadOnly, write=FIsReadOnly, nodefault};
	__property AnsiString Name = {read=FName};
	__property bool NeedResult = {read=FNeedResult, write=FNeedResult, nodefault};
	__property TfsParamItem* Params[int Index] = {read=GetParam/*, default*/};
	__property System::PVariant PValue = {read=GetPValue};
	__property TfsCustomVariable* RefItem = {read=FRefItem, write=FRefItem};
	__property AnsiString SourcePos = {read=FSourcePos, write=FSourcePos};
	__property AnsiString SourceUnit = {read=FSourceUnit, write=FSourceUnit};
	__property TfsVarType Typ = {read=FTyp, write=FTyp, nodefault};
	__property AnsiString TypeName = {read=FTypeName, write=FTypeName};
	__property Variant Value = {read=GetValue, write=SetValue};
	__property TfsGetVariableValueEvent OnGetVarValue = {read=FOnGetVarValue, write=FOnGetVarValue};
public:
	#pragma option push -w-inl
	/* TfsItemList.Destroy */ inline __fastcall virtual ~TfsCustomVariable(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TfsDesignatorKind { dkOther, dkVariable, dkStringArray, dkArray };
#pragma option pop

class DELPHICLASS TfsDesignatorItem;
class DELPHICLASS TfsCustomExpression;
class PASCALIMPLEMENTATION TfsDesignatorItem : public TfsItemList 
{
	typedef TfsItemList inherited;
	
public:
	TfsCustomExpression* operator[](int Index) { return Items[Index]; }
	
private:
	bool FFlag;
	TfsCustomVariable* FRef;
	AnsiString FSourcePos;
	TfsCustomExpression* __fastcall GetItem(int Index);
	
public:
	__property TfsCustomExpression* Items[int Index] = {read=GetItem/*, default*/};
	__property bool Flag = {read=FFlag, write=FFlag, nodefault};
	__property TfsCustomVariable* Ref = {read=FRef, write=FRef};
	__property AnsiString SourcePos = {read=FSourcePos, write=FSourcePos};
public:
	#pragma option push -w-inl
	/* TfsItemList.Create */ inline __fastcall TfsDesignatorItem(void) : TfsItemList() { }
	#pragma option pop
	#pragma option push -w-inl
	/* TfsItemList.Destroy */ inline __fastcall virtual ~TfsDesignatorItem(void) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TfsDesignator : public TfsCustomVariable 
{
	typedef TfsCustomVariable inherited;
	
public:
	TfsDesignatorItem* operator[](int Index) { return Items[Index]; }
	
private:
	TfsDesignatorKind FKind;
	TfsScript* FMainProg;
	TfsScript* FProgram;
	TfsCustomVariable* FRef1;
	TfsDesignatorItem* FRef2;
	Fs_xml::TfsXMLItem* FLateBindingXmlSource;
	void __fastcall CheckLateBinding(void);
	Variant __fastcall DoCalc(const Variant &AValue, bool Flag);
	TfsDesignatorItem* __fastcall GetItem(int Index);
	
protected:
	virtual Variant __fastcall GetValue();
	virtual void __fastcall SetValue(const Variant &Value);
	
public:
	__fastcall TfsDesignator(TfsScript* AProgram);
	__fastcall virtual ~TfsDesignator(void);
	void __fastcall Borrow(TfsDesignator* ADesignator);
	void __fastcall Finalize(void);
	__property TfsDesignatorItem* Items[int Index] = {read=GetItem/*, default*/};
	__property TfsDesignatorKind Kind = {read=FKind, nodefault};
	__property Fs_xml::TfsXMLItem* LateBindingXmlSource = {read=FLateBindingXmlSource, write=FLateBindingXmlSource};
};


class PASCALIMPLEMENTATION TfsAssignmentStmt : public TfsStatement 
{
	typedef TfsStatement inherited;
	
private:
	TfsDesignator* FDesignator;
	TfsCustomExpression* FExpression;
	TfsCustomVariable* FVar;
	TfsCustomVariable* FExpr;
	
public:
	__fastcall virtual ~TfsAssignmentStmt(void);
	virtual void __fastcall Execute(void);
	void __fastcall Optimize(void);
	__property TfsDesignator* Designator = {read=FDesignator, write=FDesignator};
	__property TfsCustomExpression* Expression = {read=FExpression, write=FExpression};
public:
	#pragma option push -w-inl
	/* TfsStatement.Create */ inline __fastcall virtual TfsAssignmentStmt(TfsScript* AProgram, const AnsiString UnitName, const AnsiString SourcePos) : TfsStatement(AProgram, UnitName, SourcePos) { }
	#pragma option pop
	
};


class DELPHICLASS TfsAssignPlusStmt;
class PASCALIMPLEMENTATION TfsAssignPlusStmt : public TfsAssignmentStmt 
{
	typedef TfsAssignmentStmt inherited;
	
public:
	virtual void __fastcall Execute(void);
public:
	#pragma option push -w-inl
	/* TfsAssignmentStmt.Destroy */ inline __fastcall virtual ~TfsAssignPlusStmt(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TfsStatement.Create */ inline __fastcall virtual TfsAssignPlusStmt(TfsScript* AProgram, const AnsiString UnitName, const AnsiString SourcePos) : TfsAssignmentStmt(AProgram, UnitName, SourcePos) { }
	#pragma option pop
	
};


class DELPHICLASS TfsAssignMinusStmt;
class PASCALIMPLEMENTATION TfsAssignMinusStmt : public TfsAssignmentStmt 
{
	typedef TfsAssignmentStmt inherited;
	
public:
	virtual void __fastcall Execute(void);
public:
	#pragma option push -w-inl
	/* TfsAssignmentStmt.Destroy */ inline __fastcall virtual ~TfsAssignMinusStmt(void) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TfsStatement.Create */ inline __fastcall virtual TfsAssignMinusStmt(TfsScript* AProgram, const AnsiString UnitName, const AnsiString SourcePos) : TfsAssignmentStmt(AProgram, UnitName, SourcePos) { }
	#pragma option pop
	
};


class DELPHICLASS TfsAssignMulStmt;
class PASCALIMPLEMENTATION TfsAssignMulStmt : public TfsAssignmentStmt 
{
	typedef TfsAssignmentStmt inherited;
	
public:
	virtual void __fastcall Execute(void);