main.h

asn格式文件的编译器

/*
 * main.h
 *
 * PWLib application header file for asnparser
 *
 * ASN.1 compiler to produce C++ classes.
 *
 * Copyright (c) 1997-1999 Equivalence Pty. Ltd.
 *
 * Copyright (c) 2001 Institute for Information Industry, Taiwan, Republic of China 
 * (http://www.iii.org.tw/iiia/ewelcome.htm)
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is ASN Parser.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Portions of this code were written with the assisance of funding from
 * Vovida Networks, Inc. http://www.vovida.com.
 *
 * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
 * All Rights Reserved.
 *
 * Contributor(s): ___________________.
 *
 * $Log: main.h,v $
 * Revision 1.3  2002/07/02 02:03:26  mangelo
 * Remove Pwlib dependency
 *
 * Revision 1.2  2001/09/07 22:39:17  mangelo
 * add Log keyword substitution
 *
 *
 * May 3, 2001 Huang-Ming Huang
 *   Fixed the problem with my wrong interpretation to varaible constraint.
 *
 * March, 2001 Huang-Ming Huang
 *            Add support for Information Object Class and generate code that follows
 *            X/Open ASN.1/C++ interface.
 *
 */

#ifndef _MAIN_H
#define _MAIN_H

#if defined(_MSC_VER) && (_MSC_VER <=1200)
#pragma warning(disable:4786)
#endif
#include <stdio.h>
#include <vector>
#include <list>
#include <map>
#include <functional>
#include <stack>
#include <string>
#include <iostream>
#include <boost/smart_ptr.hpp>
#include <boost/cstdint.hpp>

extern unsigned lineNumber;
extern std::string  fileName;
extern FILE * yyin;
extern FILE * idin;
extern int yyparse();
extern int idparse();

void yyerror(char * str);
void iderror(char * str);

/////////////////////////////////////////
//
//  standard error output from parser
//

enum StdErrorType { Warning, Fatal };

class StdError {
  public:
    StdError(StdErrorType ne) : e(ne) { }
    //StdError(StdErrorType ne, unsigned ln) : e(ne), l(ln) { }
    friend std::ostream & operator<<(std::ostream & out, const StdError & e);

  protected:
    StdErrorType e;
};


/////////////////////////////////////////
//
//  intermediate structures from parser
//

typedef std::vector<std::string> StringList;

class NamedNumber ////: public PObject
{
  public:
    NamedNumber(std::string * nam);
    NamedNumber(std::string * nam, int num);
    NamedNumber(std::string * nam, const std::string & ref);
    friend std::ostream& operator << (std::ostream &, const NamedNumber& );

    void SetAutoNumber(const NamedNumber & prev);
    const std::string & GetName() const { return name; }
    int GetNumber() const { return number; }

  protected:
    std::string name;
    std::string reference;
    int number;
    bool autonumber;
};

class Printable {
public:
	virtual void PrintOn(std::ostream &) const=0;
};

inline std::ostream& operator << (std::ostream& os, const Printable& obj)
{
	obj.PrintOn(os);
	return os;
}

//PLIST(NamedNumberList, NamedNumber);
typedef boost::shared_ptr<NamedNumber> NamedNumberPtr;
typedef std::list<NamedNumberPtr> NamedNumberList;


// Types

class TypeBase;
typedef boost::shared_ptr<TypeBase> TypePtr;
typedef std::vector<TypePtr> TypesVector;

class Tag : public Printable
{
  public:
    enum Type {
      Universal,
      Application,
      ContextSpecific,
      Private,
	  ImplicitType
    };
    enum UniversalTags {
      IllegalUniversalTag,
      UniversalBoolean,
      UniversalInteger,
      UniversalBitString,
      UniversalOctetString,
      UniversalNull,
      UniversalObjectId,
      UniversalObjectDescriptor,
      UniversalExternalType,
      UniversalReal,
      UniversalEnumeration,
      UniversalEmbeddedPDV,
      UniversalSequence = 16,
      UniversalSet,
      UniversalNumericString,
      UniversalPrintableString,
      UniversalTeletexString,
      UniversalVideotexString,
      UniversalIA5String,
      UniversalUTCTime,
      UniversalGeneralisedTime,
      UniversalGraphicString,
      UniversalVisibleString,
      UniversalGeneralString,
      UniversalUniversalString,
      UniversalBMPString = 30
    };
    enum Mode {
      Implicit,
      Explicit,
      Automatic
    };
    Tag(unsigned tagNum, Mode m);

