main.h

asn格式文件的编译器

{
  public:
    RemovedType(const TypeBase& type);
	virtual bool IsRemovedType() const { return true;}
    virtual const char * GetAncestorClass() const;
};

// Values

class ValueBase : public Printable
{
  public:
    void SetValueName(const std::string& name);
    const std::string & GetName() const { return valueName; }

    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
	virtual bool IsPERInvisibleConstraint(const Parameter&) const { return false;}

  protected:
    void PrintBase(std::ostream &) const;
    std::string valueName;
};

typedef std::vector<ValuePtr> ValuesList;

class DefinedValue : public ValueBase
{
    //PCLASSINFO(DefinedValue, ValueBase);
  public:
    DefinedValue(const std::string& name);
	DefinedValue(const ValuePtr&);
	DefinedValue(const std::string& name, const ValuePtr& );
    void PrintOn(std::ostream &) const;
    const std::string & GetReference() const { return referenceName; }
    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
	virtual bool IsPERInvisibleConstraint(const Parameter& param) const { return param.GetName() == referenceName;}
  protected:
    std::string referenceName;
    mutable ValuePtr actualValue;
    mutable bool unresolved;
};

class ImportedValue : public DefinedValue
{
public:
	ImportedValue(const std::string& modName, const std::string& name, const ValuePtr& v)
		: DefinedValue(name, v), moduleName(modName){}
	const std::string& GetModuleName() const { return moduleName; }
private:
	std::string moduleName;
};


class BooleanValue : public ValueBase
{
  public:
    BooleanValue(bool newVal);
    void PrintOn(std::ostream &) const;
    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
  protected:
    bool value;
};


class IntegerValue : public ValueBase
{
  public:
    IntegerValue(boost::int64_t newVal);
    void PrintOn(std::ostream &) const;
    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;

    operator boost::int64_t() const { return value; }
    operator long() const { return (long)value; }

  protected:
    boost::int64_t value;
};


class RealValue : public ValueBase
{
  public:
    RealValue(double newVal);
	void PrintOn(std::ostream &) const {}
  protected:
    double value;
};


class OctetStringValue : public ValueBase
{
  public:
    OctetStringValue() { }
    OctetStringValue(const std::string& newVal);
	void PrintOn(std::ostream &) const {}
  protected:
	  std::vector<char> value;
};


class BitStringValue : public ValueBase
{
  public:
    BitStringValue() { }
    BitStringValue(const std::string& newVal);
    BitStringValue(StringList * newVal);
	void PrintOn(std::ostream &) const{}
  protected:
    std::vector<char> value;
};


class NullValue : public ValueBase
{
public:
	void PrintOn(std::ostream &) const {}
};


class CharacterValue : public ValueBase
{
  public:
    CharacterValue(char c);
    CharacterValue(char t1, char t2);
    CharacterValue(char q1, char q2, char q3, char q4);
    void PrintOn(std::ostream &) const;
    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
    unsigned GetValue() const { return value;}
  protected:
    unsigned value;
};


class CharacterStringValue : public ValueBase
{
  public:
    CharacterStringValue() { }
    CharacterStringValue(const std::string& newVal);
    CharacterStringValue(StringList& newVal);
    void PrintOn(std::ostream &) const;
    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
	void GetValue(std::string& v) const;
  protected:
    std::string value;
};


class ObjectIdentifierValue : public ValueBase
{
  public:
    ObjectIdentifierValue(const std::string& newVal);
    ObjectIdentifierValue(StringList& newVal);
    void PrintOn(std::ostream &) const;
  protected:
    StringList value;
};


class MinValue : public ValueBase
{
  public:
    void PrintOn(std::ostream &) const;
    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
};


class MaxValue : public ValueBase
{
  public:
    void PrintOn(std::ostream &) const;
    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
};


class SequenceValue : public ValueBase
{
  public:
    SequenceValue(ValuesList * list = NULL);
    void PrintOn(std::ostream &) const;
  protected:
    ValuesList values;
};

class ChoiceValue : public ValueBase
{
  public:
    ChoiceValue(const TypePtr& typ, const std::string& fieldName, ValuePtr val)
	: type(typ), fieldname(fieldName), value(val) { }
    void PrintOn(std::ostream &) const;
    virtual void GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
  protected:
	const TypePtr type;
	std::string fieldname;
	ValuePtr value;
private:
	ChoiceValue& operator = (const ChoiceValue&);
};

// ValueSet
class ValueSet : public Printable
{
public:
	virtual void Union(ValueSetPtr&)=0;
	virtual void Intersect(ValueSetPtr&)=0;
	virtual TypePtr MakeValueSetType()=0;
	virtual TypePtr GetType()=0;
	virtual ConstraintElementVector* GetElements()=0;
	virtual void ResolveReference() const {}
};

class ValueSetDefn : public ValueSet
{
public:
	ValueSetDefn();
	ValueSetDefn(TypePtr type, ConstraintPtr cons);
	~ValueSetDefn();

	void Union(ValueSetPtr&);
	void Intersect(ValueSetPtr&);
	TypePtr MakeValueSetType();
	void PrintOn(std::ostream & ) const;

