#include <stdio.h>
#include <ctype.h>
#include "asn-incl.h"
#include "mem.h"
#include "asn1module.h"
#include "define.h"
#include "str-util.h"
#include "normalize.h"
#include "snacc-util.h"
#include "do-macros.h"
void AddAnyRefByOid PROTO ((AnyRefList **arl, char *enumIdName, AsnOid *oid));
void AddAnyRefByInt PROTO ((AnyRefList **arl, char *enumIdName, AsnInt intId));
void ProcessMacrosInTypeDef PROTO ((Module *m, TypeDef *td));
void ProcessMacrosInValueDef PROTO ((Module *m, ValueDef *vd));
void ProcessMacrosInType PROTO ((Module *m, TypeDef *td, Type *t, ValueDef *v));
void ProcessMacrosInElmtTypes PROTO ((Module *m, TypeDef *td, NamedTypeList *e, ValueDef *v));
void ProcessMacrosInBasicType PROTO ((Module *m, TypeDef *td, Type *type, BasicType *bt, ValueDef *v));
void DefineType PROTO ((Module *m, TypeDef *td, Type *t, char *name));
void ProcessRosOperationMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, RosOperationMacroType *op, ValueDef *v));
void ProcessRosErrorMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, RosErrorMacroType *err, ValueDef *v));
void ProcessRosBindMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, RosBindMacroType *bind, ValueDef *v));
void ProcessRosAseMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, RosAseMacroType *ase, ValueDef *v));
void ProcessRosAcMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, RosAcMacroType *ac, ValueDef *v));
void ProcessMtsasExtensionsMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, MtsasExtensionsMacroType *exts, ValueDef *v));
void ProcessMtsasExtensionMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, MtsasExtensionMacroType *ext, ValueDef *v));
void ProcessMtsasExtensionAttributeMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, MtsasExtensionAttributeMacroType *ext, ValueDef *v));
void ProcessMtsasTokenMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, MtsasTokenMacroType *tok, ValueDef *v));
void ProcessMtsasTokenDataMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, MtsasTokenDataMacroType *tok, ValueDef *v));
void ProcessMtsasSecurityCategoryMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, MtsasSecurityCategoryMacroType *sec, ValueDef *v));
void ProcessAsnObjectMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, AsnObjectMacroType *obj, ValueDef *v));
void ProcessAsnPortMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, AsnPortMacroType *p, ValueDef *v));
void ProcessAsnAbstractBindMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, AsnAbstractBindMacroType *bind, ValueDef *v));
void ProcessSnmpObjectTypeMacroType PROTO ((Module *m, TypeDef *td, Type *t, BasicType *bt, SnmpObjectTypeMacroType *bind, ValueDef *v));
void
ProcessMacros PARAMS ((m),
Module *m)
{
TypeDef *td;
TypeDef **tmpTypeDefHndl;
ValueDef *vd;
FOR_EACH_LIST_ELMT (td, m->typeDefs)
{
ProcessMacrosInTypeDef (m, td);
}
FOR_EACH_LIST_ELMT (vd, m->valueDefs)
{
ProcessMacrosInValueDef (m, vd);
}
}
void
AddAnyRefByOid PARAMS ((arl, enumId, oid),
AnyRefList **arl _AND_
char *enumId _AND_
AsnOid *oid)
{
AnyRef **anyRefHndl;
if (*arl == NULL)
*arl = AsnListNew (sizeof (void*));
anyRefHndl = (AnyRef**)AsnListAppend (*arl);
*anyRefHndl = MT (AnyRef);
(*anyRefHndl)->anyIdName = Malloc (strlen (enumId)+1);
strcpy ((*anyRefHndl)->anyIdName, enumId);
(*anyRefHndl)->id = MT (OidOrInt);
(*anyRefHndl)->id->choiceId = OIDORINT_OID;
(*anyRefHndl)->id->a.oid = MT (AsnOid);
(*anyRefHndl)->id->a.oid->octs = Malloc (oid->octetLen);
memcpy ((*anyRefHndl)->id->a.oid->octs, oid->octs, oid->octetLen);
(*anyRefHndl)->id->a.oid->octetLen = oid->octetLen;
}
void
AddAnyRefByInt PARAMS ((arl, enumId, intId),
AnyRefList **arl _AND_
char *enumId _AND_
AsnInt intId)
{
AnyRef **anyRefHndl;
if (*arl == NULL)
*arl = AsnListNew (sizeof (void*));
anyRefHndl = (AnyRef**)AsnListAppend (*arl);
*anyRefHndl = MT (AnyRef);
(*anyRefHndl)->anyIdName = Malloc (strlen (enumId)+1);
strcpy ((*anyRefHndl)->anyIdName, enumId);
(*anyRefHndl)->id = MT (OidOrInt);
(*anyRefHndl)->id->choiceId = OIDORINT_INTID;
(*anyRefHndl)->id->a.intId = intId;
}
void
ProcessMacrosInValueDef PARAMS ((m, vd),
Module *m _AND_
ValueDef *vd)
{
if (vd == NULL)
return;
if (vd->value->basicValue->choiceId == BASICVALUE_LINKEDOID)
NormalizeValue (m, vd, vd->value, FALSE);
ProcessMacrosInType (m, NULL, vd->value->type, vd);
}
void
ProcessMacrosInTypeDef PARAMS ((m,td),
Module *m _AND_
TypeDef *td)
{
if (td == NULL)
return;
ProcessMacrosInType (m, td, td->type, NULL);
}
void
ProcessMacrosInType PARAMS ((m, td,t, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
ValueDef *v)
{
if (t == NULL)
return;
ProcessMacrosInBasicType (m, td, t, t->basicType, v);
}
void
ProcessMacrosInElmtTypes PARAMS ((m, td, e, v),
Module *m _AND_
TypeDef *td _AND_
NamedTypeList *e _AND_
ValueDef *v)
{
NamedType *nt;
FOR_EACH_LIST_ELMT (nt, e)
{
ProcessMacrosInType (m, td, nt->type, v);
}
}
void
ProcessMacrosInBasicType PARAMS ((m,td,type,bt, v),
Module *m _AND_
TypeDef *td _AND_
Type *type _AND_
BasicType *bt _AND_
ValueDef *v)
{
if (bt == NULL)
return;
switch (bt->choiceId)
{
case BASICTYPE_SEQUENCE:
case BASICTYPE_SET:
case BASICTYPE_CHOICE:
ProcessMacrosInElmtTypes (m, td, bt->a.set,v);
break;
case BASICTYPE_SEQUENCEOF:
case BASICTYPE_SETOF:
ProcessMacrosInType (m, td, bt->a.setOf, v);
break;
case BASICTYPE_MACROTYPE:
switch (bt->a.macroType->choiceId)
{
case MACROTYPE_ASNABSTRACTOPERATION:
case MACROTYPE_ROSOPERATION:
ProcessRosOperationMacroType (m, td, type, bt, bt->a.macroType->a.rosOperation, v);
break;
case MACROTYPE_ROSERROR:
case MACROTYPE_ASNABSTRACTERROR:
ProcessRosErrorMacroType (m, td, type, bt, bt->a.macroType->a.rosError, v);
break;
case MACROTYPE_ROSBIND:
case MACROTYPE_ROSUNBIND:
ProcessRosBindMacroType (m, td, type, bt, bt->a.macroType->a.rosBind,v);
break;
case MACROTYPE_ROSASE:
ProcessRosAseMacroType (m, td, type, bt, bt->a.macroType->a.rosAse,v);
break;
case MACROTYPE_MTSASEXTENSIONS:
ProcessMtsasExtensionsMacroType (m, td, type, bt, bt->a.macroType->a.mtsasExtensions,v);
break;
case MACROTYPE_MTSASEXTENSION:
ProcessMtsasExtensionMacroType (m, td, type, bt, bt->a.macroType->a.mtsasExtension,v);
break;
case MACROTYPE_MTSASEXTENSIONATTRIBUTE:
ProcessMtsasExtensionAttributeMacroType (m, td, type, bt, bt->a.macroType->a.mtsasExtensionAttribute,v);
break;
case MACROTYPE_MTSASTOKEN:
ProcessMtsasTokenMacroType (m, td, type, bt, bt->a.macroType->a.mtsasToken,v);
break;
case MACROTYPE_MTSASTOKENDATA:
ProcessMtsasTokenDataMacroType (m, td, type, bt, bt->a.macroType->a.mtsasTokenData,v);
break;
case MACROTYPE_MTSASSECURITYCATEGORY:
ProcessMtsasSecurityCategoryMacroType (m, td, type, bt, bt->a.macroType->a.mtsasSecurityCategory,v);
break;
case MACROTYPE_ASNOBJECT:
ProcessAsnObjectMacroType (m, td, type, bt, bt->a.macroType->a.asnObject,v);
break;
case MACROTYPE_ASNPORT:
ProcessAsnPortMacroType (m, td, type, bt, bt->a.macroType->a.asnPort,v);
break;
case MACROTYPE_ASNABSTRACTBIND:
case MACROTYPE_ASNABSTRACTUNBIND:
ProcessAsnAbstractBindMacroType (m, td, type, bt, bt->a.macroType->a.asnAbstractBind,v);
break;
case MACROTYPE_AFALGORITHM:
case MACROTYPE_AFENCRYPTED:
case MACROTYPE_AFPROTECTED:
case MACROTYPE_AFSIGNATURE:
case MACROTYPE_AFSIGNED:
break;
case MACROTYPE_SNMPOBJECTTYPE:
ProcessSnmpObjectTypeMacroType (m, td, type, bt, bt->a.macroType->a.snmpObjectType,v);
break;
default:
break;
}
default:
break;
}
}
void
DefineType PARAMS ((m, td, t, name),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
char *name)
{
int digit;
TypeDef *newDef;
TypeDef **tmpTypeDefHndl;
Type *tmpType;
TypeDef *retVal;
if (IsNewType (t))
{
newDef = (TypeDef*)Malloc (sizeof (TypeDef));
newDef->exported = FALSE;
newDef->type = (Type*)Malloc (sizeof (Type));
memcpy (newDef->type, t, sizeof (Type));
newDef->definedName = Malloc (strlen (name)+4);
strcpy (newDef->definedName, name);
if (islower (newDef->definedName[0]))
newDef->definedName[0] =
toupper (newDef->definedName[0]);
for (digit = 0;
(LookupType (m->typeDefs, newDef->definedName) != NULL);
digit++)
AppendDigit (newDef->definedName, digit);
tmpTypeDefHndl = (TypeDef**)AsnListPrepend (m->typeDefs);
*tmpTypeDefHndl = newDef;
SetupType (&tmpType, BASICTYPE_LOCALTYPEREF, 0);
memcpy (t, tmpType, sizeof (Type));
Free (tmpType);
t->implicit = FALSE;
t->basicType->a.localTypeRef = (TypeRef*)Malloc (sizeof (TypeRef));
t->basicType->a.localTypeRef->link = newDef;
t->basicType->a.localTypeRef->module = m;
t->basicType->a.localTypeRef->typeName =
newDef->definedName;
}
}
void
ProcessRosOperationMacroType PARAMS ((m, td, t, bt, op, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
RosOperationMacroType *op _AND_
ValueDef *v)
{
if (op->arguments != NULL)
DefineType (m, td, op->arguments->type, v->definedName);
if (op->result != NULL)
DefineType (m, td, op->result->type, v->definedName);
}
void
ProcessRosErrorMacroType PARAMS ((m, td, t, bt, err, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
RosErrorMacroType *err _AND_
ValueDef *v)
{
if ((err != NULL) && (err->parameter != NULL))
DefineType (m, td, err->parameter->type, v->definedName);
}
void
ProcessRosBindMacroType PARAMS ((m, td, t, bt, bind, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
RosBindMacroType *bind _AND_
ValueDef *v)
{
if (bind != NULL)
{
DefineType (m, td, bind->argument->type, v->definedName);
DefineType (m, td, bind->result->type, v->definedName);
DefineType (m, td, bind->error->type, v->definedName);
}
}
void
ProcessRosAseMacroType PARAMS ((m, td, t, bt, ase, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
RosAseMacroType *ase _AND_
ValueDef *v)
{
}
void
ProcessRosAcMacroType PARAMS ((m, td, t, bt, ac, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
RosAcMacroType *ac _AND_
ValueDef *v)
{
}
void
ProcessMtsasExtensionsMacroType PARAMS ((m, td, t, bt, exts, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
MtsasExtensionsMacroType *exts _AND_
ValueDef *v)
{
}
void
ProcessMtsasExtensionMacroType PARAMS ((m, td, t, bt, ext, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
MtsasExtensionMacroType *ext _AND_
ValueDef *v)
{
}
void
ProcessMtsasExtensionAttributeMacroType PARAMS ((m, td, t, bt, ext, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
MtsasExtensionAttributeMacroType *ext _AND_
ValueDef *v)
{
}
void
ProcessMtsasTokenMacroType PARAMS ((m, td, t, bt, tok, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
MtsasTokenMacroType *tok _AND_
ValueDef *v)
{
}
void
ProcessMtsasTokenDataMacroType PARAMS ((m, td, t, bt, tok, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
MtsasTokenDataMacroType *tok _AND_
ValueDef *v)
{
}
void
ProcessMtsasSecurityCategoryMacroType PARAMS ((m, td, t, bt, sec, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
MtsasSecurityCategoryMacroType *sec _AND_
ValueDef *v)
{
}
void
ProcessAsnObjectMacroType PARAMS ((m, td, t, bt, obj, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
AsnObjectMacroType *obj _AND_
ValueDef *v)
{
}
void
ProcessAsnPortMacroType PARAMS ((m, td, t, bt, p, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
AsnPortMacroType *p _AND_
ValueDef *v)
{
}
void
ProcessAsnAbstractBindMacroType PARAMS ((m, td, t, bt, bind, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
AsnAbstractBindMacroType *bind _AND_
ValueDef *v)
{
}
void
ProcessSnmpObjectTypeMacroType PARAMS ((m, td, t, bt, ot, v),
Module *m _AND_
TypeDef *td _AND_
Type *t _AND_
BasicType *bt _AND_
SnmpObjectTypeMacroType *ot _AND_
ValueDef *v)
{
NamedType *nt;
NamedType **tmpNtHndl;
char anyId[256];
AnyRefList **arlHndl;
if ((ot != NULL) && (ot->syntax != NULL))
DefineType (m, td, ot->syntax, v->definedName);
m->hasAnys = TRUE;
strcpy (anyId, v->definedName);
strcat (anyId, "_ANY_ID");
arlHndl = GetAnyRefListHndl (ot->syntax);
if (v->value->basicValue->choiceId == BASICVALUE_OID)
AddAnyRefByOid (arlHndl, anyId, v->value->basicValue->a.oid);
else
AddAnyRefByInt (arlHndl, anyId, v->value->basicValue->a.integer);
}