    void PrintOn(std::ostream &) const;
	bool operator == (const Tag& other) const {
		return type == other.type && number == other.number && mode == other.mode;
	}

	bool operator != (const Tag& other) const {
		return !(*this == other);
	}

    Type type;
    unsigned number;
    Mode mode;

    static const char * classNames[];
    static const char * modeNames[];
};

class ValueSet;
class Constraint;
class Parameter;
class SizeConstraintElement;
class FromConstraintElement;
class SubTypeConstraintElement;

typedef boost::shared_ptr<ValueSet> ValueSetPtr;
typedef boost::shared_ptr<Constraint> ConstraintPtr;

class ConstraintElementBase : public Printable
{
  public:
    ConstraintElementBase();
	~ConstraintElementBase();

    void SetExclusions(boost::shared_ptr<ConstraintElementBase> excl) { exclusions = excl; }

    virtual void GenerateCplusplus(const std::string & fn, std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
	virtual void GetConstraint(std::string& ) const {}
    virtual bool ReferencesType(const TypeBase & type) const;

	virtual ValueSetPtr GetValueSetFromValueField(const std::string& field) const;
	virtual ValueSetPtr GetValueSetFromValueSetField(const std::string& field) const;
	virtual ConstraintPtr GetObjectSetFromObjectField(const std::string& field) const;
	virtual ConstraintPtr GetObjectSetFromObjectSetField(const std::string& field) const;

	virtual bool HasPERInvisibleConstraint(const Parameter&) const { return false;}
    virtual void GenerateObjectSetInstanceCode(const std::string& , std::ostream& ) const{}
    virtual void GenerateObjSetAccessCode(std::ostream& ){}
	virtual bool GetCharacterSet(std::string& characterSet) const;
	virtual const SizeConstraintElement* GetSizeConstraint() const;
	virtual const FromConstraintElement* GetFromConstraint() const;
    virtual const SubTypeConstraintElement* GetSubTypeConstraint() const;

	virtual void PrintOn(std::ostream&) {};
	
  protected:
    boost::shared_ptr<ConstraintElementBase> exclusions;
};

typedef boost::shared_ptr<ConstraintElementBase> ConstraintElementPtr;
typedef std::vector<ConstraintElementPtr> ConstraintElementVector;

class Constraint : public Printable
{
  public:
	Constraint(bool extend) : extendable(extend){};
    Constraint(ConstraintElementPtr& elmt);
	Constraint(std::auto_ptr<ConstraintElementVector> std, 
		       bool extend, 
			   std::auto_ptr<ConstraintElementVector> ext =
				std::auto_ptr<ConstraintElementVector>());

	Constraint(const Constraint& other);

    void PrintOn(std::ostream &) const;
	void PrintElements(std::ostream &) const;

    bool IsExtendable() const { return extendable; }
	void GetConstraint(std::string& str) const ; 
    void GenerateCplusplus(const std::string & fn, std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
    bool ReferencesType(const TypeBase & type) const;

	const ConstraintElementVector& GetStandardElements() const { return standard; }
	const ConstraintElementVector& GetExtensionElements() const { return extensions; }
	ConstraintElementVector& GetStandardElements() { return standard; }
	ConstraintElementVector& GetExtensionElements() { return extensions; }

	ValueSetPtr GetValueSetFromValueField(const std::string& field) const;
	ValueSetPtr GetValueSetFromValueSetField(const std::string& field) const;
	ConstraintPtr GetObjectSetFromObjectField(const std::string& field) const;
	ConstraintPtr GetObjectSetFromObjectSetField(const std::string& field) const;
	const SizeConstraintElement* GetSizeConstraint() const;
	const FromConstraintElement* GetFromConstraint() const;
    const SubTypeConstraintElement* GetSubTypeConstraint() const;

	void GetCharacterSet(std::string& characterSet) const;

	virtual std::auto_ptr<Constraint> Clone() const;
	bool HasPERInvisibleConstraint(const Parameter&) const;
    void GenerateObjectSetInstanceCode(const std::string& prefix, std::ostream& cxx) const;
    void GenerateObjSetAccessCode(std::ostream& );

  protected:
    ConstraintElementVector standard;
    bool                  extendable;
    ConstraintElementVector extensions;
};

typedef boost::shared_ptr<Constraint> ConstraintPtr;
typedef std::vector<ConstraintPtr> ConstraintList;

class ConstrainAllConstraintElement : public ConstraintElementBase
{
  public:
    ConstrainAllConstraintElement(ConstraintElementPtr excl);
	void PrintOn(std::ostream &) const{}
};



class ElementListConstraintElement : public ConstraintElementBase
{
  public:
    ElementListConstraintElement();
    ElementListConstraintElement(std::auto_ptr<ConstraintElementVector> list);
    void PrintOn(std::ostream &) const;
 
