main.cxx

asn格式文件的编译器

	else
		return true;
}

const std::string& DefinedType::GetCModuleName() const
{
	if (GetName() == "" )
	{
		ResolveReference();
		if (baseType.get())
			baseType->GetCModuleName();
	}
	return module->GetCModuleName();
}

TypeBase::RemoveReuslt DefinedType::CanRemoveType(const TypeBase& type) 
{
    return ReferencesType(type) ? MAY_NOT : OK;
}

bool DefinedType::RemoveThisType(const TypeBase& type)
{
    return ReferencesType(type);
}

std::string DefinedType::GetPrimitiveType() const
{
    if (baseType.get())
    {
      std::string result = baseType->GetPrimitiveType();   
      if (result.find("::const_reference") != -1)
          result = GetIdentifier() + "::const_reference";
      else if (result.find("::value_type::") != -1)
			result = GetIdentifier() + result.substr(result.find(':'));
      return result;
    }
    else
        return TypeBase::GetPrimitiveType();
}

bool DefinedType::NeedGenInfo() const 
{ 
    return TypeBase::NeedGenInfo() || !constraints.empty();
}

void DefinedType::GenerateInfo(const TypeBase* type, std::ostream& hdr, std::ostream& cxx)
{
	if (baseType.get())
		baseType->GenerateInfo(type, hdr, cxx);
}

TypePtr DefinedType::FlattenThisType(TypePtr& self, const TypeBase & parent)
{
	TypePtr result = self;
    if (NeedGenInfo())
    {
        if (parent.HasParameters())
        {
            size_t i;
            const SubTypeConstraintElement*  subcons = NULL;
            for (i=0; i != constraints.size(); ++i)
                if ((subcons = constraints[i]->GetSubTypeConstraint()) != NULL)
                {
                    const TypePtr subtype = subcons->GetSubType();
                    ParameterListRep paramList= parent.GetParameters().rep;
                    for (i = 0; i < paramList.size(); ++i)
                    {
                        if (paramList[i]->GetName() == subtype->GetTypeName())
                        {
                            parameters.rep.push_back(paramList[i]);
							result.reset(
								new ParameterizedType(self, 
								                      parent, 
													  *parameters.MakeActualParameters()));
                            return result;
                        }
                    }
					break;
                }
        }
		result.reset(new DefinedType(self, parent));
    }
    return result;
}

/////////////////////////////////////////////////////////

ParameterizedType::ParameterizedType(const std::string& name, ActualParameterList& args)
  : DefinedType(name)
{
  arguments.swap(args);
}

ParameterizedType::ParameterizedType(TypePtr& refType, 
									 const TypeBase& parent, 
									 ActualParameterList& args)
  : DefinedType(refType, parent)
{
  arguments.swap(args);
}


void ParameterizedType::PrintOn(std::ostream & strm) const
{
  PrintStart(strm);
  strm << referenceName << " { ";
  for (size_t i = 0; i < arguments.size(); i++) {
    if (i > 0)
      strm << ", ";
    strm << *arguments[i];
  }
  strm << " }";
  PrintFinish(strm);
}


bool ParameterizedType::IsParameterizedType() const
{
  return true;
}


bool ParameterizedType::ReferencesType(const TypeBase & type) const
{

  if (std::find_if(arguments.begin(), arguments.end(),
	  boost::bind(&ActualParameter::ReferencesType, _1, boost::cref(type))) != arguments.end())
	  return true;
  return DefinedType::ReferencesType(type);
}

bool ParameterizedType::UseType(const TypeBase & type) const
{

  if (std::find_if(arguments.begin(), arguments.end(),
	  boost::bind(&ActualParameter::UseType, _1, boost::cref(type))) != arguments.end())
	  return true;

  return DefinedType::UseType(type);
}

std::string ParameterizedType::GetTypeName() const
{
  std::string typeName = DefinedType::GetTypeName();
  if (IsParameterizedType()) {
    typeName += '<';
    for (size_t i = 0; i < arguments.size(); ++i) {
      if (arguments[i]->GenerateTemplateArgument(typeName))
        typeName += ", ";
    }
    typeName[typeName.size()-2] = '>';
  }
  return typeName;
}

TypeBase::RemoveReuslt ParameterizedType::CanRemoveType(const TypeBase& type)
{

  if (std::find_if(arguments.begin(), arguments.end(),
	  boost::bind(&ActualParameter::ReferencesType, _1, boost::cref(type))) != arguments.end())
	  return FORBIDDEN;

  return DefinedType::CanRemoveType(type);
}


/////////////////////////////////////////////////////////

SelectionType::SelectionType(const std::string& name, TypePtr base)
  : TypeBase(Tag::IllegalUniversalTag, Module),
    selection(name)
{
  assert(base.get());
  baseType = base;
}


SelectionType::~SelectionType()
{
}


void SelectionType::PrintOn(std::ostream & strm) const
{
  PrintStart(strm);
  strm << selection << '<' << *baseType;
  PrintFinish(strm);
}


