main.cxx

asn格式文件的编译器

}

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

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

void ElementListConstraintElement::GenerateObjectSetInstanceCode(const std::string& prefix, std::ostream& cxx) const
{
	ConstraintElementVector::const_iterator i = elements.begin(), e = elements.end();
	for (; i != e; ++i)
		(*i)->GenerateObjectSetInstanceCode(prefix, cxx);
}

void ElementListConstraintElement::GenerateObjSetAccessCode(std::ostream& cxx)
{
	ConstraintElementVector::const_iterator i = elements.begin(), e = elements.end();
	for (; i != e; ++i)
		(*i)->GenerateObjSetAccessCode(cxx);
}

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

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


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

SingleValueConstraintElement::SingleValueConstraintElement(const ValuePtr& val)
: value(val)
{
}

SingleValueConstraintElement::~SingleValueConstraintElement()
{
}


void SingleValueConstraintElement::PrintOn(std::ostream & strm) const
{
  strm << *value;
}


void SingleValueConstraintElement::GenerateCplusplus(const std::string & fn, std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const
{
  if (dynamic_cast<const IntegerValue*>(value.get())) {
    cxx << fn << ", ";
    value->GenerateCplusplus(hdr, cxx, inl);
    cxx << ", ";
    value->GenerateCplusplus(hdr, cxx, inl);
    cxx << ");\n";
    return;
  }

  if (dynamic_cast<const CharacterStringValue*>(value.get())) {
    cxx << fn << ", ";
    value->GenerateCplusplus(hdr, cxx, inl);
    cxx << ");\n";
    return;
  }

  std::cerr << StdError(Warning) << "Unsupported constraint type, ignoring." << std::endl;
}

void SingleValueConstraintElement::GetConstraint(std::string& str) const
{
	std::strstream strm;
  if (dynamic_cast<const IntegerValue*>(value.get())) {
	  strm << *value << ", " << *value << std::ends;
	  str += strm.str();
    return;
  }

  if (dynamic_cast<const CharacterStringValue*>(value.get())) {
	  strm << *value << std::ends;
	  str += strm.str();
    return;
  }
}

bool SingleValueConstraintElement::HasPERInvisibleConstraint(const Parameter& ) const
{
    return false;
}

bool SingleValueConstraintElement::GetCharacterSet(std::string& characterSet) const
{
	const CharacterStringValue* val;
	if ((val = dynamic_cast<const CharacterStringValue*>(value.get())) != NULL) 
	{
		val->GetValue(characterSet);
		return true;
	}
	return false;
}

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

ValueRangeConstraintElement::ValueRangeConstraintElement(ValuePtr lowerBound, ValuePtr upperBound)
{
  lower = lowerBound;
  upper = upperBound;
}

ValueRangeConstraintElement::~ValueRangeConstraintElement()
{
}


void ValueRangeConstraintElement::PrintOn(std::ostream & strm) const
{
  strm << *lower << ".." << *upper;
}


void ValueRangeConstraintElement::GenerateCplusplus(const std::string & fn, std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const
{
  cxx << fn << ", ";
  lower->GenerateCplusplus(hdr, cxx, inl);
  cxx << ", ";
  upper->GenerateCplusplus(hdr, cxx, inl);
  cxx << ");\n";
}



void ValueRangeConstraintElement::GetConstraint(std::string& str) const
{
	if (dynamic_cast<MinValue*>(lower.get()))
	{
		str_replace(str, "FixedConstraint", "Unconstrained");
	}
	else if (dynamic_cast<MaxValue*>(upper.get()))
	{
		str_replace(str,"FixedConstraint", "PartiallyConstrained");
	}
	else if (dynamic_cast<CharacterStringValue*>(lower.get()))
	{
		str_replace(str,"FromConstraint", "FromRangeConstraint");
	}

	std::strstream strm;
	strm << *lower << ", " << *upper << std::ends;
	str += strm.str();
}

bool ValueRangeConstraintElement::HasPERInvisibleConstraint(const Parameter& ) const
{
    return false;
}

bool ValueRangeConstraintElement::GetCharacterSet(std::string& characterSet) const
{
	const CharacterValue* l = dynamic_cast<const CharacterValue*>(lower.get());
	const CharacterValue* u = dynamic_cast<const CharacterValue*>(upper.get());
    if ( l && u)
    {
        for (char c = (char) l->GetValue();
             c <= (char) u->GetValue();
             ++c)
        {
            characterSet += c;
        }
        return true;
    }

	const CharacterStringValue* lv = dynamic_cast<const CharacterStringValue*>(lower.get());
	const CharacterStringValue* uv = dynamic_cast<const CharacterStringValue*>(upper.get());
    if (lv && uv)
    {
        std::string l, u;
        lv->GetValue(l);
        uv->GetValue(u);
        if (l.length()==1 && u.length() == 1)
        {
            for (char c = l[0]; c <= u[0]; ++c)
                characterSet += c;
            return true;
        }

    }

    return false;
}


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

SubTypeConstraintElement::SubTypeConstraintElement(TypePtr typ)
: subtype(typ)
{
}

SubTypeConstraintElement::~SubTypeConstraintElement()
{
}


void SubTypeConstraintElement::PrintOn(std::ostream & strm) const
{
	strm << *subtype;
}


void SubTypeConstraintElement::GenerateCplusplus(const std::string & str, std::ostream & , std::ostream & cxx, std::ostream& ) const
{
    cxx << "    " << subtype->GetTypeName() << " typeConstraint;\n" 
        << "    setConstraints(" ;
    if (str.find("ASN1::ExtendableConstraint") != -1)
        cxx << "ASN1::ExtendableConstraint,";
    else
        cxx << "ASN1::FixedConstraint,";
    cxx << " typeConstraint.getLowerLimit(), typeConstraint.getUpperLimit());\n";
}

void SubTypeConstraintElement::GetConstraint(std::string& str) const
{
    std::strstream strm;
    strm << str << subtype->GetTypeName() << "::LowerLimit, " 
		<< subtype->GetTypeName() << "::UpperLimit" << std::ends;
    str = strm.str();
}


bool SubTypeConstraintElement::ReferencesType(const TypeBase & type) const
{
  return subtype->ReferencesType(type);
}

bool SubTypeConstraintElement::HasPERInvisibleConstraint(const Parameter& ) const
{
    return false;
}

const SubTypeConstraintElement* SubTypeConstraintElement::GetSubTypeConstraint() const
{
    return this;
}

std::string SubTypeConstraintElement::GetSubTypeName() const
{
    return subtype->GetTypeName();
}



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

NestedConstraintConstraintElement::NestedConstraintConstraintElement(ConstraintPtr con)
{
  constraint = con;
}

NestedConstraintConstraintElement::~NestedConstraintConstraintElement()
{
}


bool NestedConstraintConstraintElement::ReferencesType(const TypeBase & type) const
{
  if (constraint.get() == NULL)
    return false;

  return constraint->ReferencesType(type);
}

bool NestedConstraintConstraintElement::HasPERInvisibleConstraint(const Parameter& param) const
{
	return constraint->HasPERInvisibleConstraint(param);
}

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

SizeConstraintElement::SizeConstraintElement(ConstraintPtr constraint)
  : NestedConstraintConstraintElement(constraint)
{
}

void SizeConstraintElement::PrintOn(std::ostream & strm) const
{
  strm << "SIZE" << *constraint;
}


void SizeConstraintElement::GenerateCplusplus(const std::string & fn, std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const
{
  constraint->GenerateCplusplus(fn, hdr, cxx, inl);
}

void SizeConstraintElement::GetConstraint(std::string& str) const
{
	const char* cstr = "ASN1::FixedConstraint, ";
	const int len = strlen(cstr);
	std::string::iterator itr = std::find_end(str.begin(), str.end(), cstr, cstr+len);
	if (itr != str.end())
		str.replace(itr, itr+len, " ASN1::SizeConstraint<");
	constraint->GetConstraint(str);
	str += "> ";
}

const SizeConstraintElement* SizeConstraintElement::GetSizeConstraint() const
{
	return this;
}


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

FromConstraintElement::FromConstraintElement(ConstraintPtr constraint)
  : NestedConstraintConstraintElement(constraint)
{
}

void FromConstraintElement::PrintOn(std::ostream & strm) const
{
  strm << "FROM" << *constraint;
}


void FromConstraintElement::GenerateCplusplus(const std::string & fn, std::ostream & hdr, std::ostream & cxx, std::ostream & inl) const
{
  std::string newfn = fn;
  str_replace(newfn,"setConstraints(", "setCharacterSet(");
  constraint->GenerateCplusplus(newfn, hdr, cxx, inl);
}

void FromConstraintElement::GetConstraint(std::string& ) const
{
}

const FromConstraintElement* FromConstraintElement::GetFromConstraint() const
{
	return this;
}

std::string FromConstraintElement::GetCharacterSet(const char* canonicalSet, int canonicalSetSize) const
{
    std::string characterSet;
    if (!constraint->IsExtendable())
    {
        std::string constrainedSet;
        constraint->GetCharacterSet(constrainedSet);
        
        int setSize = constrainedSet.size();
        const char* c = &constrainedSet[0];
        for (int i = 0; i < canonicalSetSize; i++) {
            if (memchr(c, canonicalSet[i], setSize) != NULL)
                characterSet += canonicalSet[i];
        }
    }
    return characterSet;
}

int FromConstraintElement::GetRange(std::ostream& cxx) const
{
	std::strstream inl, hdr, tmpcxx;
    std::string str;
    constraint->GenerateCplusplus(str,hdr, tmpcxx, inl);
	int min, max;
	char c;
	tmpcxx >> str >> min >> c >> max;
    cxx << min << ", " << max;
    return max-min;
}

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

WithComponentConstraintElement::WithComponentConstraintElement(std::string newName,
                                                               ConstraintPtr constraint,
                                                               int pres)
  : NestedConstraintConstraintElement(constraint)
{
  name = newName;
  presence = pres;
}

void WithComponentConstraintElement::PrintOn(std::ostream & strm) const
{
  if (name.empty())
    strm << "WITH COMPONENT";
  else
    strm << name;

  if (constraint.get() != NULL)
    strm << *constraint;

  switch (presence) {
    case Present :
      strm << " PRESENT";
      break;
    case Absent :
      strm << " ABSENT";
      break;
    case Optional :
      strm << " OPTIONAL";
      break;
  }
}


void WithComponentConstraintElement::GenerateCplusplus(const std::string &, std::ostream &, std::ostream & , std::ostream &) const
{
}

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

InnerTypeConstraintElement::InnerTypeConstraintElement(std::auto_ptr<ConstraintElementVector> list,
                                                       bool part)
  : ElementListConstraintElement(list)
{
  partial = part;
}


void InnerTypeConstraintElement::PrintOn(std::ostream & strm) const
{
  strm << "WITH COMPONENTS { ";

  if (partial)
    strm << "..., ";

  for (ConstraintElementVector::size_type i = 0; i < elements.size(); i++) {
    if (i > 0)
      strm << ", ";
    elements[i]->PrintOn(strm);
  }

  strm << " }";
}


void InnerTypeConstraintElement::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);
}

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

UserDefinedConstraintElement::UserDefinedConstraintElement(ActualParameterListPtr list)
: parameters(list)
{
}

void UserDefinedConstraintElement::PrintOn(std::ostream & strm) const
{
  strm << "CONSTRAINED BY { ";
  for (size_t i = 0; i < parameters->size(); i++) {
    if (i > 0)
      strm << ", ";
    strm << * (*parameters)[i];
  }
  strm << " }";
}


void UserDefinedConstraintElement::GenerateCplusplus(const std::string &, std::ostream &, std::ostream &, std::ostream &) const
{
}

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

TableConstraint::TableConstraint(boost::shared_ptr<DefinedObjectSet> os, 
								std::auto_ptr<StringList> as)
: objSet(os), atNotations(as)
{
}

TableConstraint::~TableConstraint()
{
}

std::string TableConstraint::GetObjectSetIdentifier() const 
{ 
    return MakeIdentifierC(objSet->GetName()); 
} 


bool TableConstraint::ReferenceType(const TypeBase& type)
{
	return type.GetTypeName() == GetObjectSetIdentifier();
}

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

TypeBase::TypeBase(unsigned tagNum, ModuleDefinition* md)
  : tag(tagNum, md->GetDefaultTagMode()), defaultTag(tagNum, md->GetDefaultTagMode())
{
  isOptional = false;
  isGenerated = false;
  isValueSetType = false;
  module = md;
}


TypeBase::TypeBase(TypeBase& copy)
  : name(copy.name),
    identifier(MakeIdentifierC(copy.name)),
    tag(copy.tag),
    defaultTag(copy.tag)
{
  isOptional = copy.isOptional;
  isGenerated = false;
  isValueSetType = false;
  module = Module;
}


void TypeBase::PrintOn(std::ostream & strm) const
{
  PrintStart(strm);
  PrintFinish(strm);
}


void TypeBase::PrintStart(std::ostream & strm) const
{
  strm << indent();
  if (name.size()) {
    strm << name << parameters << ": ";
  }