main.cxx

asn格式文件的编译器

  number = 0;
  autonumber = false;
}


std::ostream& operator << (std::ostream & strm, const NamedNumber& obj)
{
  strm << obj.name << " (";
  if (obj.reference.size()==0)
    strm << obj.number;
  else
    strm << obj.reference;
  strm << ')';
  return strm;
}


void NamedNumber::SetAutoNumber(const NamedNumber & prev)
{
  if (autonumber) {
    number = prev.number + 1;
    autonumber = false;
  }
}


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

Tag::Tag(unsigned tagNum, Mode m)
{
  type = Universal;
  number = tagNum;
  mode = m;
}


const char * Tag::classNames[] = {
  "UNIVERSAL", "APPLICATION", "CONTEXTSPECIFIC", "PRIVATE"
};


const char * Tag::modeNames[] = {
  "IMPLICIT", "EXPLICIT", "AUTOMATIC"
};


void Tag::PrintOn(std::ostream & strm) const
{
  if (type != Universal || number != IllegalUniversalTag) {
    strm << '[';
    if (type != ContextSpecific)
      strm << classNames[type] << ' ';
    strm << number << "] " << modeNames[mode] << ' ';
  }
}


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

Constraint::Constraint(ConstraintElementPtr& elmt)
{
  standard.push_back(elmt);
  extendable = false;
}


Constraint::Constraint(std::auto_ptr<ConstraintElementVector> std, 
					   bool extend, 
					   std::auto_ptr<ConstraintElementVector> ext)
{
  if (std.get() != NULL) {
	  standard.swap(*std);	
  }
  extendable = extend;
  if (ext.get() != NULL) {
	extensions.swap(*ext);
  }
}

Constraint::Constraint(const Constraint& other)
: standard(other.standard)
, extendable(other.extendable)
, extensions(other.extensions)
{
}



void Constraint::PrintOn(std::ostream & strm) const
{
  strm << '(';
  PrintElements(strm);
  strm << ')';
}

void PrintVector(std::ostream& strm ,const ConstraintElementVector& elements, char delimiter)
{
  ConstraintElementVector::const_iterator i = elements.begin(), e = elements.end();

	if (i != e)
	{
		(*i)->PrintOn(strm);
	     ++i;
	}

	for (; i != e; ++i)
	{
		strm << ' ' << delimiter << ' ';
		(*i)->PrintOn(strm);
	}
}

void Constraint::PrintElements(std::ostream & strm) const
{
  
  PrintVector(strm, standard, '|');
  if (extendable) {
    strm << indent();
    if (standard.size() > 0)
      strm << ", ";
    strm << "...";
	if (extensions.size() > 0)
		strm << ',';
	strm << ' ';

    PrintVector(strm, extensions, '|');
  }
}