void SelectionType::FlattenUsedTypes()
{
	baseType = baseType->FlattenThisType(baseType, *this);
}


TypePtr SelectionType::FlattenThisType(TypePtr& self, const TypeBase & parent)
{
  return TypePtr(new DefinedType(self, parent));
}


void SelectionType::GenerateCplusplus(std::ostream &, std::ostream &, std::ostream &)
{
  std::cerr << StdError(Fatal) << "Cannot generate code for Selection type" << std::endl;
  isGenerated = true;
}


const char * SelectionType::GetAncestorClass() const
{
  return "";
}


bool SelectionType::CanReferenceType() const
{
  return true;
}


bool SelectionType::ReferencesType(const TypeBase & type) const
{
  return baseType->ReferencesType(type);
}

bool SelectionType::UseType(const TypeBase& type) const 
{
  return baseType->UseType(type);
}


/////////////////////////////////////////////////////////

BooleanType::BooleanType()
  : TypeBase(Tag::UniversalBoolean, Module)
{
}


void BooleanType::GenerateOperators(std::ostream & hdr, std::ostream & , const TypeBase & actualType)
{
  Indent indent(hdr.precision());
  hdr << indent << "    " << actualType.GetIdentifier() << " & operator=(bool v)";
  hdr << " { BOOLEAN::operator = (v);  return *this; }\n";
}


const char * BooleanType::GetAncestorClass() const
{
  return "ASN1::BOOLEAN";
}


void BooleanType::GenerateConstructors(std::ostream & hdr, std::ostream & , std::ostream & )
{
  Indent indent(hdr.precision()+4) ;
  hdr << indent << GetIdentifier() << "(bool b = false) : Inherited(b, &theInfo) {}\n";
  hdr << indent << GetIdentifier() << "(const void* info) : Inherited(info) {}\n";
}


/////////////////////////////////////////////////////////

IntegerType::IntegerType()
  : TypeBase(Tag::UniversalInteger, Module)
{
}


IntegerType::IntegerType(NamedNumberList& lst)
  : TypeBase(Tag::UniversalInteger, Module)
{
  allowedValues.swap(lst);
}

const char * IntegerType::GetAncestorClass() const
{
  return "ASN1::INTEGER";
}

void IntegerType::GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl)
{
    Indent indent(hdr.precision());
	if (!allowedValues.empty()  )
	{
		BeginGenerateCplusplus(hdr, cxx, inl);

		int maxEnumValue = 0;
		NamedNumberList::iterator first, last = allowedValues.end();
		for (first = allowedValues.begin() ; first != last ; ++first) {
			int num = (*first)->GetNumber();
			if (maxEnumValue < num)
				maxEnumValue = num;
		}
		
		// Generate enumerations and complete the constructor implementation
		hdr << indent << "    enum NamedNumber {\n";

		
		int prevNum = -1;
		for (first = allowedValues.begin() ; first != last ; ++first) {
			if (first != allowedValues.begin()) {
				hdr << ",\n";
			}
			
			hdr << indent << "      " << MakeIdentifierC((*first)->GetName());
			
			int num = (*first)->GetNumber();
			if (num != prevNum+1) {
				hdr << " = " << num;
			}
			prevNum = num;
			
		}

		hdr << "\n"
			<< indent << "    };\n"
			"\n";

		for (first = allowedValues.begin() ; first != last ; ++first) {
			std::string name = MakeIdentifierC((*first)->GetName());
			hdr << indent +4 << "bool is_" << name << "() const { return value == " << name << "; }\n"
				<< indent +4 << "void set_" << name << "() { value = " << name << "; }\n\n";
		}


		EndGenerateCplusplus(hdr, cxx, inl);
	}
	else 
	{
		TypeBase::GenerateCplusplus(hdr, cxx, inl);
		/*
		if (type->GetConstraints().size())
		{
			hdr << indent << "enum {\n"
				<< indent << "  LowerLimit = " <<  << ",\n"
				<< indent << "  UpperLimit = " <<  << ",\n"
				<< indent << "};\n";
		}
		*/
	}

}

