main.h

asn格式文件的编译器

	VariableTypeValueFieldSpec(const std::string& nam, 
							   const std::string& fieldname, 
							   bool optional = false);
	~VariableTypeValueFieldSpec();

	virtual bool HasDefault() const;
	std::string GetField() const { return fieldName;}
	void SetDefault(ValuePtr value){ defaultValue = value;}
	virtual void EstablishFieldRelation(FieldSpecsList* specs);

	virtual void BeginParseSetting(FieldSettingList*) const ;
	virtual void EndParseSetting() const ;
	virtual int GetToken() const;

    void PrintOn(std::ostream &) const;
	virtual void ResolveReference() const;

protected:
	std::string fieldName;
	ValuePtr defaultValue;
	TypePtr defaultType;
};

class VariableTypeValueSetFieldSpec : public FieldSpec
{
public:
	VariableTypeValueSetFieldSpec(const std::string& nam, 
								  const std::string& fieldname, 
								  bool optional = false);
	~VariableTypeValueSetFieldSpec();

	virtual bool HasDefault() const;
	std::string GetField() const { return fieldName;}
	void SetDefault(ValueSetPtr valueSet){ defaultValueSet = valueSet; }
	virtual void EstablishFieldRelation(FieldSpecsList* specs);

	virtual void BeginParseSetting(FieldSettingList*) const ;
	virtual void EndParseSetting() const ;
	virtual int GetToken() const;

    void PrintOn(std::ostream &) const;
	virtual void ResolveReference() const;

protected:
	std::string fieldName;
	ValueSetPtr defaultValueSet;
};

class DefinedObjectClass;
typedef boost::shared_ptr<DefinedObjectClass> DefinedObjectClassPtr;
class ObjectFieldSpec : public FieldSpec
{
public:
	ObjectFieldSpec(const std::string& nam, 
					DefinedObjectClass* oclass,  
					bool optional = false); 
	~ObjectFieldSpec() ;

	virtual bool HasDefault() const;
	std::string GetField() const;
	void SetDefault(InformationObjectPtr dftObj);
	virtual void BeginParseSetting(FieldSettingList*) const ;
	virtual void EndParseSetting() const ;
	virtual int GetToken() const;

    void PrintOn(std::ostream &) const;
	virtual void ResolveReference() const;
protected:
	DefinedObjectClass* objectClass;
	InformationObjectPtr obj;
};

class ObjectSetFieldSpec : public FieldSpec
{
public:
    ObjectSetFieldSpec(const std::string& nam, 
				DefinedObjectClassPtr oclass,  
				bool optional = false);
    ~ObjectSetFieldSpec();

	virtual bool HasDefault() const;
	void SetDefault(ConstraintPtr dftObjSet){ objSet = dftObjSet;}
	std::string GetField() const;

	virtual void BeginParseSetting(FieldSettingList*) const ;
	virtual void EndParseSetting() const ;
	virtual int GetToken() const;

    void PrintOn(std::ostream &) const;
	virtual void ResolveReference() const;
	virtual void FwdDeclare(std::ostream& hdr) const ;
	virtual void Generate_info_type_constructor(std::ostream& ) const;
	virtual void Generate_info_type_memfun(std::ostream& hdr) const ;
	virtual void Generate_info_type_mem(std::ostream& ) const;
	virtual void Generate_value_type(std::ostream& hdr) const ;
	virtual void GenerateTypeField(const std::string& templatePrefix,
								   const std::string& classNameString,
								   const TypeBase* keyType,
								   const std::string& objClassName,
								   std::ostream& hdr, 
								   std::ostream& cxx, 
								   std::ostream& inl) const;
protected:
	DefinedObjectClassPtr objectClass;
	ConstraintPtr objSet;
};


class DefinedSyntaxToken;