	TypePtr GetType() { return type;}
	ConstraintElementVector* GetElements() { return elements.get();}
    void ResolveReference() const;
protected:
	TypePtr type;
	std::auto_ptr<ConstraintElementVector> elements;
    bool extendable;
};



class ObjectSetConstraintElement;
class ValueSetFromObject : public ValueSet
{
public:
	ValueSetFromObject(InformationObjectPtr obj, const std::string& fld);
	~ValueSetFromObject();
	void Union(ValueSetPtr&);
	void Intersect(ValueSetPtr&);
	TypePtr MakeValueSetType();
	void PrintOn(std::ostream & ) const;

	TypePtr GetType() ;
	ConstraintElementVector* GetElements() ;
protected:
	ValueSetPtr GetRepresentation();

	InformationObjectPtr object;
	std::string field;
	ValueSetPtr rep;
};

typedef boost::shared_ptr<ObjectSetConstraintElement> ObjectSetConstraintElementPtr;

class ValueSetFromObjects : public ValueSet
{
public:
	ValueSetFromObjects(ObjectSetConstraintElementPtr objSet, 
						const std::string& fld);
	~ValueSetFromObjects();
	void Union(ValueSetPtr&);
	void Intersect(ValueSetPtr&);
	TypePtr MakeValueSetType();
	void PrintOn(std::ostream & ) const;

	TypePtr GetType();
	ConstraintElementVector* GetElements();
protected:
	ValueSetPtr GetRepresentation();

	ObjectSetConstraintElementPtr objectSet;
	std::string field;
	ValueSetPtr rep;
};

// object class
class FieldSetting;

typedef boost::shared_ptr<FieldSetting> FieldSettingPtr;
typedef std::vector<FieldSettingPtr> FieldSettingList;

class FieldSpec;
//PLIST(FieldSpecsList, FieldSpec);
typedef boost::shared_ptr<FieldSpec> FieldSpecPtr;
typedef std::vector<FieldSpecPtr> FieldSpecsList;

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

	bool IsOptional() const { return isOptional; }
	virtual bool HasDefault() const =0;
	const std::string& GetName() const { return name; }
	const std::string& GetIdentifier() const { return identifier;}
	virtual std::string GetField() const = 0;

	virtual void EstablishFieldRelation(FieldSpecsList* ){}
	virtual void BeginParseSetting(FieldSettingList* ) const {}
	virtual void EndParseSetting() const {}

	virtual int GetToken() const = 0;
	void PrintOn(std::ostream &) const;

	virtual void ResolveReference() const {};

	// used only for FixedTypeValueField and FixedTypeValueSetField
	virtual TypeBase* GetFieldType() { return NULL;}
	virtual const TypeBase* GetFieldType() const { return NULL; }

	// 

	virtual bool GetKey(TypePtr& , std::string& ) { return false;}
	virtual void FwdDeclare(std::ostream& ) const {}
	virtual void Generate_info_type_constructor(std::ostream&) const {}
	virtual void Generate_info_type_memfun(std::ostream& ) const {}
	virtual void Generate_info_type_mem(std::ostream& ) const {}

	virtual void Generate_value_type(std::ostream& ) 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:

	std::string name;
	std::string identifier;
	bool isOptional;
};

class TypeFieldSpec : public FieldSpec
{
public:
	TypeFieldSpec(const std::string& nam, bool optional = false, TypePtr defaultType= TypePtr());
	~TypeFieldSpec();
	virtual bool HasDefault() const;
	std::string GetField() const;
	std::string GetDefault() const ;
	TypePtr GetDefaultType();
	virtual int GetToken() const;
    void PrintOn(std::ostream &) const;
	virtual void ResolveReference() 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:
	TypePtr type;
};

class FixedTypeValueFieldSpec : public FieldSpec
{
public:
	FixedTypeValueFieldSpec(const std::string& nam, TypePtr t, bool optional = false,
		bool unique = false);
	~FixedTypeValueFieldSpec();

	virtual bool HasDefault() const;
	void SetDefault(ValuePtr value);
	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 bool GetKey(TypePtr& keyType, std::string& keyName);
	virtual TypeBase* GetFieldType() ;
	virtual const TypeBase* GetFieldType() const;

protected:
	bool isUnique;
	TypePtr  type;
	ValuePtr defaultValue;
};

class FixedTypeValueSetFieldSpec : public FieldSpec
{
public:
	FixedTypeValueSetFieldSpec(const std::string& nam, TypePtr t, bool optional = false);
	~FixedTypeValueSetFieldSpec();

	virtual bool HasDefault() const;
	void SetDefault(ValueSetPtr valueSet){ defaultValueSet = valueSet; }
	std::string GetField() const { return type->GetName();}
	virtual void BeginParseSetting(FieldSettingList*) const ;
	virtual void EndParseSetting() const ;
	virtual int GetToken() const;

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

	virtual TypeBase* GetFieldType() ;
	virtual const TypeBase* GetFieldType() const ;

protected:
	TypePtr  type;
	ValueSetPtr defaultValueSet;
};

class VariableTypeValueFieldSpec : public FieldSpec
{
public: