#include <stdio.h>
#include "asn-incl.h"
#include "asn1module.h"
#include "lib-types.h"
#include "print.h"
static int indentCountG;
static int indentG = 0;
static int indentStepG = 4;
#define INDENT(f, i)\
for (indentCountG = 0; indentCountG < (i); indentCountG++)\
fputc (' ', (f))\
void
PrintModule PARAMS ((f, mod),
FILE *f _AND_
Module *mod)
{
if (mod->status == MOD_ERROR)
{
fprintf (f, "WARNING: this module contains errors\n");
fprintf (f,"(probably some type/value is referenced but is not defined or imported)\n");
fprintf (f,"The prog. may croak, cross your fingers!\n");
}
fprintf (f, "%s ",mod->modId->name);
PrintOid (f, mod->modId->oid);
fprintf (f, "\nDEFINITIONS ");
if (mod->tagDefault == EXPLICIT_TAGS)
fprintf (f, "EXPLICIT TAGS");
else if (mod->tagDefault == IMPLICIT_TAGS)
fprintf (f, "IMPLICIT TAGS");
else
fprintf (f, "\n\n -- compiler error unknown tag default");
fprintf (f, " ::=\nBEGIN\n\n");
PrintExports (f, mod);
PrintImportLists (f, mod->imports);
PrintTypeDefs (f, mod->typeDefs);
PrintValueDefs (f, mod->valueDefs);
fprintf (f, "END\n");
}
void
PrintExports PARAMS ((f, m),
FILE *f _AND_
Module *m)
{
TypeDef *td;
ValueDef *vd;
int first;
if (m->exportStatus == EXPORTS_ALL)
{
fprintf (f, "\n\n-- exports everything\n\n");
}
else if (m->exportStatus == EXPORTS_NOTHING)
{
fprintf (f, "\n\nEXPORTS -- exports nothing\n\n");
}
else
{
fprintf (f, "\n\nEXPORTS\n");
first = 1;
FOR_EACH_LIST_ELMT (td, m->typeDefs)
if (td->exported)
{
if (!first)
fprintf (f,", ");
fprintf (f, "%s", td->definedName);
first = 0;
}
FOR_EACH_LIST_ELMT (vd, m->valueDefs)
if (vd->exported)
{
if (!first)
fprintf (f,", ");
fprintf (f, "%s", vd->definedName);
first = 0;
}
fprintf (f, "\n;\n\n");
}
}
void
PrintOid PARAMS ((f, oid),
FILE *f _AND_
OID *oid)
{
int i;
if (oid == NULL)
return;
fprintf (f, "{ ");
for (; oid != NULL; oid = oid->next)
{
if (oid->valueRef != NULL)
PrintValue (f, NULL, NULL, oid->valueRef);
else if (oid->arcNum != NULL_OID_ARCNUM)
fprintf (f, "%d", oid->arcNum);
fprintf (f, " ");
}
fprintf (f, "}");
}
void
PrintImportElmt PARAMS ((f, impElmt),
FILE *f _AND_
ImportElmt *impElmt)
{
fprintf (f, "%s",impElmt->name);
}
void
PrintImportElmts PARAMS ((f, impElmtList),
FILE *f _AND_
ImportElmtList *impElmtList)
{
ImportElmt *ie;
ImportElmt *last;
if ((impElmtList == NULL) || (LIST_EMPTY (impElmtList)))
return;
last = (ImportElmt*)LAST_LIST_ELMT (impElmtList);
FOR_EACH_LIST_ELMT (ie, impElmtList)
{
PrintImportElmt (f, ie);
if (ie != last)
fprintf (f, ", ");
}
}
void
PrintImportLists PARAMS ((f, impLists),
FILE *f _AND_
ImportModuleList *impLists)
{
ImportModule *impMod;
if (impLists == NULL)
{
fprintf (f,"\n\n-- imports nothing\n\n");
return;
}
fprintf (f, "IMPORTS\n\n");
FOR_EACH_LIST_ELMT (impMod, impLists)
{
PrintImportElmts (f, impMod->importElmts);
fprintf (f, "\n FROM %s ", impMod->modId->name);
PrintOid (f, impMod->modId->oid);
fprintf (f, "\n\n\n");
}
fprintf (f, ";\n\n\n");
}
void
PrintTypeDefs PARAMS ((f, typeDefs),
FILE *f _AND_
TypeDefList *typeDefs)
{
TypeDef *td;
FOR_EACH_LIST_ELMT (td, typeDefs)
{
if (td->type->basicType->choiceId == BASICTYPE_MACRODEF)
PrintMacroDef (f, td);
else
{
fprintf (f,"-- %s notes: ", td->definedName);
if (td->recursive)
fprintf (f,"recursive, ");
else
fprintf (f,"not recursive, ");
if (td->exported)
fprintf (f,"exported,\n");
else
fprintf (f,"not exported,\n");
fprintf (f,"-- locally refd %d times, ", td->localRefCount);
fprintf (f,"import refd %d times\n", td->importRefCount);
fprintf (f, "%s ::= ", td->definedName);
PrintType (f, td, td->type);
}
fprintf (f, "\n\n\n");
}
}
void
PrintType PARAMS ((f, head, t),
FILE *f _AND_
TypeDef *head _AND_
Type *t)
{
Tag *tag;
Tag *lastTag;
if (t == NULL)
return;
lastTag = NULL;
FOR_EACH_LIST_ELMT (tag, t->tags)
{
if (! ((tag->tclass == UNIV) &&
(tag->code == LIBTYPE_GET_UNIV_TAG_CODE (t->basicType->choiceId))))
{
PrintTag (f, tag);
fprintf (f, " ");
}
lastTag = tag;
}
if (t->implicit)
fprintf (f, "IMPLICIT ");
PrintBasicType (f, head, t, t->basicType);
if ((t->subtypes != NULL) &&
(t->basicType->choiceId != BASICTYPE_SETOF) &&
(t->basicType->choiceId != BASICTYPE_SEQUENCEOF))
{
fprintf (f," ");
PrintSubtype (f, head, t, t->subtypes);
}
if (t->defaultVal != NULL)
{
fprintf (f, " DEFAULT ");
if (t->defaultVal->fieldName != NULL)
fprintf (f, "%s ", t->defaultVal->fieldName);
PrintValue (f, NULL, t, t->defaultVal->value);
}
else if (t->optional)
fprintf (f, " OPTIONAL");
#ifdef DEBUG
fprintf (f, " -- lineNo = %d --", t->lineNo);
#endif
}
void
PrintBasicType PARAMS ((f, head, t, bt),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt)
{
switch (bt->choiceId)
{
case BASICTYPE_SEQUENCE:
fprintf (f, "SEQUENCE\n");
INDENT (f, indentG);
fprintf (f,"{\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintElmtTypes (f, head, t, bt->a.sequence);
indentG -= indentStepG;
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f, "}");
break;
case BASICTYPE_SET:
fprintf (f, "SET\n");
INDENT (f, indentG);
fprintf (f,"{\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintElmtTypes (f, head, t, bt->a.set);
indentG -= indentStepG;
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f, "}");
break;
case BASICTYPE_CHOICE:
fprintf (f, "CHOICE\n");
INDENT (f, indentG);
fprintf (f,"{\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintElmtTypes (f, head, t, bt->a.choice);
indentG -= indentStepG;
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f, "}");
break;
case BASICTYPE_SEQUENCEOF:
fprintf (f, "SEQUENCE ");
if (t->subtypes != NULL)
{
PrintSubtype (f, head, t, t->subtypes);
fprintf (f," ");
}
fprintf (f, "OF ");
PrintType (f, head, bt->a.sequenceOf);
break;
case BASICTYPE_SETOF:
fprintf (f, "SET ");
if (t->subtypes != NULL)
{
PrintSubtype (f, head, t, t->subtypes);
fprintf (f," ");
}
fprintf (f, "OF ");
PrintType (f, head, bt->a.setOf);
break;
case BASICTYPE_SELECTION:
fprintf (f, "%s < ", bt->a.selection->fieldName);
PrintType (f, head, bt->a.selection->typeRef);
break;
case BASICTYPE_COMPONENTSOF:
fprintf (f, "COMPONENTS OF ");
PrintType (f, NULL, bt->a.componentsOf);
break;
case BASICTYPE_ANYDEFINEDBY:
fprintf (f, "ANY DEFINED BY %s", bt->a.anyDefinedBy->fieldName);
break;
case BASICTYPE_LOCALTYPEREF:
fprintf (f, "%s", bt->a.localTypeRef->typeName);
break;
case BASICTYPE_IMPORTTYPEREF:
if (bt->a.importTypeRef->moduleName != NULL)
fprintf (f,"%s.", bt->a.importTypeRef->moduleName);
fprintf (f, "%s", bt->a.importTypeRef->typeName);
break;
case BASICTYPE_UNKNOWN:
fprintf (f, "unknown type !?!");
break;
case BASICTYPE_BOOLEAN:
fprintf (f, "BOOLEAN");
break;
case BASICTYPE_INTEGER:
fprintf (f, "INTEGER");
if ((bt->a.integer != NULL) && !LIST_EMPTY (bt->a.integer))
{
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
PrintNamedElmts (f, head, t, bt->a.integer);
indentG -= indentStepG;
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f, "}");
}
break;
case BASICTYPE_BITSTRING:
fprintf (f, "BIT STRING");
if ((bt->a.bitString != NULL) && !LIST_EMPTY (bt->a.bitString))
{
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
PrintNamedElmts (f, head, t, bt->a.bitString);
indentG -= indentStepG;
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f, "}");
}
break;
case BASICTYPE_OCTETSTRING:
fprintf (f, "OCTET STRING");
break;
case BASICTYPE_NULL:
fprintf (f, "NULL");
break;
case BASICTYPE_OID:
fprintf (f, "OBJECT IDENTIFIER");
break;
case BASICTYPE_REAL:
fprintf (f, "REAL");
break;
case BASICTYPE_ENUMERATED:
fprintf (f, "ENUMERATED");
if ((bt->a.enumerated != NULL) && !LIST_EMPTY (bt->a.enumerated))
{
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
PrintNamedElmts (f, head, t, bt->a.enumerated);
indentG -= indentStepG;
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f, "}");
}
break;
case BASICTYPE_ANY:
fprintf (f, "ANY");
break;
case BASICTYPE_MACROTYPE:
switch (bt->a.macroType->choiceId)
{
case MACROTYPE_ROSOPERATION:
case MACROTYPE_ASNABSTRACTOPERATION:
PrintRosOperationMacroType (f, head, t, bt, bt->a.macroType->a.rosOperation);
break;
case MACROTYPE_ROSERROR:
case MACROTYPE_ASNABSTRACTERROR:
PrintRosErrorMacroType (f, head, t, bt, bt->a.macroType->a.rosError);
break;
case MACROTYPE_ROSBIND:
case MACROTYPE_ROSUNBIND:
PrintRosBindMacroType (f, head, t, bt, bt->a.macroType->a.rosBind);
break;
case MACROTYPE_ROSASE:
PrintRosAseMacroType (f, head, t, bt, bt->a.macroType->a.rosAse);
break;
case MACROTYPE_MTSASEXTENSIONS:
PrintMtsasExtensionsMacroType (f, head, t, bt, bt->a.macroType->a.mtsasExtensions);
break;
case MACROTYPE_MTSASEXTENSION:
PrintMtsasExtensionMacroType (f, head, t, bt, bt->a.macroType->a.mtsasExtension);
break;
case MACROTYPE_MTSASEXTENSIONATTRIBUTE:
PrintMtsasExtensionAttributeMacroType (f, head, t, bt, bt->a.macroType->a.mtsasExtensionAttribute);
break;
case MACROTYPE_MTSASTOKEN:
PrintMtsasTokenMacroType (f, head, t, bt, bt->a.macroType->a.mtsasToken);
break;
case MACROTYPE_MTSASTOKENDATA:
PrintMtsasTokenDataMacroType (f, head, t, bt, bt->a.macroType->a.mtsasTokenData);
break;
case MACROTYPE_MTSASSECURITYCATEGORY:
PrintMtsasSecurityCategoryMacroType (f, head, t, bt, bt->a.macroType->a.mtsasSecurityCategory);
break;
case MACROTYPE_ASNOBJECT:
PrintAsnObjectMacroType (f, head, t, bt, bt->a.macroType->a.asnObject);
break;
case MACROTYPE_ASNPORT:
PrintAsnPortMacroType (f, head, t, bt, bt->a.macroType->a.asnPort);
break;
case MACROTYPE_ASNABSTRACTBIND:
case MACROTYPE_ASNABSTRACTUNBIND:
PrintAsnAbstractBindMacroType (f, head, t, bt, bt->a.macroType->a.asnAbstractBind);
break;
case MACROTYPE_AFALGORITHM:
PrintAfAlgorithmMacroType (f, head, t, bt, bt->a.macroType->a.afAlgorithm);
break;
case MACROTYPE_AFENCRYPTED:
PrintAfEncryptedMacroType (f, head, t, bt, bt->a.macroType->a.afEncrypted);
break;
case MACROTYPE_AFSIGNED:
PrintAfSignedMacroType (f, head, t, bt, bt->a.macroType->a.afSigned);
break;
case MACROTYPE_AFSIGNATURE:
PrintAfSignatureMacroType (f, head, t, bt, bt->a.macroType->a.afSignature);
break;
case MACROTYPE_AFPROTECTED:
PrintAfProtectedMacroType (f, head, t, bt, bt->a.macroType->a.afProtected);
break;
case MACROTYPE_SNMPOBJECTTYPE:
PrintSnmpObjectTypeMacroType (f, head, t, bt, bt->a.macroType->a.snmpObjectType);
break;
default:
fprintf (f, "< unknown macro type id ?! >");
}
break;
case BASICTYPE_MACRODEF:
break;
default:
fprintf (f, "< unknown type id ?! >");
}
}
void
PrintElmtType PARAMS ((f, head, t, nt),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
NamedType *nt)
{
if (nt->fieldName != NULL)
fprintf (f, "%s ", nt->fieldName);
PrintType (f, head, nt->type);
}
void
PrintElmtTypes PARAMS ((f, head, t, e),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
NamedTypeList *e)
{
NamedType *nt;
NamedType *last;
if ((e == NULL) || LIST_EMPTY (e))
return;
last = (NamedType*)LAST_LIST_ELMT (e);
FOR_EACH_LIST_ELMT (nt, e)
{
PrintElmtType (f, head, t, nt);
if (nt != last)
{
fprintf (f, ",\n");
INDENT (f, indentG);
}
}
}
void
PrintValueDefs PARAMS ((f, vList),
FILE *f _AND_
ValueDefList *vList)
{
ValueDef *v;
FOR_EACH_LIST_ELMT (v, vList)
{
PrintValueDef (f, v);
}
}
void
PrintValueDef PARAMS ((f, v),
FILE *f _AND_
ValueDef *v)
{
fprintf (f, "%s ", v->definedName);
if (v->value->type != NULL)
PrintType (f, NULL, v->value->type);
else
PrintTypeById (f, v->value->valueType);
fprintf (f, " ::= ");
indentG += indentStepG;
PrintValue (f, v, v->value->type, v->value);
fprintf (f, "\n\n");
indentG -= indentStepG;
}
void
PrintValue PARAMS ((f, head, valuesType, v),
FILE *f _AND_
ValueDef *head _AND_
Type *valuesType _AND_
Value *v)
{
if (v == NULL)
return;
PrintBasicValue (f, head, valuesType, v, v->basicValue);
}
void
PrintBasicValue PARAMS ((f, head, valuesType, v, bv),
FILE *f _AND_
ValueDef *head _AND_
Type *valuesType _AND_
Value *v _AND_
BasicValue *bv)
{
if (v == NULL)
return;
switch (bv->choiceId)
{
case BASICVALUE_UNKNOWN:
fprintf (f, "<unknown value>");
break;
case BASICVALUE_EMPTY:
fprintf (f,"{ }");
break;
case BASICVALUE_INTEGER:
fprintf (f, "%d", bv->a.integer);
break;
case BASICVALUE_SPECIALINTEGER:
if (bv->a.specialInteger == MAX_INT)
fprintf (f, "MAX");
else
fprintf (f, "MIN");
break;
case BASICVALUE_BOOLEAN:
if (bv->a.boolean)
fprintf (f,"TRUE");
else
fprintf (f,"FALSE");
break;
case BASICVALUE_REAL:
fprintf (f, "%f", bv->a.real);
break;
case BASICVALUE_SPECIALREAL:
if (bv->a.specialReal == PLUS_INFINITY_REAL)
fprintf (f, "PLUS INFINITY");
else
fprintf (f, "MINUS INFINITY");
break;
case BASICVALUE_ASCIITEXT:
fprintf (f, "\"%s\"", bv->a.asciiText->octs);
break;
case BASICVALUE_ASCIIHEX:
fprintf (f, "\"%s\"", bv->a.asciiHex->octs);
break;
case BASICVALUE_ASCIIBITSTRING:
fprintf (f, "\"%s\"", bv->a.asciiBitString->octs);
break;
case BASICVALUE_OID:
PrintEncodedOid (f, bv->a.oid);
break;
case BASICVALUE_LINKEDOID:
PrintOid (f, bv->a.linkedOid);
break;
case BASICVALUE_BERVALUE:
fprintf (f,"<PrintBerValue not coded yet");
break;
case BASICVALUE_PERVALUE:
fprintf (f,"<PrintPerValue not coded yet");
break;
case BASICVALUE_NAMEDVALUE:
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f,"{\n");
indentG += indentStepG;
PrintElmtValue (f, head, v, bv->a.namedValue);
indentG -= indentStepG;
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f,"}");
break;
case BASICVALUE_NULL:
fprintf (f,"NULL");
break;
case BASICVALUE_LOCALVALUEREF:
fprintf (f, "%s", bv->a.localValueRef->valueName);
break;
case BASICVALUE_IMPORTVALUEREF:
fprintf (f, "%s", bv->a.importValueRef->valueName);
break;
case BASICVALUE_VALUENOTATION:
fprintf (f, "-- snacc warning: can't parse this value yet --");
fprintf (f, "%s", bv->a.valueNotation->octs);
break;
default:
fprintf (stderr,"PrintBasicValue: ERROR - unknown value type\n");
}
}
void
PrintElmtValue PARAMS ((f, head, v, nv),
FILE *f _AND_
ValueDef *head _AND_
Value *v _AND_
NamedValue *nv)
{
if (nv->fieldName != NULL)
fprintf (f, "%s ", nv->fieldName);
PrintValue (f, NULL, NULL, nv->value);
}
void
PrintElmtValues PARAMS ((f, head, v, e),
FILE *f _AND_
ValueDef *head _AND_
Value *v _AND_
NamedValueList *e)
{
NamedValue *nv;
NamedValue *last;
if ((e == NULL) || LIST_EMPTY (e))
return;
last = (NamedValue*)LAST_LIST_ELMT (e);
FOR_EACH_LIST_ELMT (nv, e)
{
PrintElmtValue (f, head, v, nv);
if (nv != last)
{
fprintf (f, ",\n");
INDENT (f, indentG);
}
}
}
void
PrintTypeById PARAMS ((f, typeId),
FILE *f _AND_
int typeId)
{
switch (typeId)
{
case BASICTYPE_UNKNOWN:
fprintf (f, "UNKNOWN");
break;
case BASICTYPE_BOOLEAN:
fprintf (f, "BOOLEAN");
break;
case BASICTYPE_INTEGER:
fprintf (f, "INTEGER");
break;
case BASICTYPE_BITSTRING:
fprintf (f, "BIT STRING");
break;
case BASICTYPE_OCTETSTRING:
fprintf (f, "OCTET STRING");
break;
case BASICTYPE_NULL:
fprintf (f, "NULL");
break;
case BASICTYPE_SEQUENCE:
fprintf (f, "SEQUENCE");
break;
case BASICTYPE_SEQUENCEOF:
fprintf (f, "SEQUENCE OF");
break;
case BASICTYPE_SET:
fprintf (f, "SET");
break;
case BASICTYPE_SETOF:
fprintf (f, "SET OF");
break;
case BASICTYPE_CHOICE:
fprintf (f, "CHOICE");
break;
case BASICTYPE_SELECTION:
fprintf (f, "SELECTION");
break;
case BASICTYPE_ANY:
fprintf (f, "ANY");
break;
case BASICTYPE_ANYDEFINEDBY:
fprintf (f, "ANY DEFINED BY");
break;
case BASICTYPE_OID:
fprintf (f, "OBJECT IDENTIFIER");
break;
case BASICTYPE_ENUMERATED:
fprintf (f, "ENUMERATED");
break;
case BASICTYPE_REAL:
fprintf (f, "REAL");
break;
case BASICTYPE_COMPONENTSOF:
fprintf (f, "COMPONENTS OF");
break;
default:
fprintf (f, "ERROR - %d is an unknown type id\n", typeId);
}
}
void
PrintTag PARAMS ((f, tag),
FILE *f _AND_
Tag *tag)
{
char *name=NULL;
if (tag->tclass == UNIV)
{
switch (tag->code)
{
case BOOLEAN_TAG_CODE: name = "BOOLEAN";
break;
case INTEGER_TAG_CODE: name = "INTEGER";
break;
case BITSTRING_TAG_CODE: name = "BITSTRING";
break;
case OCTETSTRING_TAG_CODE: name = "OCTETSTRING";
break;
case NULLTYPE_TAG_CODE: name = "NULL TYPE";
break;
case OID_TAG_CODE: name = "OBJECT ID";
break;
case OD_TAG_CODE: name = "OBEJECT DESCRIPTOR";
break;
case EXTERNAL_TAG_CODE: name = "EXTERNAL";
break;
case REAL_TAG_CODE: name = "REAL";
break;
case ENUM_TAG_CODE: name = "ENUMERATED";
break;
case SEQ_TAG_CODE: name = "SEQUENCE";
break;
case SET_TAG_CODE: name = "SET";
break;
case NUMERICSTRING_TAG_CODE: name = "NUMERIC STRING";
break;
case PRINTABLESTRING_TAG_CODE: name = "PRINTABLE STRING";
break;
case TELETEXSTRING_TAG_CODE: name = "TELETEX STRING";
break;
case VIDEOTEXSTRING_TAG_CODE: name = "VIDEOTEX STRING";
break;
case IA5STRING_TAG_CODE: name = "IA5 STRING";
break;
case UTCTIME_TAG_CODE: name = "UTC TIME";
break;
case GENERALIZEDTIME_TAG_CODE: name = "GENERALIZED TIME";
break;
case GRAPHICSTRING_TAG_CODE: name = "GRAPHIC STRING";
break;
case VISIBLESTRING_TAG_CODE: name = "VISIBLE STRING";
break;
case GENERALSTRING_TAG_CODE: name = "GENERAL STRING";
break;
default: name = "UNKNOWN UNIVERSAL TYPE";
}
fprintf (f, "[UNIVERSAL %d]", tag->code);
}
else if (tag->tclass == APPL)
{
fprintf (f, "[APPLICATION %d]", tag->code);
}
else if (tag->tclass == PRIV)
{
fprintf (f, "[PRIVATE %d]", tag->code);
}
else if (tag->tclass == CNTX)
{
fprintf (f, "[%d]", tag->code);
}
if (tag->explicit)
fprintf (f, " EXPLICIT");
}
void
PrintSubtype PARAMS ((f, head, t, s),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
Subtype *s)
{
Subtype *tmpS;
Subtype *last;
if (s == NULL)
return;
switch (s->choiceId)
{
case SUBTYPE_SINGLE:
PrintSubtypeValue (f, head, t, s->a.single);
break;
case SUBTYPE_AND:
FOR_EACH_LIST_ELMT (tmpS, s->a.and)
{
fprintf (f, "(");
PrintSubtype (f, head, t, tmpS);
fprintf (f, ")");
}
break;
case SUBTYPE_OR:
if ((s->a.or != NULL) && !LIST_EMPTY (s->a.or))
last = (Subtype*)LAST_LIST_ELMT (s->a.or);
FOR_EACH_LIST_ELMT (tmpS, s->a.or)
{
fprintf (f, "(");
PrintSubtype (f, head, t, tmpS);
fprintf (f, ")");
if (tmpS != last)
fprintf (f, " | ");
}
break;
case SUBTYPE_NOT:
fprintf (f, "NOT (");
PrintSubtype (f, head, t, s->a.not);
fprintf (f, ")");
break;
default:
fprintf (stderr, "PrintSubtype: ERROR - unknown Subtypes choiceId\n");
break;
}
}
void
PrintSubtypeValue PARAMS ((f, head, t, s),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
SubtypeValue *s)
{
if (s == NULL)
return;
switch (s->choiceId)
{
case SUBTYPEVALUE_SINGLEVALUE:
PrintValue (f, NULL, NULL, s->a.singleValue);
break;
case SUBTYPEVALUE_CONTAINED:
fprintf (f, "<PrintContainedSubtype not coded yet\n");
break;
case SUBTYPEVALUE_VALUERANGE:
PrintValue (f, NULL, NULL, s->a.valueRange->lowerEndValue);
if (!s->a.valueRange->lowerEndInclusive)
fprintf (f, " >");
fprintf (f,"..");
if (!s->a.valueRange->upperEndInclusive)
fprintf (f, "< ");
PrintValue (f, NULL, NULL, s->a.valueRange->upperEndValue);
break;
case SUBTYPEVALUE_PERMITTEDALPHABET:
fprintf (f,"FROM ");
PrintSubtype (f, head, t, s->a.permittedAlphabet);
break;
case SUBTYPEVALUE_SIZECONSTRAINT:
fprintf (f,"SIZE ");
PrintSubtype (f, head, t, s->a.sizeConstraint);
break;
case SUBTYPEVALUE_INNERSUBTYPE:
PrintInnerSubtype (f, head, t, s->a.innerSubtype);
break;
default:
fprintf (stderr, "PrintSubtype: ERROR - unknown Subtype choiceId\n");
break;
}
}
void
PrintInnerSubtype PARAMS ((f, head, t, i),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
InnerSubtype *i)
{
Constraint *constraint;
if (i->constraintType == SINGLE_CT)
{
fprintf (f,"WITH COMPONENT ");
constraint = *(Constraint**)AsnListFirst (i->constraints);
PrintSubtype (f, head, t, constraint->valueConstraints);
}
else
{
fprintf (f, "WITH COMPONENTS\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
if (i->constraintType == PARTIAL_CT)
{
INDENT (f, indentG);
fprintf (f, "...,\n");
}
PrintMultipleTypeConstraints (f, head, t, i->constraints);
indentG -= indentStepG;
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f, "}");
}
}
void
PrintMultipleTypeConstraints PARAMS ((f, head, t, cList),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
ConstraintList *cList)
{
Constraint *c;
Constraint *last;
if ((cList == NULL) || LIST_EMPTY (cList))
return;
last = (Constraint*)LAST_LIST_ELMT (cList);
FOR_EACH_LIST_ELMT (c, cList)
{
if (c->fieldRef != NULL)
{
INDENT (f, indentG);
fprintf (f, "%s ", c->fieldRef);
}
PrintSubtype (f, head, t, c->valueConstraints);
if (c->presenceConstraint == ABSENT_CT)
fprintf (f, " ABSENT");
if (c->presenceConstraint == PRESENT_CT)
fprintf (f, " PRESENT");
if (c->presenceConstraint == OPTIONAL_CT)
fprintf (f, " OPTIONAL");
if (c != last)
fprintf (f, ",\n");
}
}
void
PrintNamedElmts PARAMS ((f, head, t, n),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
ValueDefList *n)
{
ValueDef *vd;
ValueDef *last;
if ((n == NULL) || LIST_EMPTY (n))
return;
last = (ValueDef*)LAST_LIST_ELMT (n);
FOR_EACH_LIST_ELMT (vd, n)
{
INDENT (f, indentG);
fprintf (f, "%s (", vd->definedName);
PrintValue (f, NULL, NULL, vd->value);
fprintf (f,")");
if (vd != last)
fprintf (f,",\n");
}
}
void
PrintRosOperationMacroType PARAMS ((f, head, t, bt, op),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
RosOperationMacroType *op)
{
TypeOrValue *tOrV;
TypeOrValue *last;
if (bt->a.macroType->choiceId == MACROTYPE_ROSOPERATION)
fprintf (f, "OPERATION");
else
fprintf (f, "ABSTRACT-OPERATION");
indentG += indentStepG;
if (op->arguments != NULL)
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f, "ARGUMENT\n");
indentG += indentStepG;
INDENT (f, indentG);
if (op->arguments->fieldName != NULL)
fprintf (f, "%s ", op->arguments->fieldName);
PrintType (f, head, op->arguments->type);
indentG -= indentStepG;
}
if (op->result != NULL)
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f, "RESULT\n");
indentG += indentStepG;
INDENT (f, indentG);
if (op->arguments->fieldName != NULL)
fprintf (f, "%s ", op->arguments->fieldName);
PrintType (f, head, op->result->type);
indentG -= indentStepG;
}
if ((op->errors == NULL) || (!LIST_EMPTY (op->errors)))
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f, "ERRORS\n");
INDENT (f, indentG);
fprintf (f,"{\n");
indentG += indentStepG;
last = (TypeOrValue*)LAST_LIST_ELMT (op->errors);
FOR_EACH_LIST_ELMT (tOrV, op->errors)
{
INDENT (f, indentG);
if (tOrV->choiceId == TYPEORVALUE_TYPE)
PrintType (f, head, tOrV->a.type);
else
PrintValue (f, NULL, t, tOrV->a.value);
if (tOrV != last)
fprintf (f, ",\n");
}
indentG -= indentStepG;
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f, "}");
}
if ((op->linkedOps != NULL) && (!LIST_EMPTY (op->linkedOps)))
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f, "LINKED\n");
INDENT (f, indentG);
fprintf (f,"{\n");
indentG += indentStepG;
last = (TypeOrValue*)LAST_LIST_ELMT (op->linkedOps);
FOR_EACH_LIST_ELMT (tOrV, op->linkedOps)
{
INDENT (f, indentG);
if (tOrV->choiceId == TYPEORVALUE_TYPE)
PrintType (f, head, tOrV->a.type);
else
PrintValue (f, NULL, t, tOrV->a.value);
if (tOrV != last)
fprintf (f, ",\n");
}
indentG -= indentStepG;
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f, " }");
}
indentG -= indentStepG;
}
void
PrintRosErrorMacroType PARAMS ((f, head, t, bt, err),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
RosErrorMacroType *err)
{
if (bt->a.macroType->choiceId == MACROTYPE_ROSERROR)
fprintf (f,"ERROR\n");
else
fprintf (f,"ABSTRACT-ERROR\n");
indentG += indentStepG;
if (err->parameter != NULL)
{
INDENT (f, indentG);
fprintf (f,"PARAMETER ");
indentG += indentStepG;
PrintElmtType (f, head, t, err->parameter);
indentG -= indentStepG;
}
indentG -= indentStepG;
}
void
PrintRosBindMacroType PARAMS ((f, head, t, bt, bind),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
RosBindMacroType *bind)
{
if (bt->a.macroType->choiceId == MACROTYPE_ROSBIND)
fprintf (f,"BIND");
else
fprintf (f,"UNBIND");
indentG += indentStepG;
if (bind->argument != NULL)
{
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f,"ARGUMENT\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintElmtType (f, head, t, bind->argument);
indentG -= indentStepG;
}
if (bind->result != NULL)
{
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f,"RESULT\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintElmtType (f, head, t, bind->result);
indentG -= indentStepG;
}
if (bind->error != NULL)
{
fprintf (f, "\n");
INDENT (f, indentG);
if (bt->a.macroType->choiceId == MACROTYPE_ROSBIND)
fprintf (f,"BIND-ERROR\n");
else
fprintf (f,"UNBIND-ERROR\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintElmtType (f, head, t, bind->error);
indentG -= indentStepG;
}
indentG -= indentStepG;
}
void
PrintRosAseMacroType PARAMS ((f, head, t, bt, ase),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
RosAseMacroType *ase)
{
Value *v;
Value *last;
fprintf (f, "APPLICATION-SERVICE-ELEMENT");
indentG += indentStepG;
if ((ase->operations != NULL)&& (!LIST_EMPTY (ase->operations)))
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f,"OPERATIONS\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
last = (Value*)LAST_LIST_ELMT (ase->operations);
FOR_EACH_LIST_ELMT (v, ase->operations)
{
INDENT (f, indentG);
PrintValue (f, NULL, t, v);
if (v != last)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
}
else
{
if ((ase->consumerInvokes != NULL) && (!LIST_EMPTY (ase->consumerInvokes)))
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f,"CONSUMER INVOKES\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
last = (Value*) LAST_LIST_ELMT (ase->consumerInvokes);
FOR_EACH_LIST_ELMT (v, ase->consumerInvokes)
{
INDENT (f, indentG);
PrintValue (f, NULL, t, v);
if (v != last)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
}
if ((ase->operations != NULL) && (!LIST_EMPTY (ase->operations)))
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f,"SUPPLIER INVOKES\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
last = (Value*)LAST_LIST_ELMT (ase->supplierInvokes);
FOR_EACH_LIST_ELMT (v, ase->supplierInvokes)
{
INDENT (f, indentG);
PrintValue (f, NULL, t, v);
if (v != last)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
}
}
indentG -= indentStepG;
}
void
PrintRosAcMacroType PARAMS ((f, head, t, bt, ac),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
RosAcMacroType *ac)
{
Value *v;
Value *last;
OID *oid;
OID *lastOid;
fprintf (f, "APPLICATION-CONTEXT");
indentG += indentStepG;
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f,"APPLICATION-SERVICE-ELEMENTS\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
if ((ac->nonRoElements == NULL) && (!LIST_EMPTY (ac->nonRoElements)))
last = (Value*)LAST_LIST_ELMT (ac->nonRoElements);
FOR_EACH_LIST_ELMT (v, ac->nonRoElements)
{
INDENT (f, indentG);
PrintValue (f, NULL, t, v);
if (v != last)
fprintf (f, ",\n");
}
fprintf (f, "}\n");
INDENT (f, indentG);
fprintf (f,"BIND\n");
INDENT (f, indentG);
PrintType (f, head, ac->bindMacroType);
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f,"UNBIND\n");
INDENT (f, indentG);
PrintType (f, head, ac->unbindMacroType);
if (ac->remoteOperations != NULL)
{
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f,"REMOTE OPERATIONS { ");
PrintValue (f, NULL, t, ac->remoteOperations);
fprintf (f, " }");
if ((ac->operationsOf != NULL) && (!LIST_EMPTY (ac->operationsOf)))
{
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f,"OPERATIONS OF\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
last = (Value*)LAST_LIST_ELMT (ac->operationsOf);
FOR_EACH_LIST_ELMT (v, ac->operationsOf)
{
INDENT (f, indentG);
PrintValue (f, NULL, t, v);
if (v != last)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
}
if ((ac->initiatorConsumerOf != NULL) && (!LIST_EMPTY (ac->initiatorConsumerOf)))
{
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f,"INITIATOR CONSUMER OF\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
last = (Value*)LAST_LIST_ELMT (ac->initiatorConsumerOf);
FOR_EACH_LIST_ELMT (v, ac->initiatorConsumerOf)
{
INDENT (f, indentG);
PrintValue (f, NULL, t, v);
if (v != last)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
}
if ((ac->responderConsumerOf != NULL) && (!LIST_EMPTY (ac->responderConsumerOf)))
{
fprintf (f, "\n");
INDENT (f, indentG);
fprintf (f,"RESPONDER CONSUMER OF\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
last = (Value*)LAST_LIST_ELMT (ac->responderConsumerOf);
FOR_EACH_LIST_ELMT (v, ac->responderConsumerOf)
{
INDENT (f, indentG);
PrintValue (f, NULL, t, v);
if (v != last)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
}
}
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f,"ABSTRACT SYNTAXES\n");
INDENT (f, indentG);
fprintf (f, "{\n");
if ((ac->abstractSyntaxes != NULL) && (!LIST_EMPTY (ac->abstractSyntaxes)))
lastOid = (OID*)LAST_LIST_ELMT (ac->abstractSyntaxes);
FOR_EACH_LIST_ELMT (oid, ac->abstractSyntaxes)
{
INDENT (f, indentG);
PrintOid (f, oid);
if (oid != lastOid)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
indentG -= indentStepG;
}
void
PrintMtsasExtensionsMacroType PARAMS ((f, head, t, bt, exts),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
MtsasExtensionsMacroType *exts)
{
Value *v;
Value *last;
fprintf (f, "EXTENSIONS CHOSEN FROM");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
if ((exts->extensions == NULL) && (!LIST_EMPTY (exts->extensions)))
last = (Value*)LAST_LIST_ELMT (exts->extensions);
FOR_EACH_LIST_ELMT (v, exts->extensions)
{
INDENT (f, indentG);
PrintValue (f, NULL, t, v);
if (v != last)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
}
void
PrintMtsasExtensionMacroType PARAMS ((f, head, t, bt, ext),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
MtsasExtensionMacroType *ext)
{
fprintf (f, "EXTENSION");
indentG += indentStepG;
if (ext->elmtType != NULL)
{
fprintf (f, "\n");
INDENT (f, indentG);
PrintElmtType (f, head, t, ext->elmtType);
if (ext->defaultValue != NULL)
{
fprintf (f, " DEFAULT ");
PrintValue (f, NULL, t, ext->defaultValue);
}
}
if ((ext->criticalForSubmission != NULL) ||
(ext->criticalForTransfer != NULL) ||
(ext->criticalForDelivery != NULL))
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f, "CRITICAL FOR ");
if (ext->criticalForSubmission != NULL)
{
fprintf (f, "SUBMISSION");
if ((ext->criticalForTransfer != NULL) ||
(ext->criticalForDelivery != NULL))
fprintf (f,", ");
}
if (ext->criticalForTransfer != NULL)
{
fprintf (f, "TRANSFER, ");
if (ext->criticalForDelivery != NULL)
fprintf (f,", ");
}
if (ext->criticalForDelivery != NULL)
fprintf (f, "DELIVERY");
}
indentG -= indentStepG;
}
void
PrintMtsasExtensionAttributeMacroType PARAMS ((f, head, t, bt, ext),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
MtsasExtensionAttributeMacroType *ext)
{
fprintf (f, "EXTENSION-ATTRIBUTE");
if (ext->type != NULL)
{
fprintf (f, "\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintType (f, head, ext->type);
indentG -= indentStepG;
}
}
void
PrintMtsasTokenMacroType PARAMS ((f, head, t, bt, tok),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
MtsasTokenMacroType *tok)
{
fprintf (f, "TOKEN");
if (tok->type != NULL)
{
fprintf (f, "\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintType (f, head, tok->type);
indentG -= indentStepG;
}
}
void
PrintMtsasTokenDataMacroType PARAMS ((f, head, t, bt, tok),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
MtsasTokenDataMacroType *tok)
{
fprintf (f, "TOKEN-DATA");
if (tok->type != NULL)
{
fprintf (f, "\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintType (f, head, tok->type);
indentG -= indentStepG;
}
}
void
PrintMtsasSecurityCategoryMacroType PARAMS ((f, head, t, bt, sec),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
MtsasSecurityCategoryMacroType *sec)
{
fprintf (f, "SECURITY-CATEGORY");
if (sec->type != NULL)
{
fprintf (f, "\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintType (f, head, sec->type);
indentG -= indentStepG;
}
}
void
PrintAsnObjectMacroType PARAMS ((f, head, t, bt, obj),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
AsnObjectMacroType *obj)
{
AsnPort *ap;
AsnPort *last;
fprintf (f, "OBJECT");
indentG += indentStepG;
if ((obj->ports != NULL) && !LIST_EMPTY (obj->ports))
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f, "PORTS\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
last = (AsnPort*)LAST_LIST_ELMT (obj->ports);
FOR_EACH_LIST_ELMT (ap, obj->ports)
{
INDENT (f, indentG);
PrintValue (f, NULL, t, ap->portValue);
if (ap->portType == CONSUMER_PORT)
fprintf (f, " [C]");
else if (ap->portType == SUPPLIER_PORT)
fprintf (f, " [S]");
if (ap != last)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
}
indentG -= indentStepG;
}
void
PrintAsnPortMacroType PARAMS ((f, head, t, bt, p),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
AsnPortMacroType *p)
{
TypeOrValue *tOrV;
TypeOrValue *last;
fprintf (f, "PORT");
indentG += indentStepG;
if ((p->abstractOps != NULL) && (!LIST_EMPTY (p->abstractOps)))
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f, "ABSTRACT OPERATIONS\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
last = (TypeOrValue*)LAST_LIST_ELMT (p->abstractOps);
FOR_EACH_LIST_ELMT (tOrV, p->abstractOps)
{
INDENT (f, indentG);
if (tOrV->choiceId == TYPEORVALUE_TYPE)
PrintType (f, head, tOrV->a.type);
else
PrintValue (f, NULL, t, tOrV->a.value);
if (tOrV != last)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
}
if ((p->consumerInvokes != NULL) && (!LIST_EMPTY (p->consumerInvokes)))
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f, "CONSUMER INVOKES\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
last = (TypeOrValue*)LAST_LIST_ELMT (p->consumerInvokes);
FOR_EACH_LIST_ELMT (tOrV, p->consumerInvokes)
{
INDENT (f, indentG);
if (tOrV->choiceId == TYPEORVALUE_TYPE)
PrintType (f, head, tOrV->a.type);
else
PrintValue (f, NULL, t, tOrV->a.value);
if (tOrV != last)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
}
if ((p->supplierInvokes != NULL) && (!LIST_EMPTY (p->supplierInvokes)))
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f, "SUPPLIER INVOKES\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
last = (TypeOrValue*)LAST_LIST_ELMT (p->supplierInvokes);
FOR_EACH_LIST_ELMT (tOrV, p->supplierInvokes)
{
INDENT (f, indentG);
if (tOrV->choiceId == TYPEORVALUE_TYPE)
PrintType (f, head, tOrV->a.type);
else
PrintValue (f, NULL, t, tOrV->a.value);
if (tOrV != last)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
}
indentG -= indentStepG;
}
void
PrintAsnAbstractBindMacroType PARAMS ((f, head, t, bt, bind),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
AsnAbstractBindMacroType *bind)
{
AsnPort *ap;
AsnPort *last;
if (bt->a.macroType->choiceId == MACROTYPE_ASNABSTRACTBIND)
fprintf (f, "ABSTRACT-BIND");
else
fprintf (f, "ABSTRACT-UNBIND");
indentG += indentStepG;
if ((bind->ports != NULL) && (!LIST_EMPTY (bind->ports)))
{
fprintf (f,"\n");
INDENT (f, indentG);
if (bt->a.macroType->choiceId == MACROTYPE_ASNABSTRACTBIND)
fprintf (f, "TO\n");
else
fprintf (f, "FROM\n");
INDENT (f, indentG);
fprintf (f, "{\n");
indentG += indentStepG;
last = (AsnPort*)LAST_LIST_ELMT (bind->ports);
FOR_EACH_LIST_ELMT (ap, bind->ports)
{
INDENT (f, indentG);
PrintValue (f, NULL, t, ap->portValue);
if (ap->portType == CONSUMER_PORT)
fprintf (f, " [C]");
else if (ap->portType == SUPPLIER_PORT)
fprintf (f, " [S]");
if (ap != last)
fprintf (f, ",\n");
}
fprintf (f, "\n");
indentG -= indentStepG;
INDENT (f, indentG);
fprintf (f, "}");
}
if (bind->type != NULL)
{
fprintf (f,"\n");
INDENT (f, indentG);
PrintType (f, head, bind->type);
}
indentG -= indentStepG;
}
void
PrintAfAlgorithmMacroType PARAMS ((f, head, t, bt, alg),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
Type *alg)
{
indentG += indentStepG;
fprintf (f, "ALGORITHM PARAMETER ");
PrintType (f, head, alg);
indentG -= indentStepG;
}
void
PrintAfEncryptedMacroType PARAMS ((f, head, t, bt, encrypt),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
Type *encrypt)
{
indentG += indentStepG;
fprintf (f, "ENCRYPTED ");
PrintType (f, head, encrypt);
indentG -= indentStepG;
}
void
PrintAfSignedMacroType PARAMS ((f, head, t, bt, sign),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
Type *sign)
{
indentG += indentStepG;
fprintf (f, "SIGNED ");
PrintType (f, head, sign);
indentG -= indentStepG;
}
void
PrintAfSignatureMacroType PARAMS ((f, head, t, bt, sig),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
Type *sig)
{
indentG += indentStepG;
fprintf (f, "SIGNATURE ");
PrintType (f, head, sig);
indentG -= indentStepG;
}
void
PrintAfProtectedMacroType PARAMS ((f, head, t, bt, p),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
Type *p)
{
indentG += indentStepG;
fprintf (f, "PROTECTED ");
PrintType (f, head, p);
indentG -= indentStepG;
}
void
PrintSnmpObjectTypeMacroType PARAMS ((f, head, t, bt, ot),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt _AND_
SnmpObjectTypeMacroType *ot)
{
TypeOrValue *tOrV;
TypeOrValue *last;
fprintf (f, "OBJECT-TYPE\n");
indentG += indentStepG;
INDENT (f,indentG);
fprintf (f,"SYNTAX ");
indentG += indentStepG;
PrintType (f, head, ot->syntax);
indentG -= indentStepG;
fprintf (f,"\n");
INDENT (f,indentG);
fprintf (f,"ACCESS ");
switch (ot->access)
{
case SNMP_READ_ONLY:
fprintf (f,"read-only");
break;
case SNMP_READ_WRITE:
fprintf (f,"read-write");
break;
case SNMP_WRITE_ONLY:
fprintf (f,"write-only");
break;
case SNMP_NOT_ACCESSIBLE:
fprintf (f,"not-accessible");
break;
default:
fprintf (f," < ?? unknown access type ?? >");
}
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f,"STATUS ");
switch (ot->status)
{
case SNMP_MANDATORY:
fprintf (f,"mandatory");
break;
case SNMP_OPTIONAL:
fprintf (f,"optional");
break;
case SNMP_OBSOLETE:
fprintf (f,"obsolete");
break;
case SNMP_DEPRECATED:
fprintf (f,"deprecated");
break;
default:
fprintf (f," < ?? unknown status type ?? >");
}
if (ot->description != NULL)
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f,"DESCRIPTION\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintValue (f, NULL, t, ot->description);
indentG -= indentStepG;
}
if (ot->reference != NULL)
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f,"REFERENCE\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintValue (f, NULL, t, ot->reference);
indentG -= indentStepG;
}
if (ot->index != NULL)
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f,"INDEX\n");
indentG += indentStepG;
INDENT (f, indentG);
last = (TypeOrValue*)LAST_LIST_ELMT (ot->index);
FOR_EACH_LIST_ELMT (tOrV, ot->index)
{
INDENT (f, indentG);
if (tOrV->choiceId == TYPEORVALUE_TYPE)
PrintType (f, head, tOrV->a.type);
else
PrintValue (f, NULL, t, tOrV->a.value);
if (tOrV != last)
fprintf (f, ",\n");
}
indentG -= indentStepG;
}
if (ot->defVal != NULL)
{
fprintf (f,"\n");
INDENT (f, indentG);
fprintf (f,"DEFVAL\n");
indentG += indentStepG;
INDENT (f, indentG);
PrintValue (f, NULL, t, ot->defVal);
indentG -= indentStepG;
}
fprintf (f,"\n");
indentG -= indentStepG;
}
void
PrintMacroDef PARAMS ((f, head),
FILE *f _AND_
TypeDef *head)
{
char *s;
fprintf (f,"\n-- Note: snacc does not use macro defs to extend the compiler.");
fprintf (f,"\n-- All macros that are understood have been hand coded.");
fprintf (f,"\n-- The macro def body is kept as a string only.\n\n");
s = head->type->basicType->a.macroDef;
fprintf (f, "%s MACRO ::=\n", head->definedName);
fprintf (f, "%s", s);
}
void
PrintEncodedOid PARAMS ((f, eoid),
FILE *f _AND_
AsnOid *eoid)
{
int i;
int arcNum;
int firstArcNum;
int secondArcNum;
if (eoid == NULL)
return;
fprintf (f, "{ ");
for (arcNum = 0, i=0; (i < eoid->octetLen) && (eoid->octs[i] & 0x80);i++)
arcNum = (arcNum << 7) + (eoid->octs[i] & 0x7f);
arcNum = (arcNum << 7) + (eoid->octs[i] & 0x7f);
i++;
firstArcNum = arcNum / 40;
if (firstArcNum > 2)
firstArcNum = 2;
secondArcNum = arcNum - (firstArcNum * 40);
fprintf (f, "%d ", firstArcNum);
fprintf (f, "%d ", secondArcNum);
for (; i < eoid->octetLen; )
{
for (arcNum = 0; (i < eoid->octetLen) && (eoid->octs[i] & 0x80);i++)
arcNum = (arcNum << 7) + (eoid->octs[i] & 0x7f);
arcNum = (arcNum << 7) + (eoid->octs[i] & 0x7f);
i++;
fprintf (f, "%d ", arcNum);
}
fprintf (f, "}");
}
void
SpecialPrintBasicType PARAMS ((f, head, t, bt),
FILE *f _AND_
TypeDef *head _AND_
Type *t _AND_
BasicType *bt)
{
switch (bt->choiceId)
{
case BASICTYPE_SEQUENCE:
fprintf (f, "SEQUENCE");
break;
case BASICTYPE_SET:
fprintf (f, "SET");
break;
case BASICTYPE_CHOICE:
fprintf (f, "CHOICE");
break;
case BASICTYPE_SEQUENCEOF:
fprintf (f, "SEQUENCE ");
if (t->subtypes != NULL)
{
PrintSubtype (f, head, t, t->subtypes);
fprintf (f," ");
}
fprintf (f, "OF ");
SpecialPrintType (f, head, t->basicType->a.sequenceOf);
break;
case BASICTYPE_SETOF:
fprintf (f, "SET ");
if (t->subtypes != NULL)
{
PrintSubtype (f, head, t, t->subtypes);
fprintf (f," ");
}
fprintf (f, "OF ");
SpecialPrintType (f, head, t->basicType->a.sequenceOf);
break;
case BASICTYPE_SELECTION:
fprintf (f, "%s < ", bt->a.selection->fieldName);
PrintType (f, head, bt->a.selection->typeRef);
break;
case BASICTYPE_COMPONENTSOF:
fprintf (f, "COMPONENTS OF ");
PrintType (f, NULL, bt->a.componentsOf);
break;
case BASICTYPE_ANYDEFINEDBY:
fprintf (f, "ANY DEFINED BY %s", bt->a.anyDefinedBy->fieldName);
break;
case BASICTYPE_LOCALTYPEREF:
fprintf (f, "%s", bt->a.localTypeRef->typeName);
break;
case BASICTYPE_IMPORTTYPEREF:
fprintf (f, "%s", bt->a.importTypeRef->typeName);
break;
case BASICTYPE_UNKNOWN:
fprintf (f, "unknown type !?!");
break;
case BASICTYPE_BOOLEAN:
fprintf (f, "BOOLEAN");
break;
case BASICTYPE_INTEGER:
fprintf (f, "INTEGER");
if ((bt->a.integer != NULL) && !LIST_EMPTY (bt->a.integer))
SpecialPrintNamedElmts (f, head, t);
break;
case BASICTYPE_BITSTRING:
fprintf (f, "BIT STRING");
if ((bt->a.bitString != NULL) && !LIST_EMPTY (bt->a.bitString))
SpecialPrintNamedElmts (f, head, t);
break;
case BASICTYPE_OCTETSTRING:
fprintf (f, "OCTET STRING");
break;
case BASICTYPE_NULL:
fprintf (f, "NULL");
break;
case BASICTYPE_OID:
fprintf (f, "OBJECT IDENTIFIER");
break;
case BASICTYPE_REAL:
fprintf (f, "REAL");
break;
case BASICTYPE_ENUMERATED:
fprintf (f, "ENUMERATED");
if ((bt->a.enumerated != NULL) && !LIST_EMPTY (bt->a.enumerated))
SpecialPrintNamedElmts (f, head, t);
break;
case BASICTYPE_ANY:
fprintf (f, "ANY");
break;
case BASICTYPE_MACROTYPE:
switch (bt->a.macroType->choiceId)
{
case MACROTYPE_ROSOPERATION:
case MACROTYPE_ASNABSTRACTOPERATION:
PrintRosOperationMacroType (f, head, t, bt, bt->a.macroType->a.rosOperation);
break;
case MACROTYPE_ROSERROR:
case MACROTYPE_ASNABSTRACTERROR:
PrintRosErrorMacroType (f, head, t, bt, bt->a.macroType->a.rosError);
break;
case MACROTYPE_ROSBIND:
case MACROTYPE_ROSUNBIND:
PrintRosBindMacroType (f, head, t, bt, bt->a.macroType->a.rosBind);
break;
case MACROTYPE_ROSASE:
PrintRosAseMacroType (f, head, t, bt, bt->a.macroType->a.rosAse);
break;
case MACROTYPE_MTSASEXTENSIONS:
PrintMtsasExtensionsMacroType (f, head, t, bt, bt->a.macroType->a.mtsasExtensions);
break;
case MACROTYPE_MTSASEXTENSION:
PrintMtsasExtensionMacroType (f, head, t, bt, bt->a.macroType->a.mtsasExtension);
break;
case MACROTYPE_MTSASEXTENSIONATTRIBUTE:
PrintMtsasExtensionAttributeMacroType (f, head, t, bt, bt->a.macroType->a.mtsasExtensionAttribute);
break;
case MACROTYPE_MTSASTOKEN:
PrintMtsasTokenMacroType (f, head, t, bt, bt->a.macroType->a.mtsasToken);
break;
case MACROTYPE_MTSASTOKENDATA:
PrintMtsasTokenDataMacroType (f, head, t, bt, bt->a.macroType->a.mtsasTokenData);
break;
case MACROTYPE_MTSASSECURITYCATEGORY:
PrintMtsasSecurityCategoryMacroType (f, head, t, bt, bt->a.macroType->a.mtsasSecurityCategory);
break;
case MACROTYPE_ASNOBJECT:
PrintAsnObjectMacroType (f, head, t, bt, bt->a.macroType->a.asnObject);
break;
case MACROTYPE_ASNPORT:
PrintAsnPortMacroType (f, head, t, bt, bt->a.macroType->a.asnPort);
break;
case MACROTYPE_ASNABSTRACTBIND:
case MACROTYPE_ASNABSTRACTUNBIND:
PrintAsnAbstractBindMacroType (f, head, t, bt, bt->a.macroType->a.asnAbstractBind);
break;
case MACROTYPE_AFALGORITHM:
PrintAfAlgorithmMacroType (f, head, t, bt, bt->a.macroType->a.afAlgorithm);
break;
case MACROTYPE_AFENCRYPTED:
PrintAfEncryptedMacroType (f, head, t, bt, bt->a.macroType->a.afEncrypted);
break;
case MACROTYPE_AFSIGNED:
PrintAfSignedMacroType (f, head, t, bt, bt->a.macroType->a.afSigned);
break;
case MACROTYPE_AFSIGNATURE:
PrintAfSignatureMacroType (f, head, t, bt, bt->a.macroType->a.afSignature);
break;
case MACROTYPE_AFPROTECTED:
PrintAfProtectedMacroType (f, head, t, bt, bt->a.macroType->a.afProtected);
break;
case MACROTYPE_SNMPOBJECTTYPE:
PrintSnmpObjectTypeMacroType (f, head, t, bt, bt->a.macroType->a.snmpObjectType);
break;
default:
fprintf (f, "< unknown macro type id ?! >");
}
break;
case BASICTYPE_MACRODEF:
break;
default:
fprintf (f, "< unknown type id ?! >");
}
}
void
SpecialPrintType PARAMS ((f, head, t),
FILE *f _AND_
TypeDef *head _AND_
Type *t)
{
Tag *tag;
Tag *lastTag;
if (t == NULL)
return;
lastTag = NULL;
FOR_EACH_LIST_ELMT (tag, t->tags)
{
if (!(tag->tclass == UNIV && tag->code == LIBTYPE_GET_UNIV_TAG_CODE (t->basicType->choiceId)))
{
PrintTag (f, tag);
fprintf (f, " ");
}
lastTag = tag;
}
if (t->implicit)
fprintf (f, "IMPLICIT ");
SpecialPrintBasicType (f, head, t, t->basicType);
if ((t->subtypes != NULL) &&
(t->basicType->choiceId != BASICTYPE_SETOF) &&
(t->basicType->choiceId != BASICTYPE_SEQUENCEOF))
{
fprintf (f," ");
PrintSubtype (f, head, t, t->subtypes);
}
if (t->defaultVal != NULL)
{
fprintf (f, " DEFAULT ");
if (t->defaultVal->fieldName != NULL)
fprintf (f, "%s ", t->defaultVal->fieldName);
PrintValue (f, NULL, t, t->defaultVal->value);
}
else if (t->optional)
fprintf (f, " OPTIONAL");
#ifdef DEBUG
fprintf (f, " -- lineNo = %d", t->lineNo);
fprintf (f, " --");
#endif
}
void
SpecialPrintNamedElmts PARAMS ((f, head, t),
FILE *f _AND_
TypeDef *head _AND_
Type *t)
{
CNamedElmt *last;
CNamedElmt *cne;
CNamedElmts *n = NULL;
if (t->cTypeRefInfo != NULL)
n = t->cTypeRefInfo->cNamedElmts;
if ((n == NULL) && (t->cxxTypeRefInfo != NULL))
n = t->cxxTypeRefInfo->namedElmts;
if ((n == NULL) || LIST_EMPTY (n))
return;
fprintf (f," { ");
last = (CNamedElmt*)LAST_LIST_ELMT (n);
FOR_EACH_LIST_ELMT (cne, n)
{
fprintf (f, "%s (%d)", cne->name, cne->value);
if (cne != last)
fprintf (f,", ");
}
fprintf (f," } ");
}