class TokenOrGroupSpec : public Printable
{
public:
	virtual ~TokenOrGroupSpec(){};
	virtual bool ValidateField(FieldSpecsList* )=0;
	virtual bool HasLiteral(const std::string& str) const = 0;
	enum MakeDefaultSyntaxResult
	{
		FAIL, // indicate the make process fail
		CONSUMED_AND_EXHAUSTED,
		CONSUMED_AND_NOT_EXHAUSTED,
		NOT_CONSUMED
	};
	virtual MakeDefaultSyntaxResult  MakeDefaultSyntax(DefinedSyntaxToken* token, FieldSettingList* setting)=0;
	virtual void PreMakeDefaultSyntax(FieldSettingList* settings)=0;
	virtual void CancelMakeDefaultSyntax() const=0;
	virtual void Reset(){}
};

class Literal : public TokenOrGroupSpec
{
public:
	Literal(const std::string& str)
		: name(str ){ }
	Literal (const char* str): name(str){}
	virtual ~Literal(){};
    void PrintOn(std::ostream & strm) const ;
	virtual bool ValidateField(FieldSpecsList* ){ return true; }
	virtual MakeDefaultSyntaxResult  MakeDefaultSyntax(DefinedSyntaxToken* token, FieldSettingList* setting);
	virtual bool HasLiteral(const std::string& str) const { return str == name; } 
	virtual void PreMakeDefaultSyntax(FieldSettingList*){};
	virtual void CancelMakeDefaultSyntax() const {}

protected:
	std::string name;
};

class PrimitiveFieldName : public TokenOrGroupSpec
{
public:
	PrimitiveFieldName(const std::string& fieldname)
		: name(fieldname)
	{}
	PrimitiveFieldName(const char* fieldname) : name(fieldname){}
	PrimitiveFieldName(const PrimitiveFieldName& other){ name = other.name; field = other.field;}
	~PrimitiveFieldName(){};
    void PrintOn(std::ostream &) const ;
	virtual bool ValidateField(FieldSpecsList* fields);
	virtual MakeDefaultSyntaxResult  MakeDefaultSyntax(DefinedSyntaxToken* token, FieldSettingList* setting) ;
	virtual bool HasLiteral(const std::string&) const { return false; }
	virtual void PreMakeDefaultSyntax(FieldSettingList* settings);
	virtual void CancelMakeDefaultSyntax() const;
private:
	std::string name;
	FieldSpec* field;
};

typedef boost::shared_ptr<TokenOrGroupSpec> TokenOrGroupSpecPtr;
typedef std::vector<TokenOrGroupSpecPtr> TokenOrGroupSpecList;

class TokenGroup : public TokenOrGroupSpec
{
public:
	TokenGroup() : optional(false), cursor(0){}
	TokenGroup(const TokenGroup& other);
	~TokenGroup(){}
	void AddToken(TokenOrGroupSpecPtr token){ tokenOrGroupSpecList.push_back(token);}
	void SetOptional(){ optional = true;}
    void PrintOn(std::ostream &) const;
	bool ValidateField(FieldSpecsList* fields);
	MakeDefaultSyntaxResult  MakeDefaultSyntax(DefinedSyntaxToken* token, 
												FieldSettingList* setting);
	virtual bool HasLiteral(const std::string& str) const;
	virtual void PreMakeDefaultSyntax(FieldSettingList* settings);
	virtual void CancelMakeDefaultSyntax() const;

	size_t size() const { return tokenOrGroupSpecList.size(); }
	TokenOrGroupSpec& operator[](size_t i){ return *(tokenOrGroupSpecList[i]);}
	virtual void Reset();
private:
	TokenOrGroupSpecList tokenOrGroupSpecList;
	bool optional;
	size_t cursor;
};

typedef boost::shared_ptr<TokenGroup> TokenGroupPtr;

class DefaultSyntaxBuilder 
{
public:
	DefaultSyntaxBuilder(TokenGroupPtr tkGrp);
	~DefaultSyntaxBuilder();
	void AddToken(DefinedSyntaxToken* token);
	std::auto_ptr<FieldSettingList> GetDefaultSyntax();
	void ResetTokenGroup();
private:
	TokenGroupPtr tokenGroup;
	std::auto_ptr<FieldSettingList> setting;
};

class ObjectClassBase : public Printable
{
public:
	ObjectClassBase(){};
	ObjectClassBase(const std::string& nam){ SetName(nam); }
	virtual ~ObjectClassBase(){};