    virtual void GenerateCplusplus(const std::string & fn, std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
	virtual void GetConstraint(std::string& str) const;
    virtual bool ReferencesType(const TypeBase & type) const;
	const ConstraintElementVector& GetElements() const { return elements; } 

	virtual ValueSetPtr GetValueSetFromValueField(const std::string& field) const;
	virtual ValueSetPtr GetValueSetFromValueSetField(const std::string& field) const;
	virtual ConstraintPtr GetObjectSetFromObjectField(const std::string& field) const;
	virtual ConstraintPtr GetObjectSetFromObjectSetField(const std::string& field) const;
	virtual bool HasPERInvisibleConstraint(const Parameter&) const;
    virtual void GenerateObjectSetInstanceCode(const std::string& prefix, std::ostream& cxx) const;
    virtual void GenerateObjSetAccessCode(std::ostream& );

	virtual const SizeConstraintElement* GetSizeConstraint() const;
	virtual const FromConstraintElement* GetFromConstraint() const;

	void AppendElements(
		ConstraintElementVector::const_iterator first,
		ConstraintElementVector::const_iterator last
		);
  protected:
    ConstraintElementVector elements;
};


class ValueBase;
typedef boost::shared_ptr<ValueBase> ValuePtr;

class SingleValueConstraintElement : public ConstraintElementBase
{
  public:
    SingleValueConstraintElement(const ValuePtr& val);
    ~SingleValueConstraintElement();
    void PrintOn(std::ostream &) const;

    virtual void GenerateCplusplus(const std::string & fn, std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
	virtual void GetConstraint(std::string& str) const;
	
	const ValuePtr& GetValue() const { return value; }
	virtual bool HasPERInvisibleConstraint(const Parameter&) const;
	virtual bool GetCharacterSet(std::string& characterSet) const;

  protected:
    const ValuePtr value;
  private:
    SingleValueConstraintElement& operator = (const SingleValueConstraintElement&);
};


class ValueRangeConstraintElement : public ConstraintElementBase
{
  public:
    ValueRangeConstraintElement(ValuePtr lowerBound, ValuePtr upperBound);
    ~ValueRangeConstraintElement();
    void PrintOn(std::ostream &) const;
	void GenerateRange(std::ostream& strm);
	virtual void GetConstraint(std::string& str) const;

    virtual void GenerateCplusplus(const std::string & fn, std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const;
	virtual bool HasPERInvisibleConstraint(const Parameter&) const;
    virtual bool GetCharacterSet(std::string& characterSet) const;
  protected:
    ValuePtr lower;
    ValuePtr upper;
};



class SubTypeConstraintElement : public ConstraintElementBase
{
    //PCLASSINFO(SubTypeConstraintElement, ConstraintElementBase);
  public:
    SubTypeConstraintElement(TypePtr typ);
    ~SubTypeConstraintElement();
    void PrintOn(std::ostream &) const;
    void GenerateCplusplus(const std::string &, std::ostream &, std::ostream &, std::ostream &) const;
    virtual bool ReferencesType(const TypeBase & type) const;
	virtual bool HasPERInvisibleConstraint(const Parameter&) const;
	virtual void GetConstraint(std::string& str) const;
    virtual const SubTypeConstraintElement* GetSubTypeConstraint() const;
    std::string GetSubTypeName() const;
    const TypePtr GetSubType() const { return subtype;}
  protected:
    TypePtr subtype;
};


class NestedConstraintConstraintElement : public ConstraintElementBase
{
  public:
    NestedConstraintConstraintElement(ConstraintPtr con);
    ~NestedConstraintConstraintElement();

    virtual bool ReferencesType(const TypeBase & type) const;
	virtual bool HasPERInvisibleConstraint(const Parameter&) const;

  protected:
    ConstraintPtr constraint;
};