void IntegerType::GenerateInfo(const TypeBase* type, std::ostream& hdr , std::ostream& cxx)
{
    Indent indent(hdr.precision()+4);
    hdr << indent << dllMacroExport << "static const InfoType theInfo;\n";
	if ( !allowedValues.empty()  )
    {
		hdr	<< indent -2 << "private:\n"
			<< "#ifdef ASN1_HAS_IOSTREAM\n"
			<< indent << "static const NameEntry nameEntries[" << allowedValues.size() << "];\n"
			<< "#endif\n";

        cxx << "#ifdef ASN1_HAS_IOSTREAM\n"
			<< type->GetTemplatePrefix()
            << "const " << type->GetClassNameString() << "::NameEntry " << type->GetClassNameString() 
			<< "::nameEntries[" << allowedValues.size() << "] = {\n";

		NamedNumberList::iterator itr, last = allowedValues.end();
		for (itr = allowedValues.begin() ; itr != last ; ++itr ) {
			if (itr != allowedValues.begin())
				cxx << ",\n";

			cxx << "    { " << (*itr)->GetNumber() << ", \"" 
				        << (*itr)->GetName() << "\"}";

		}
			
		cxx << "\n"
			<< "};\n"
			<< "#endif\n\n";
	}
		



    cxx << type->GetTemplatePrefix()
        << "const " ;

   if (type->GetTemplatePrefix().length())
	   cxx << "typename ";

   cxx  << type->GetClassNameString() << "::InfoType " << type->GetClassNameString() << "::theInfo = {\n"
        << "    create,\n" ;

    cxx << "    ";

    type->GenerateTags(cxx);

    cxx << ",\n"
        << "    ";

	if (type->GetConstraints().size())
	{
		std::string strm;
		type->GetConstraints()[0]->GetConstraint(strm);
		cxx << strm;
	}
	else
		cxx << "ASN1::Unconstrained, 0, UINT_MAX";

    cxx << "\n";
	if ( allowedValues.size()  )
    {
        cxx << "#ifdef ASN1_HAS_IOSTREAM\n"
            << "    , nameEntries, " << allowedValues.size() << "\n"
			<< "#endif\n";
    }

    cxx << "};\n\n";
}


std::string IntegerType::GetTypeName() const
{
	if (allowedValues.size())
		return "ASN1::IntegerWithNamedNumber";
	if (constraints.size())
	{
		std::string result("ASN1::Constrained_INTEGER<");
		constraints[0]->GetConstraint(result);
		result += "> ";
		return result;
	}
	else
		return GetAncestorClass();
}

void IntegerType::GenerateConstructors(std::ostream & hdr, std::ostream & , std::ostream & )
{
  Indent indent(hdr.precision() + 4) ;
  hdr << indent
	  << GetIdentifier() << "(value_type v = 0) : Inherited(v, &theInfo) { }\n" ;
}

bool IntegerType::NeedGenInfo() const 
{ 
    return TypeBase::NeedGenInfo() || allowedValues.size() > 0; 
}

TypePtr IntegerType::FlattenThisType(TypePtr& self, const TypeBase & parent)
{
	TypePtr result = self;
    if (NeedGenInfo() && parent.HasParameters())
    {
		size_t i;
		const SubTypeConstraintElement*  subcons = NULL;
		for (i=0; i != constraints.size(); ++i)
            if ((subcons = constraints[i]->GetSubTypeConstraint())!= NULL)
			{
				const TypePtr subtype = subcons->GetSubType();
				ParameterListRep paramList= parent.GetParameters().rep;
				for (size_t i = 0; i < paramList.size(); ++i)
				{
					if (paramList[i]->GetName() == subtype->GetTypeName())
					{
						parameters.rep.push_back(paramList[i]);
						result.reset(
							new ParameterizedType(self, 
												  parent, 
												  *parameters.MakeActualParameters()));
						return result;
					}
				}
				break;
			}
		result.reset(new DefinedType(self, parent));
    }
    return result;
}

bool IntegerType::CanReferenceType() const
{
	if (constraints.size())
		return true;
	return false;
}


bool IntegerType::ReferencesType(const TypeBase & type) const
{
	if (constraints.size())
		return constraints[0]->ReferencesType(type);
	else
		return false;
}

/////////////////////////////////////////////////////////

EnumeratedType::EnumeratedType(NamedNumberList& enums, bool extend, NamedNumberList* ext)
  : TypeBase(Tag::UniversalEnumeration, Module)
{
  enumerations.swap(enums);
  numEnums = enumerations.size();
  extendable = extend;
  if (ext != NULL) {
	enumerations.splice( enumerations.end(), *ext);
    delete ext;
  }
}


void EnumeratedType::PrintOn(std::ostream & strm) const
{
  PrintStart(strm);
  strm << '\n';

  size_t i;
  NamedNumberList::const_iterator itr, last = enumerations.end();
  for (i = 0, itr = enumerations.begin() ; i < numEnums; i++, ++itr)
    strm << indent() << **itr << '\n';

  if (extendable) {
    strm << "...\n";
    for (; itr != last; ++itr)
      strm << indent() << **itr << '\n';
  }
  PrintFinish(strm);
}


TypePtr EnumeratedType::FlattenThisType(TypePtr& self, const TypeBase & parent)
{
  return TypePtr(new DefinedType(self, parent));
}


void EnumeratedType::GenerateCplusplus(std::ostream & hdr, std::ostream & cxx, std::ostream & inl)
{
  maxEnumValue = 0;
  NamedNumberList::iterator itr, last = enumerations.end();


  for (itr = enumerations.begin(); itr != last; ++itr) {
    int num = (*itr)->GetNumber();
    if (maxEnumValue < num)
      maxEnumValue = num;
  }

  Indent indent(hdr.precision());

  BeginGenerateCplusplus(hdr, cxx, inl);
  
  // Generate enumerations and complete the constructor impl