	void SetName(const std::string& nam);
	virtual const std::string& GetName() const { return name;}
    int GetFieldToken(const char* fieldname) const;
	virtual FieldSpec* GetField(const std::string& fieldName) =0;
	virtual const FieldSpec* GetField(const std::string& fieldName) const=0;
	virtual TypeBase* GetFieldType(const std::string& fieldName) { return GetField(fieldName)->GetFieldType(); }
	virtual const TypeBase* GetFieldType(const std::string& fieldName) const { return GetField(fieldName)->GetFieldType(); }
	virtual bool VerifyDefaultSyntax(FieldSettingList*) const = 0;
	virtual bool HasLiteral(const std::string& str) const = 0;
	virtual TokenGroupPtr GetWithSyntax() const = 0;
	virtual void PreParseObject() const = 0;
	virtual void BeginParseObject() const = 0;
	virtual void EndParseObject() const =0 ;
	virtual void BeginParseObjectSet() const = 0;
	virtual void EndParseObjectSet() const = 0;
	virtual void ResolveReference() const =0;
	virtual void GenerateCplusplus(std::ostream& , std::ostream& , std::ostream& ){}
	virtual const std::string& GetKeyName() const =0;
protected:
	std::string name;
};

typedef std::vector<ObjectClassBasePtr> ObjectClassesList;
class ObjectClassDefn : public ObjectClassBase
{
public:
	ObjectClassDefn();

	~ObjectClassDefn();

	void SetFieldSpecs(std::auto_ptr<FieldSpecsList> list);
	void SetWithSyntaxSpec(TokenGroupPtr list);

	FieldSpec* GetField(const std::string& fieldName);
	const FieldSpec* GetField(const std::string& fieldName) const;

	virtual bool VerifyDefaultSyntax(FieldSettingList*) const;
	virtual bool HasLiteral(const std::string& str) const { return withSyntaxSpec->HasLiteral(str);}
	virtual TokenGroupPtr GetWithSyntax() const;
	virtual void PreParseObject() const ;
	virtual void BeginParseObject() const;
	virtual void EndParseObject() const;
	virtual void BeginParseObjectSet() const;
	virtual void EndParseObjectSet() const;
    void PrintOn(std::ostream &) const;
	virtual void ResolveReference() const;

	void ResolveKey();
	const std::string& GetKeyName() const { return keyName; }
	void GenerateCplusplus(std::ostream& hdr, std::ostream& cxx, std::ostream& inl);
protected:
	std::auto_ptr<FieldSpecsList> fieldSpecs;
	TokenGroupPtr withSyntaxSpec;
	TypePtr keyType;
	std::string keyName;
};


class DefinedObjectClass : public ObjectClassBase
{
public:
	DefinedObjectClass(ObjectClassBase* ref);
	DefinedObjectClass(const std::string& nam, ObjectClassBase* ref = NULL);
	~DefinedObjectClass(){}

	const std::string& GetName() const { return referenceName;}
	ObjectClassBase* GetReference();
	const ObjectClassBase* GetReference() const;
	FieldSpec* GetField(const std::string& fieldName);
	const FieldSpec* GetField(const std::string& fieldName) const;
	virtual bool VerifyDefaultSyntax(FieldSettingList*) const;
	bool HasLiteral(const std::string& str) const;
	virtual TokenGroupPtr GetWithSyntax() const;
	virtual void PreParseObject() const ;
	virtual void BeginParseObject() const;
	virtual void EndParseObject() const;
	virtual void BeginParseObjectSet() const;
	virtual void EndParseObjectSet() const;
	void PrintOn(std::ostream& strm) const;
	virtual void ResolveReference() const;
	virtual TypeBase* GetFieldType(const std::string& fieldName) ;
	virtual const TypeBase* GetFieldType(const std::string& fieldName) const;
	const std::string& GetKeyName() const { return reference->GetKeyName(); }
protected:
	std::string referenceName;
	mutable ObjectClassBase* reference;
};

