oplbacke.h

来自「在手机操作系统symbina上使用的一个脚本扩展语言的代码实现,可以参考用于自己」· C头文件 代码 · 共 582 行 · 第 1/2 页

///////////////////////////////////////////////////////////////////////
//
// TPcode - An internal Pcode
//
///////////////////////////////////////////////////////////////////////

inline RReadStream& operator>>(RReadStream& aStream, TOplToken& aValue) { aValue=TOplToken(TOplToken::TValue(aStream.ReadUint16L()));return aStream;}
inline RReadStream& operator>>(RReadStream& aStream, TOplToken::TType& aType) { aType=TOplToken::TType(aStream.ReadUint8L()); return aStream;}
inline RReadStream& operator>>(RReadStream& aStream, TOplKeyword::TCode& aCode) { aCode=TOplKeyword::TCode(aStream.ReadUint8L()); return aStream;}
inline RReadStream& operator>>(RReadStream& aStream, TOplSignature::TArgType& aType) { aType=TOplSignature::TArgType(aStream.ReadUint8L()); return aStream;}
inline RReadStream& operator>>(RReadStream& aStream, TOplFunction::TNumber& aNumber) { aNumber=TOplFunction::TNumber(aStream.ReadUint8L()); return aStream;}
inline RReadStream& operator>>(RReadStream& aStream, TOplField::TDevice& aDevice) {aDevice=TOplField::TDevice(aStream.ReadUint8L());return aStream;}
inline RReadStream& operator>>(RReadStream& aStream, COplSymbol*& aSymbol){aSymbol=(COplSymbol *)aStream.ReadUint32L();return aStream;}

inline RWriteStream& operator<<(RWriteStream& aStream, TOplToken::TValue aValue) { aStream.WriteUint16L(aValue); return aStream;}
inline RWriteStream& operator<<(RWriteStream& aStream, TOplToken::TType aType) { aStream.WriteUint8L(aType); return aStream;}
inline RWriteStream& operator<<(RWriteStream& aStream, TOplKeyword::TCode aCode) { aStream.WriteUint8L(aCode); return aStream;}
inline RWriteStream& operator<<(RWriteStream& aStream, TOplSignature::TArgType aType) { aStream.WriteUint8L(aType); return aStream;}
inline RWriteStream& operator<<(RWriteStream& aStream, TOplFunction::TNumber aNumber) { aStream.WriteUint8L(aNumber); return aStream;}
inline RWriteStream& operator<<(RWriteStream& aStream, TOplField::TDevice aDevice) {aStream.WriteUint8L(aDevice);return aStream;}
inline RWriteStream& operator<<(RWriteStream& aStream, COplSymbol* aSymbol){aStream.WriteUint32L(TUint32(aSymbol));return aStream;}

// Used to shift and encode the number of bits in the offset
const TInt KOplPcodeTCodeMask=0x3f;
const TInt KOplPcodeSizeMask=0xc0;
const TInt KOplPcodeSizeShift=6;
class TPcode
	{
public:
	enum TCode // Tokens in the Parse code
		{
		// Used to mark statement starts for the debugger
		EStatement,
		
		// Various operand references
		EConstant, EIdentifier, EField,EEvalIdentifier,
		
		// Proc, Function & OPX calls.
		EProcCallName,		// Marks the name for call by name.
		EArgList,			// Marks the start of an argument list
		EProcArg, EOpxArg, EFunctionArg, // Argument types
		
		EProcCall, EProcByNameCall, EOpxCall, // The actual calls
		EFixedFunctionCall, ECountedFunctionCall,

		// Operator and expression stuff
		EDrop, EAssign, ECast, EOperator,

		// Command keywords 
		ECommand, ETypedCommand, EQualifiedCommand,
		EFieldName, EEndFieldList, // Fields name for Open, Create etc
		
		// Structural stuff
		ELabel, EBranchFalse, EBranchAlways, EOnErr,
		EVector, EVectorLabel, EEndVector
		};
public:
	inline TPcode::TPcode() {}
	inline TPcode::TPcode(TPcode::TCode aCode,TUint32 anOffset) : iCode(aCode), iOffset(anOffset) {}
	inline TPcode::TCode Code() { return iCode;}
	inline TUint32 Offset() { return iOffset;}
	void ExternalizeL(RWriteStream& aStream) const; // Should be needed outside the parser
	IMPORT_C void InternalizeL(RReadStream& aStream); // Needed by anyone writing a back end
	// Some odds an ends enums
	enum TIdentifierSide {ELeft, ERight};
private:
	enum TOffsetSize {EOffset8Bits=0,EOffset16Bits=(1<<KOplPcodeSizeShift), EOffset32Bits=(2<<KOplPcodeSizeShift) };
private:
	TCode iCode; // actual Pcode
	TUint32 iOffset; // Corresponding offset in the source code
	};