void Constraint::GenerateCplusplus(const std::string & fn, std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const
{
  switch (standard.size()) {
    case 0 :
      return;
    case 1 :
      break;
    default :
		std::cerr << StdError(Warning) << "unsupported UNION constraints, ignored." << std::endl;
  }

  if (extensions.size() > 0)
	  std::cerr << StdError(Warning) << "unsupported extension constraints, ignored." << std::endl;

  std::string fn2 = fn;
  if (fn.find("ASN1::") == -1) {
    if (extendable)
      fn2 += "ASN1::ExtendableConstraint";
    else
      fn2 += "ASN1::FixedConstraint";
  }

  standard[0]->GenerateCplusplus(fn2, hdr, cxx, inl);

}

void Constraint::GetConstraint(std::string& str) const
{
  if (str.find("ConstrainedObject::, ") == -1 ) {
	if (extendable)
		str += "ASN1::ExtendableConstraint, ";
	else
		str += "ASN1::FixedConstraint, ";
  }
  standard[0]->GetConstraint(str);
}



bool Constraint::ReferencesType(const TypeBase & type) const
{
	ConstraintElementVector::size_type	i;

  for (i = 0; i < standard.size(); i++) {
    if (standard[i]->ReferencesType(type))
      return true;
  }

  for (i = 0; i < extensions.size(); i++) {
    if (extensions[i]->ReferencesType(type))
      return true;
  }

  return false;
}

ValueSetPtr Constraint::GetValueSetFromValueField(const std::string& field) const
{
	const ConstraintElementVector* vectors[] = {&standard,&extensions};
	ValueSetPtr result(new ValueSetDefn);

	for (int k = 0; k < 2; ++k)
	{
		ConstraintElementVector::const_iterator i = vectors[k]->begin(), e = vectors[k]->end();
		for (; i != e ; ++i)
		{
			ValueSetPtr s = (*i)->GetValueSetFromValueField(field);
			result->Union(s);
		}
	}

	return result;
}

ValueSetPtr Constraint::GetValueSetFromValueSetField(const std::string& field) const
{
	const ConstraintElementVector* vectors[] = {&standard,&extensions};
	ValueSetPtr result(new ValueSetDefn);

	for (int k = 0; k < 2; ++k)
	{
		ConstraintElementVector::const_iterator i = vectors[k]->begin(), e = vectors[k]->end();
		for (; i != e ; ++i)
		{
			ValueSetPtr s = (*i)->GetValueSetFromValueSetField(field);
			result->Union(s);
		}
	}
	return result;
}

ConstraintPtr Constraint::GetObjectSetFromObjectField(const std::string& field) const
{
	const ConstraintElementVector* vectors[] = {&standard,&extensions};
	ConstraintPtr result(new Constraint(extendable));
	
	for (int k = 0; k < 2; ++k)
	{
		ConstraintElementVector::const_iterator i = vectors[k]->begin(), e = vectors[k]->end();
		for (; i != e; ++i)
		{
			ConstraintPtr j = (*i)->GetObjectSetFromObjectField(field);
			result->standard.insert(result->standard.end(), j->standard.begin(), j->standard.end());
			result->standard.insert(result->standard.end(), j->extensions.begin(), j->extensions.end());
			result->extendable |= j->extendable;
		}
	}
	return result;
}

ConstraintPtr Constraint::GetObjectSetFromObjectSetField(const std::string& field) const
{
	const ConstraintElementVector* vectors[] = {&standard,&extensions};
	ConstraintPtr result(new Constraint(extendable));
	
	for (int k = 0; k < 2; ++k)
	{
		ConstraintElementVector::const_iterator i = vectors[k]->begin(), e = vectors[k]->end();
		for (; i != e; ++i)
		{
			ConstraintPtr j = (*i)->GetObjectSetFromObjectSetField(field);
			result->standard.insert(result->standard.end(), j->standard.begin(), j->standard.end());
			result->standard.insert(result->standard.end(), j->extensions.begin(), j->extensions.end());
			result->extendable |= j->extendable;
		}
	}
	return result;
}


bool Constraint::HasPERInvisibleConstraint(const Parameter& param) const
{
	ConstraintElementVector::const_iterator it = standard.begin(),
		last = standard.end();

	for (; it != last; ++it)
		if ((*it)->HasPERInvisibleConstraint(param))
			return true;

        for (it = extensions.begin(),last = extensions.end();
		 it != last;
		 ++it)
		if ((*it)->HasPERInvisibleConstraint(param))
			return true;

	return false;
}

void Constraint::GenerateObjectSetInstanceCode(const std::string& prefix, std::ostream& cxx) const
{
	ConstraintElementVector::const_iterator it = standard.begin(),
		last = standard.end();

	for (; it != last; ++it)
		(*it)->GenerateObjectSetInstanceCode(prefix, cxx);

	for (it = extensions.begin(), last = extensions.end();
		 it != last;
		 ++it)
		(*it)->GenerateObjectSetInstanceCode(prefix, cxx);
}


void Constraint::GenerateObjSetAccessCode(std::ostream& cxx)
{
	ConstraintElementVector::const_iterator it = standard.begin(),
		last = standard.end();

	for (; it != last; ++it)
		(*it)->GenerateObjSetAccessCode(cxx);

	for (it = extensions.begin(), last = extensions.end();
		 it != last;
		 ++it)
		(*it)->GenerateObjSetAccessCode(cxx);
}

const SizeConstraintElement* Constraint::GetSizeConstraint() const
{
    const SizeConstraintElement* result= NULL;
	ConstraintElementVector::const_iterator it = standard.begin(),
		last = standard.end();
	for (; it != last; ++it)
		if ((result = (*it)->GetSizeConstraint()) != NULL)
			break;
	return result;
}

const FromConstraintElement* Constraint::GetFromConstraint() const
{
    const FromConstraintElement* result=NULL;
	ConstraintElementVector::const_iterator it = standard.begin(),
		last = standard.end();
	for (; it != last; ++it)
		if ((result = (*it)->GetFromConstraint()) != NULL)
			break;
	return result;
}

void Constraint::GetCharacterSet(std::string& characterSet) const
{
	ConstraintElementVector::const_iterator it = standard.begin(),
		last = standard.end();
	for (; it != last; ++it)
		if ((*it)->GetCharacterSet(characterSet))
			return;
}

const SubTypeConstraintElement* Constraint::GetSubTypeConstraint() const
{
    const SubTypeConstraintElement* result=NULL;
	ConstraintElementVector::const_iterator it = standard.begin(),
		last = standard.end();
	for (; it != last; ++it)
		if ((result = (*it)->GetSubTypeConstraint()) != NULL)
			break;
	return result;
}

std::auto_ptr<Constraint> Constraint::Clone() const
{
	return std::auto_ptr<Constraint>(new Constraint(*this));
}


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

ConstraintElementBase::ConstraintElementBase()
{}

ConstraintElementBase::~ConstraintElementBase()
{}

void ConstraintElementBase::GenerateCplusplus(const std::string &, std::ostream &, std::ostream &, std::ostream &) const
{
  std::cerr << StdError(Warning) << "unsupported constraint, ignored." << std::endl;
}


bool ConstraintElementBase::ReferencesType(const TypeBase &) const
{
  return false;
}

ValueSetPtr ConstraintElementBase::GetValueSetFromValueField(const std::string& ) const
{
  std::cerr << StdError(Fatal) << "Invalid ObjectSet." << std::endl;
  return ValueSetPtr();
}

ValueSetPtr ConstraintElementBase::GetValueSetFromValueSetField(const std::string& ) const
{
  std::cerr << StdError(Fatal) << "Invalid ObjectSet." << std::endl;
  return ValueSetPtr();
}

ConstraintPtr ConstraintElementBase::GetObjectSetFromObjectField(const std::string& ) const
{
  std::cerr << StdError(Fatal) << "Invalid ObjectSet." << std::endl;
  return ConstraintPtr();
}

ConstraintPtr ConstraintElementBase::GetObjectSetFromObjectSetField(const std::string& ) const
{
  std::cerr << StdError(Fatal) << "Invalid ObjectSet." << std::endl;
  return ConstraintPtr();
}

const SizeConstraintElement* ConstraintElementBase::GetSizeConstraint() const
{
	return NULL;
}

const FromConstraintElement* ConstraintElementBase::GetFromConstraint() const
{
	return NULL;
}

bool ConstraintElementBase::GetCharacterSet(std::string& ) const
{
	return false;
}

const SubTypeConstraintElement* ConstraintElementBase::GetSubTypeConstraint() const
{
    return NULL;
}


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

ConstrainAllConstraintElement::ConstrainAllConstraintElement(ConstraintElementPtr excl)
{
  SetExclusions(excl);
}


/////////////////////////////////////////////////////////
ElementListConstraintElement::ElementListConstraintElement()
{
}

ElementListConstraintElement::ElementListConstraintElement(std::auto_ptr<ConstraintElementVector> list)
{
  elements.swap(*list);
}

void ElementListConstraintElement::PrintOn(std::ostream & strm) const
{
	PrintVector(strm, elements, '^');
}


void ElementListConstraintElement::GenerateCplusplus(const std::string & fn, std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const
{
  for (ConstraintElementVector::size_type i = 0; i < elements.size(); i++)
    elements[i]->GenerateCplusplus(fn, hdr, cxx, inl);
}

void ElementListConstraintElement::GetConstraint(std::string& str) const
{
  for (ConstraintElementVector::size_type i = 0; i < elements.size(); i++)
    elements[i]->GetConstraint(str);

}



bool ElementListConstraintElement::ReferencesType(const TypeBase & type) const
{
  for (ConstraintElementVector::size_type i = 0; i < elements.size(); i++) {
    if (elements[i]->ReferencesType(type))
      return true;
  }
  return false;
}

ValueSetPtr ElementListConstraintElement::GetValueSetFromValueField(const std::string& field) const
{
	ValueSetPtr result = elements[0]->GetValueSetFromValueField(field);

	for (ConstraintElementVector::size_type i = 1; i < elements.size(); i++)
	{
		ValueSetPtr t = elements[i]->GetValueSetFromValueField(field);
		result->Intersect(t);
	}
	return result;
}

ValueSetPtr ElementListConstraintElement::GetValueSetFromValueSetField(const std::string& field) const
{
	ValueSetPtr result = elements[0]->GetValueSetFromValueField(field);

	for (ConstraintElementVector::size_type i = 1; i < elements.size(); i++)
	{
		ValueSetPtr t = elements[i]->GetValueSetFromValueSetField(field);
		result->Intersect(t);
	}
	return result;
}

void ElementListConstraintElement::AppendElements(
	ConstraintElementVector::const_iterator first,
	ConstraintElementVector::const_iterator last
	)
{
	elements.insert(elements.end(), first, last);
}

ConstraintPtr ElementListConstraintElement::GetObjectSetFromObjectField(const std::string& field) const
{
	boost::shared_ptr<ElementListConstraintElement> 
		elem(new  ElementListConstraintElement);
	ConstraintElementVector::const_iterator i = elements.begin(), e = elements.end();
	for (; i != e; ++i)
	{
		ConstraintPtr cons = (*i)->GetObjectSetFromObjectField(field);
		if (cons.get() != NULL)
		{
			elem->AppendElements(cons->GetStandardElements().begin(), 
				cons->GetStandardElements().end());
			elem->AppendElements(cons->GetExtensionElements().end(),
				cons->GetExtensionElements().end());
		}
	}
	if (elem->elements.size()) {
		ConstraintElementPtr elm = 
			boost::shared_static_cast<ConstraintElementBase>(elem);		
		return ConstraintPtr(new Constraint(elm));
	}
	else
		return ConstraintPtr();
}

ConstraintPtr ElementListConstraintElement::GetObjectSetFromObjectSetField(const std::string& field) const
{
	boost::shared_ptr<ElementListConstraintElement> 
		elem(new  ElementListConstraintElement);
	ConstraintElementVector::const_iterator i = elements.begin(), e = elements.end();
	for (; i != e; ++i)
	{
		ConstraintPtr cons = (*i)->GetObjectSetFromObjectSetField(field);
		if (cons.get() != NULL)
		{
			elem->AppendElements(cons->GetStandardElements().begin(), 
				cons->GetStandardElements().end());
			elem->AppendElements(cons->GetExtensionElements().end(),
				cons->GetExtensionElements().end());
		}
	}
	if (elem->elements.size()){
		ConstraintElementPtr elm = 
			boost::shared_static_cast<ConstraintElementBase>(elem);		
		return ConstraintPtr(new Constraint(elm));
	}
	else
		return ConstraintPtr();