class ImportedObjectClass : public DefinedObjectClass
{
public:
	ImportedObjectClass(const std::string& modName, 
						const std::string& nam, 
						ObjectClassBase* ref)
		: DefinedObjectClass(nam, ref), moduleName(modName){}
	const std::string& GetModuleName() const { return moduleName;}
private:
	std::string moduleName;
};

class Setting : public Printable
{
public:

	enum 
	{
		has_type_setting = 0x01,
		has_value_setting = 0x02,
		has_valueSet_setting = 0x04,
		has_object_setting = 0x08,
		has_objectSet_setting = 0x10
	};
	virtual ~Setting(){};
	virtual void GenerateInfo(const std::string& , std::ostream&){}
	virtual void GenerateCplusplus(const std::string&, const std::string&, std::ostream& , std::ostream& , std::ostream& , unsigned& flag) =0;
	virtual void GenerateInitializationList(std::ostream& , std::ostream& , std::ostream& ){}
	virtual bool IsExtendable() const { return false;}
	virtual void GenerateInstanceCode(const std::string& , std::ostream& ) const{}
};

class TypeSetting : public Setting
{
public:
	TypeSetting(TypePtr typeBase){ type = typeBase; }
	~TypeSetting(){}

	TypePtr GetType() { return type;}
	const TypeBase* GetType() const { return type.get();}
    void PrintOn(std::ostream & strm) const;
	virtual void GenerateCplusplus(const std::string& prefix, const std::string& name, std::ostream& hdr, std::ostream& cxx, std::ostream& inl, unsigned& flag);
	virtual void GenerateInfo(const std::string& name,std::ostream& hdr);
protected:
	TypePtr type;
};


class ValueSetting : public Setting
{
public:
	ValueSetting(TypePtr typeBase, ValuePtr valueBase);
	~ValueSetting();

	ValuePtr GetValue() { return value;}
	const ValuePtr GetValue() const { return value;}
	TypePtr GetType() { return type;}
	const TypeBase* GetType() const { return type.get();}
    void PrintOn(std::ostream & strm) const;
	virtual void GenerateCplusplus(const std::string& prefix, const std::string& name, std::ostream& hdr, std::ostream& cxx, std::ostream& inl, unsigned& flag);
	virtual void GenerateInitializationList(std::ostream& , std::ostream& , std::ostream& );
protected:
	TypePtr  type;
	ValuePtr value;
};

class ValueSetSetting : public Setting
{
public:
	ValueSetSetting(ValueSetPtr set);
	~ValueSetSetting();

	ValueSetPtr GetValueSet() { return valueSet; }
	const ValueSetPtr GetValueSet() const { return valueSet; }
    void PrintOn(std::ostream & strm) const;
	virtual void GenerateCplusplus(const std::string& prefix, const std::string& name, std::ostream& hdr, std::ostream& cxx, std::ostream& inl, unsigned& flag);
protected:
	ValueSetPtr valueSet;
};

class InformationObject;
typedef boost::shared_ptr<InformationObject> InformationObjectPtr;
class ObjectSetting : public Setting
{
public:
	ObjectSetting(InformationObjectPtr obj, ObjectClassBase* objClass);
	~ObjectSetting();
	InformationObjectPtr GetObject() { return object; }
	const InformationObject* GetObject() const { return object.get(); }
    void PrintOn(std::ostream & strm) const ;
	virtual void GenerateCplusplus(const std::string& prefix, const std::string& name, std::ostream& hdr, std::ostream& cxx, std::ostream& inl, unsigned& flag);
protected:
	ObjectClassBase* objectClass;
	InformationObjectPtr object;
};

class ObjectSetSetting : public Setting
{
public:
	ObjectSetSetting(ConstraintPtr objSet, ObjectClassBase* objClass)
		: objectClass(objClass), objectSet(objSet) { }
	~ObjectSetSetting();
	ConstraintPtr GetObjectSet() { return objectSet;}
	const ConstraintPtr GetObjectSet() const { return objectSet; }
    void PrintOn(std::ostream &) const ;
	virtual void GenerateCplusplus(const std::