inline RReadStream& operator>>(RReadStream& aStream, TPcode::TIdentifierSide& aSide) { aSide=TPcode::TIdentifierSide(aStream.ReadUint8L()); return aStream;}
inline RWriteStream& operator<<(RWriteStream& aStream, TPcode::TIdentifierSide aSide) { aStream.WriteUint8L(aSide); return aStream;}
//////////////////////////////////////////////////////////////////
//
// Things useful for reading Pcode.
//
//////////////////////////////////////////////////////////////////
class CPcodeConstant : public CBase
	{
public:
	IMPORT_C static CPcodeConstant *CPcodeConstant::NewLC(RReadStream& aStream);
	IMPORT_C ~CPcodeConstant();
	inline TOplToken::TType Type() const { return iType;}
	inline TInt Int() const { return iInt;}
	inline TReal64 Real() const { return iReal;}
	inline const TDesC& String() const { return *iString;}
private:
	CPcodeConstant() {;}
private:
	TOplToken::TType iType;
	union
		{
		TInt iInt;
		TReal64 iReal;
		HBufC* iString;
		};
	};

class TPcodeSymbolReference
	{
public:
	IMPORT_C void InternalizeL(RReadStream& aStream);
	inline TPcode::TIdentifierSide Side() const { return iSide;}
	inline COplSymbol* Symbol() const { return iSymbol;}
private:
	TPcode::TIdentifierSide iSide;
	COplSymbol* iSymbol;
	};

class CPcodeFieldReference : public CBase
	{
public:
	IMPORT_C static CPcodeFieldReference* CPcodeFieldReference::NewLC(RReadStream& aStream);
	IMPORT_C ~CPcodeFieldReference();
	inline TOplField::TDevice Device() const { return iDevice;}
	inline TOplToken::TType Type() const { return iType;}
	inline const TDesC& Name() const { return *iName;}
	inline TPcode::TIdentifierSide Side() const { return iSide;}
private:
	CPcodeFieldReference() {;}
private:
	TOplField::TDevice iDevice;
	TOplToken::TType iType;
	HBufC* iName;
	TPcode::TIdentifierSide iSide;
	};

class TPcodeCallArgument
	{
public:		
	inline void InternalizeL(RReadStream& aStream) { iType=TOplSignature::TArgType(aStream.ReadUint8L());}
	inline TOplSignature::TArgType Type() const { return iType;}
private:
	TOplSignature::TArgType iType;
	};

class TPcodeCall
	{
public:
	inline void InternalizeL(RReadStream& aStream) { iSymbol=(COplCallSymbol *)(aStream.ReadUint32L());}
	inline COplCallSymbol* Symbol() const {return iSymbol;}
private:
	COplCallSymbol *iSymbol;
	};

class TPcodeProcByName
	{
public:	
	IMPORT_C void InternalizeL(RReadStream& aStream);
	inline TInt ArgumentCount() const { return iArgumentCount;}
	inline TOplToken::TType Type() const { return iType;}
private:
	TInt iArgumentCount;
	TOplToken::TType iType;
	};

class TPcodeFunctionCall
	{
public:
	IMPORT_C void InternalizeL(RReadStream& aStream);
	inline TOplFunction::TNumber Number() const  { return iNumber;} 
	inline TOplToken::TType Type() const { return iType;}
	inline TUint ArgumentCount() const  {return iArgumentCount;}
private:
	TOplFunction::TNumber iNumber;
	TOplToken::TType iType;
	TUint iArgumentCount;
	};

class TPcodeDrop
	{
public:
	inline void InternalizeL(RReadStream& aStream) {aStream>>iType;}
	inline TOplToken::TType Type() const { return iType;}
private:
	TOplToken::TType iType;
	};

class TPcodeAssign
	{
public:
	inline void InternalizeL(RReadStream& aStream) {aStream>>iType;}
	inline TOplToken::TType Type() const { return iType;}
private:
	TOplToken::TType iType;
	};

class TPcodeCast
	{
public:
	inline void InternalizeL(RReadStream& aStream) { aStream>>iFrom>>iTo;}
	inline TOplToken::TType From() const { return iFrom;}
	inline TOplToken::TType To() const{ return iTo;}
private:
	TOplToken::TType iFrom;
	TOplToken::TType iTo;
	};

class TPcodeOperator
	{
public:
	IMPORT_C void InternalizeL(RReadStream& aStream);
	enum TArity { EUnary, EBinary };
	inline TOplToken::TValue Oper() const { return TOplToken::TValue(iOper);}
	inline TOplToken::TType OperandType() const { return iOperandType;}
	inline TOplToken::TType ResultingType() const { return iResultingType;}
	inline TPcodeOperator::TArity Arity() const { return iArity;}
private:
	TOplToken iOper;
	TOplToken::TType iOperandType;
	TOplToken::TType iResultingType;
	TPcodeOperator::TArity iArity;
	};
inline RReadStream& operator>>(RReadStream& aStream, TPcodeOperator::TArity& anAry) { anAry=TPcodeOperator::TArity(aStream.ReadUint8L()); return aStream;}
inline RWriteStream& operator<<(RWriteStream& aStream, TPcodeOperator::TArity anAry) { aStream.WriteUint8L(anAry); return aStream;}

class TPcodeCommand
	{
public:
	inline void InternalizeL(RReadStream& aStream) {aStream>>iCode;}
	inline TOplKeyword::TCode Code() const { return iCode;}	
private:
	TOplKeyword::TCode iCode;
	};

class TPcodeTypedCommand : public TPcodeCommand
	{
public:
	IMPORT_C void InternalizeL(RReadStream& aStream);
	inline TOplToken::TType Type() const { return iType;}
private:
	TOplToken::TType iType;
	};

class TPcodeQualifiedCommand : public TPcodeCommand
	{
public:
	IMPORT_C void InternalizeL(RReadStream& aStream);
	inline TUint Qualifier() const { return iQualifier;}
private:
	TUint32 iQualifier;
	};


class TPcodeLabel
	{
public:
	inline void InternalizeL(RReadStream& aStream) { iSymbol=(COplLabelSymbol *)aStream.ReadUint32L();}	
	inline COplLabelSymbol* Symbol() const { return iSymbol;}
private:
	COplLabelSymbol* iSymbol;
	};

class CPcodeFieldName : public CBase
	{
public:	
	IMPORT_C static CPcodeFieldName* NewLC(RReadStream& aStream);
	IMPORT_C ~CPcodeFieldName();
	inline const TDesC& Name() const { return *iName;}
	inline TOplToken::TType Type() const { return iType;}
private:
	CPcodeFieldName() {;}
private:
	HBufC * iName;
	TOplToken::TType iType;
	};
////////////////////////////////////////////////////////////
//
// COplModuleBackEnd - Pure virtual base class for 
// all Module translator back ends.
//
///////////////////////////////////////////////////////////
class MTranAppCB;
class COplModuleLexer;
class COplModuleBackEnd : public CBase
   {
public:
	virtual void StartL(const TDesC& aSourceName, CTextTranslator::TDebugFlag aDebugFlag,TSourceTranslateError& anError)=0;
	virtual COplParseApp* GetAppLC(TOplTranTarget aTarget,COplLexerBase& aLexer)=0;
	virtual void AppL(COplParseApp* anApp)=0;		// App Declaration
	virtual void OpxL(COplParseOpx* anOpx)=0;		// Opx Declaration
	virtual TInt OpxCount()=0;							// Number of OPX's seen so far.
	virtual void StartProcL(const TDesC& aName, TInt aLineNumber, TInt aQcodeOffset)=0;
	virtual void ProcL(COplProcHeader* aHeader,CBufSeg* aCodeBlock)=0;	// Proc declaration
	virtual void EndOfFileL()=0;
	};
#include <oplbacke.inl>
#endif