/* Copyright (C) Boris Nikolaus, Germany, 1996-1997. All rights reserved. */ /* Copyright (C) Microsoft Corporation, 1997-1998. All rights reserved. */ #include "precomp.h" #include "error.h" /* allocate a new value of type _T, copy *_src and return this duplicate */ #define RETDUP(_T, _src) _T *ret; ret = (_T *)malloc(sizeof(_T)); *ret = *(_src); return ret /* constructor of Assignment_t */ Assignment_t * NewAssignment(Assignment_e type) { Assignment_t *ret; ret = (Assignment_t *)malloc(sizeof(Assignment_t)); if (! ret) return NULL; memset(ret, 0, sizeof(Assignment_t)); // ret->Next = NULL; // ret->Identifier = NULL; // ret->Module = NULL; // ret->Flags = 0; // ret->fImportedLocalDuplicate = 0; // ret->fGhost = 0; ret->eDefTagType = eTagType_Unknown; ret->Type = type; switch (type) { case eAssignment_Undefined: break; case eAssignment_ModuleIdentifier: break; case eAssignment_Type: // ret->U.Type.Type = NULL; break; case eAssignment_Value: // ret->U.Value.Value = NULL; break; case eAssignment_ObjectClass: // ret->U.ObjectClass.ObjectClass = NULL; break; case eAssignment_Object: // ret->U.Object.Object = NULL; break; case eAssignment_ObjectSet: // ret->U.ObjectSet.ObjectSet = NULL; break; case eAssignment_Reference: // ret->U.Reference.Identifier = NULL; // ret->U.Reference.Module = NULL; break; } return ret; } /* copy constructor of Assignment_t */ Assignment_t * DupAssignment(Assignment_t *src) { RETDUP(Assignment_t, src); } /* find an assignment by name+moduleidentifier in an assignment list */ Assignment_t * FindAssignment(AssignmentList_t ass, Assignment_e type, char *identifier, ModuleIdentifier_t *module) { Assignment_t *a; Assignment_e at; for (a = ass; a; a = a->Next) { if (a->Type == eAssignment_NextPass) continue; if (type == eAssignment_Undefined) { at = eAssignment_Undefined; } else { at = GetAssignmentType(ass, a); } if (at == type && !strcmp(a->Identifier, identifier) && !CmpModuleIdentifier(ass, a->Module, module)) return a; } return NULL; } /* find an exported assignment by name+moduleidentifier in an assignment list */ Assignment_t * FindExportedAssignment(AssignmentList_t ass, Assignment_e type, char *identifier, ModuleIdentifier_t *module) { Assignment_t *a; Assignment_e at; for (a = ass; a; a = a->Next) { if (a->Type == eAssignment_NextPass || !(a->Flags & eAssignmentFlags_Exported)) continue; if (type == eAssignment_Undefined) { at = eAssignment_Undefined; } else { at = GetAssignmentType(ass, a); } if (at == type && !strcmp(a->Identifier, identifier) && !CmpModuleIdentifier(ass, a->Module, module)) return a; } return NULL; } /* find an assignment by name+moduleidentifier in an assignment list */ /* do not use assignments of previous parsing passes */ Assignment_t * FindAssignmentInCurrentPass(AssignmentList_t ass, char *identifier, ModuleIdentifier_t *module) { for (; ass; ass = ass->Next) { if (ass->Type == eAssignment_NextPass) return NULL; if (!strcmp(ass->Identifier, identifier) && !CmpModuleIdentifier(ass, ass->Module, module)) return ass; } return NULL; } /* resolve assignment references */ Assignment_t * GetAssignment(AssignmentList_t ass, Assignment_t *a) { while (a && a->Type == eAssignment_Reference) { a = FindAssignment(ass, eAssignment_Undefined, a->U.Reference.Identifier, a->U.Reference.Module); } return a; } /* get type of an assignment */ Assignment_e GetAssignmentType(AssignmentList_t ass, Assignment_t *a) { a = GetAssignment(ass, a); return a ? a->Type : eAssignment_Undefined; } /* assign a type */ /* lhs must be an type reference */ /* returns 0 if type is already defined in current parser pass */ int AssignType(AssignmentList_t *ass, Type_t *lhs, Type_t *rhs) { Assignment_t *a; if (lhs->Type != eType_Reference) MyAbort(); for (a = *ass; a && a->Type != eAssignment_NextPass; a = a->Next) { if (a->Type == eAssignment_Type && !strcmp(a->Identifier, lhs->U.Reference.Identifier) && !CmpModuleIdentifier(*ass, a->Module, lhs->U.Reference.Module)) return 0; } // propagate the directives from rhs to lhs PropagatePrivateDirectives(lhs, &(rhs->PrivateDirectives)); // create new assignment a = NewAssignment(eAssignment_Type); a->Identifier = lhs->U.Reference.Identifier; a->Module = lhs->U.Reference.Module; a->U.Type.Type = rhs; a->Next = *ass; *ass = a; return 1; } /* assign a value */ /* lhs must be an value reference */ /* returns 0 if value is already defined in current parser pass */ int AssignValue(AssignmentList_t *ass, Value_t *lhs, Value_t *rhs) { Assignment_t *a; if (lhs->Type) MyAbort(); for (a = *ass; a && a->Type != eAssignment_NextPass; a = a->Next) { if (a->Type == eAssignment_Value && !strcmp(a->Identifier, lhs->U.Reference.Identifier) && !CmpModuleIdentifier(*ass, a->Module, lhs->U.Reference.Module)) return 0; } a = NewAssignment(eAssignment_Value); a->Identifier = lhs->U.Reference.Identifier; a->Module = lhs->U.Reference.Module; a->U.Value.Value = rhs; ASSERT(rhs); if (rhs->Type && rhs->Type->Type == eType_ObjectIdentifier) { AddDefinedOID(a->Identifier, rhs); } a->Next = *ass; *ass = a; return 1; } /* assign a object class */ /* lhs must be an object class reference */ /* returns 0 if object class is already defined in current parser pass */ int AssignObjectClass(AssignmentList_t *ass, ObjectClass_t *lhs, ObjectClass_t *rhs) { Assignment_t *a; if (lhs->Type != eObjectClass_Reference) MyAbort(); for (a = *ass; a && a->Type != eAssignment_NextPass; a = a->Next) { if (a->Type == eAssignment_ObjectClass && !strcmp(a->Identifier, lhs->U.Reference.Identifier) && !CmpModuleIdentifier(*ass, a->Module, lhs->U.Reference.Module)) return 0; } a = NewAssignment(eAssignment_ObjectClass); a->Identifier = lhs->U.Reference.Identifier; a->Module = lhs->U.Reference.Module; a->U.ObjectClass.ObjectClass = rhs; a->Next = *ass; *ass = a; return 1; } /* assign a object */ /* lhs must be an object reference */ /* returns 0 if object is already defined in current parser pass */ int AssignObject(AssignmentList_t *ass, Object_t *lhs, Object_t *rhs) { Assignment_t *a; if (lhs->Type != eObject_Reference) MyAbort(); for (a = *ass; a && a->Type != eAssignment_NextPass; a = a->Next) { if (a->Type == eAssignment_Object && !strcmp(a->Identifier, lhs->U.Reference.Identifier) && !CmpModuleIdentifier(*ass, a->Module, lhs->U.Reference.Module)) return 0; } a = NewAssignment(eAssignment_Object); a->Identifier = lhs->U.Reference.Identifier; a->Module = lhs->U.Reference.Module; a->U.Object.Object = rhs; a->Next = *ass; *ass = a; return 1; } /* assign a object set */ /* lhs must be an object set reference */ /* returns 0 if type is already defined in current parser pass */ int AssignObjectSet(AssignmentList_t *ass, ObjectSet_t *lhs, ObjectSet_t *rhs) { Assignment_t *a; if (lhs->Type != eObjectSet_Reference) MyAbort(); for (a = *ass; a && a->Type != eAssignment_NextPass; a = a->Next) { if (a->Type == eAssignment_ObjectSet && !strcmp(a->Identifier, lhs->U.Reference.Identifier) && !CmpModuleIdentifier(*ass, a->Module, lhs->U.Reference.Module)) return 0; } a = NewAssignment(eAssignment_ObjectSet); a->Identifier = lhs->U.Reference.Identifier; a->Module = lhs->U.Reference.Module; a->U.ObjectSet.ObjectSet = rhs; a->Next = *ass; *ass = a; return 1; } /* assign a macro */ /* lhs must be an macro reference */ /* returns 0 if macro is already defined in current parser pass */ int AssignMacro(AssignmentList_t *ass, Macro_t *lhs, Macro_t *rhs) { Assignment_t *a; if (lhs->Type != eMacro_Reference) MyAbort(); for (a = *ass; a && a->Type != eAssignment_NextPass; a = a->Next) { if (a->Type == eAssignment_Macro && !strcmp(a->Identifier, lhs->U.Reference.Identifier) && !CmpModuleIdentifier(*ass, a->Module, lhs->U.Reference.Module)) return 0; } a = NewAssignment(eAssignment_Macro); a->Identifier = lhs->U.Reference.Identifier; a->Module = lhs->U.Reference.Module; a->U.Macro.Macro = rhs; a->Next = *ass; *ass = a; return 1; } /* define a module identifier */ /* returns 0 if module identifier is already defined in current parser pass */ int AssignModuleIdentifier(AssignmentList_t *ass, ModuleIdentifier_t *module) { Assignment_t *a; for (a = *ass; a && a->Type != eAssignment_NextPass; a = a->Next) { if (a->Type == eAssignment_ModuleIdentifier && !CmpModuleIdentifier(*ass, a->Module, module)) return 0; } a = NewAssignment(eAssignment_ModuleIdentifier); a->Identifier = ""; a->Module = module; a->Next = *ass; *ass = a; return 1; } /* constructor of UndefinedSymbol_t */ UndefinedSymbol_t * NewUndefinedSymbol(UndefinedSymbol_e type, Assignment_e reftype) { UndefinedSymbol_t *ret; ret = (UndefinedSymbol_t *)malloc(sizeof(UndefinedSymbol_t)); if (! ret) return NULL; memset(ret, 0, sizeof(UndefinedSymbol_t)); ret->Type = type; ret->U.Symbol.ReferenceType = reftype; // ret->U.Symbol.Identifier = NULL; // ret->U.Symbol.Module = NULL; // ret->Next = NULL; return ret; } /* constructor of UndefinedSymbol_t */ UndefinedSymbol_t * NewUndefinedField(UndefinedSymbol_e type, ObjectClass_t *oc, Settings_e reffieldtype) { UndefinedSymbol_t *ret; if (oc->Type != eObjectClass_Reference) MyAbort(); ret = (UndefinedSymbol_t *)malloc(sizeof(UndefinedSymbol_t)); if (! ret) return NULL; memset(ret, 0, sizeof(UndefinedSymbol_t)); ret->Type = type; ret->U.Field.ReferenceFieldType = reffieldtype; // ret->U.Field.Identifier = NULL; // ret->U.Field.Module = NULL; ret->U.Field.ObjectClass = oc; // ret->Next = NULL; return ret; } /* find an undefined symbol by type/name/moduleidentifier in a list of */ /* undefined symbols */ UndefinedSymbol_t * FindUndefinedSymbol(AssignmentList_t ass, UndefinedSymbolList_t u, Assignment_e type, char *ide, ModuleIdentifier_t *mod) { for (; u; u = u->Next) { if (u->Type != eUndefinedSymbol_SymbolNotDefined && u->Type != eUndefinedSymbol_SymbolNotExported) continue; if ((type == eAssignment_Undefined || u->U.Symbol.ReferenceType == eAssignment_Undefined || u->U.Symbol.ReferenceType == type) && !strcmp(u->U.Symbol.Identifier, ide) && !CmpModuleIdentifier(ass, u->U.Field.Module, mod)) return u; } return NULL; } /* find an undefined field by type/objectclass/name/moduleidentifier in a */ /* list of undefined symbols */ UndefinedSymbol_t * FindUndefinedField(AssignmentList_t ass, UndefinedSymbolList_t u, Settings_e fieldtype, ObjectClass_t *oc, char *ide, ModuleIdentifier_t *mod) { for (; u; u = u->Next) { if (u->Type != eUndefinedSymbol_FieldNotDefined && u->Type != eUndefinedSymbol_FieldNotExported) continue; if ((fieldtype == eSetting_Undefined || u->U.Field.ReferenceFieldType == eSetting_Undefined || u->U.Field.ReferenceFieldType == fieldtype) && !strcmp(u->U.Field.Identifier, ide) && GetObjectClass(ass, oc) == GetObjectClass(ass, u->U.Field.ObjectClass) && !CmpModuleIdentifier(ass, u->U.Field.Module, mod)) return u; } return NULL; } /* constructor of Type_t */ Type_t * NewType(Type_e type) { Type_t *ret; ret = (Type_t *)malloc(sizeof(Type_t)); if (! ret) return NULL; memset(ret, 0, sizeof(Type_t)); ret->Type = type; // ret->Tags = NULL; // ret->AllTags = NULL; // ret->FirstTags = NULL; // ret->Constraints = NULL; // ret->Directives = NULL; // ret->Flags = 0; ret->Rules = eTypeRules_Normal; ret->TagDefault = eTagType_Unknown; ret->ExtensionDefault = eExtensionType_None; ret->PERConstraints.Value.Type = eExtension_Unconstrained; // ret->PERConstraints.Value.Root = NULL; // ret->PERConstraints.Value.Additional = NULL; ret->PERConstraints.Size.Type = eExtension_Unconstrained; // ret->PERConstraints.Size.Root = NULL; // ret->PERConstraints.Size.Additional = NULL; ret->PERConstraints.PermittedAlphabet.Type = eExtension_Unconstrained; // ret->PERConstraints.PermittedAlphabet.Root = NULL; // ret->PERConstraints.PermittedAlphabet.Additional = NULL; // ret->PrivateDirectives = { 0 }; switch (type) { case eType_Boolean: break; case eType_Integer: case eType_Enumerated: case eType_BitString: // ret->U.IEB.NamedNumbers = NULL; break; case eType_OctetString: case eType_UTF8String: break; case eType_Null: break; case eType_Sequence: case eType_Set: case eType_Choice: case eType_Real: case eType_EmbeddedPdv: case eType_External: case eType_CharacterString: case eType_InstanceOf: // ret->U.SSC.Components = NULL; // ret->U.SSC.Optionals = 0; // ret->U.SSC.Alternatives = 0; // ret->U.SSC.Extensions = 0; // ret->U.SSC.Autotag[0] = 0; // ret->U.SSC.Autotag[1] = 0; break; case eType_SequenceOf: case eType_SetOf: // ret->U.SS.Type = NULL; // ret->U.SS.Directives = NULL; break; case eType_Selection: // ret->U.Selection.Identifier = NULL; // ret->U.Selection.Type = NULL; break; case eType_ObjectIdentifier: break; case eType_BMPString: break; case eType_GeneralString: break; case eType_GraphicString: break; case eType_IA5String: break; case eType_ISO646String: break; case eType_NumericString: break; case eType_PrintableString: break; case eType_TeletexString: break; case eType_T61String: break; case eType_UniversalString: break; case eType_VideotexString: break; case eType_VisibleString: break; case eType_GeneralizedTime: break; case eType_UTCTime: break; case eType_ObjectDescriptor: break; case eType_Undefined: break; case eType_RestrictedString: break; case eType_Reference: // ret->U.Reference.Identifier = NULL; // ret->U.Reference.Module = NULL; break; case eType_FieldReference: // ret->U.FieldReference.ObjectClass = NULL; // ret->U.FieldReference.Identifier = NULL; break; case eType_Macro: // ret->U.Macro.Macro = NULL; // ret->U.Macro.LocalAssignments = NULL; break; } return ret; } /* copy constructor of Type_t */ Type_t * DupType(Type_t *src) { RETDUP(Type_t, src); } /* resolve field reference */ FieldSpec_t * GetReferencedFieldSpec(AssignmentList_t ass, Type_t *type, ObjectClass_t **objectclass) { FieldSpec_t *fs; ObjectClass_t *oc; if (type->Type != eType_FieldReference) MyAbort(); oc = type->U.FieldReference.ObjectClass; oc = GetObjectClass(ass, oc); if (!oc) return NULL; fs = GetFieldSpec(ass, FindFieldSpec(oc->U.ObjectClass.FieldSpec, type->U.FieldReference.Identifier)); if (!fs) return NULL; if (fs->Type == eFieldSpec_Object) oc = fs->U.Object.ObjectClass; else if (fs->Type == eFieldSpec_ObjectSet) oc = fs->U.ObjectSet.ObjectClass; else return NULL; if (objectclass) *objectclass = oc; return GetFieldSpec(ass, fs); } /* resolve type reference */ Type_t * GetReferencedType(AssignmentList_t ass, Type_t *type) { Assignment_t *a; FieldSpec_t *fs; switch (type->Type) { case eType_Reference: a = FindAssignment(ass, eAssignment_Type, type->U.Reference.Identifier, type->U.Reference.Module); a = GetAssignment(ass, a); if (!a) return NULL; return a->U.Type.Type; case eType_FieldReference: fs = GetReferencedFieldSpec(ass, type, NULL); if (!fs) return NULL; switch (fs->Type) { case eFieldSpec_FixedTypeValue: return fs->U.FixedTypeValue.Type; case eFieldSpec_FixedTypeValueSet: return fs->U.FixedTypeValueSet.Type; case eFieldSpec_Type: case eFieldSpec_VariableTypeValue: case eFieldSpec_VariableTypeValueSet: return Builtin_Type_Open; default: return NULL; } /*NOTREACHED*/ default: MyAbort(); /*NOTREACHED*/ } return NULL; } /* constructor of Component_t */ Component_t * NewComponent(Components_e type) { Component_t *ret; ret = (Component_t *)malloc(sizeof(Component_t)); if (! ret) return NULL; memset(ret, 0, sizeof(Component_t)); ret->Type = type; // ret->Next = NULL; switch (type) { case eComponent_Normal: // ret->U.Normal.NamedType = NULL; break; case eComponent_Optional: // ret->U.Optional.NamedType = NULL; break; case eComponent_Default: // ret->U.Default.NamedType = NULL; // ret->U.Default.Value = NULL; break; case eComponent_ComponentsOf: // ret->U.ComponentsOf.Type = NULL; break; case eComponent_ExtensionMarker: /*ret->U.ExtensionMarker.ExceptionSpec = NULL;*/ break; } return ret; } /* copy constructor of Component_t */ Component_t * DupComponent(Component_t *src) { RETDUP(Component_t, src); } /* find a component by name in a list of components */ Component_t * FindComponent(AssignmentList_t ass, ComponentList_t components, char *identifier) { Component_t *c; NamedType_t *namedType; while (components) { switch (components->Type) { case eComponent_Normal: case eComponent_Optional: case eComponent_Default: namedType = components->U.NOD.NamedType; if (namedType && !strcmp(namedType->Identifier, identifier)) return components; break; case eComponent_ComponentsOf: switch (GetTypeType(ass, components->U.ComponentsOf.Type)) { case eType_Sequence: case eType_Set: case eType_Choice: case eType_External: case eType_EmbeddedPdv: case eType_CharacterString: case eType_Real: case eType_InstanceOf: c = FindComponent(ass, GetType(ass, components->U.ComponentsOf.Type)-> U.SSC.Components, identifier); if (c) return c; break; default: break; } break; } components = components->Next; } return NULL; } /* constructor of NamedType_t */ NamedType_t * NewNamedType(char *identifier, Type_t *type) { NamedType_t *ret; ret = (NamedType_t *)malloc(sizeof(NamedType_t)); if (! ret) return NULL; ret->Type = type; ret->Identifier = identifier; return ret; } /* constructor of NamedValue_t */ NamedValue_t * NewNamedValue(char *identifier, Value_t *value) { NamedValue_t *ret; ret = (NamedValue_t *)malloc(sizeof(NamedValue_t)); if (! ret) return NULL; ret->Next = NULL; ret->Value = value; ret->Identifier = identifier; return ret; } /* copy constructor of NamedValue_t */ NamedValue_t * DupNamedValue(NamedValue_t *src) { RETDUP(NamedValue_t, src); } /* find a named value by name in a list of named values */ NamedValue_t * FindNamedValue(NamedValueList_t namedValues, char *identifier) { for (; namedValues; namedValues = namedValues->Next) { if (!strcmp(namedValues->Identifier, identifier)) return namedValues; } return NULL; } /* constructor of NamedNumber_t */ NamedNumber_t * NewNamedNumber(NamedNumbers_e type) { NamedNumber_t *ret; ret = (NamedNumber_t *)malloc(sizeof(NamedNumber_t)); if (! ret) return NULL; memset(ret, 0, sizeof(NamedNumber_t)); // ret->Next = NULL; ret->Type = type; switch (type) { case eNamedNumber_Normal: // ret->U.Normal.Identifier = NULL; // ret->U.Normal.Value = NULL; break; case eNamedNumber_ExtensionMarker: /*XXX*/ break; } return ret; } /* copy constructor of NamedNumber_t */ NamedNumber_t * DupNamedNumber(NamedNumber_t *src) { RETDUP(NamedNumber_t, src); } /* find a named number by name in a list of named numbers */ NamedNumber_t * FindNamedNumber(NamedNumberList_t namedNumbers, char *identifier) { for (; namedNumbers; namedNumbers = namedNumbers->Next) { switch (namedNumbers->Type) { case eNamedNumber_Normal: if (!strcmp(namedNumbers->U.Normal.Identifier, identifier)) return namedNumbers; break; case eNamedNumber_ExtensionMarker: break; } } return NULL; } /* constructor of Value_t */ Value_t * NewValue(AssignmentList_t ass, Type_t *type) { Value_t *ret; ret = (Value_t *)malloc(sizeof(Value_t)); if (! ret) return NULL; memset(ret, 0, sizeof(Value_t)); // ret->Next = NULL; ret->Type = type; if (type) { // ret->Flags = 0; switch (GetTypeType(ass, type)) { case eType_Boolean: // ret->U.Boolean.Value = 0; break; case eType_Integer: ret->U.Integer.Value.length = 1; ret->U.Integer.Value.value = (octet_t *)malloc(1); // ret->U.Integer.Value.value[0] = 0; break; case eType_Enumerated: // ret->U.Enumerated.Value = 0; break; case eType_Real: ret->U.Real.Value.type = eReal_Normal; intx_setuint32(&ret->U.Real.Value.mantissa, 0); intx_setuint32(&ret->U.Real.Value.exponent, 0); ret->U.Real.Value.base = 2; break; case eType_BitString: // ret->U.BitString.Value.length = 0; // ret->U.BitString.Value.value = NULL; break; case eType_OctetString: case eType_UTF8String: // ret->U.OctetString.Value.length = 0; // ret->U.OctetString.Value.value = NULL; break; case eType_Null: break; case eType_SequenceOf: case eType_SetOf: // ret->U.SS.Values = NULL; break; case eType_Sequence: case eType_Set: case eType_Choice: case eType_EmbeddedPdv: case eType_External: case eType_CharacterString: case eType_InstanceOf: // ret->U.SSC.NamedValues = NULL; break; case eType_Selection: break; case eType_ObjectIdentifier: break; case eType_BMPString: break; case eType_GeneralString: break; case eType_GraphicString: break; case eType_IA5String: break; case eType_ISO646String: break; case eType_NumericString: break; case eType_PrintableString: break; case eType_TeletexString: break; case eType_T61String: break; case eType_UniversalString: break; case eType_VideotexString: break; case eType_VisibleString: break; case eType_GeneralizedTime: break; case eType_UTCTime: break; case eType_ObjectDescriptor: break; case eType_Undefined: break; } } else { // ret->U.Reference.Identifier = NULL; // ret->U.Reference.Module = NULL; } return ret; } /* copy constructor of Value_t */ Value_t * DupValue(Value_t *src) { RETDUP(Value_t, src); } /* constructor of ValueSet_t */ ValueSet_t * NewValueSet() { ValueSet_t *ret; ret = (ValueSet_t *)malloc(sizeof(ValueSet_t)); if (! ret) return NULL; memset(ret, 0, sizeof(ValueSet_t)); // ret->Elements = NULL; return ret; } /* copy constructor of ValueSet_t */ ValueSet_t * DupValueSet(ValueSet_t *src) { RETDUP(ValueSet_t, src); } /* constructor of Macro_t */ Macro_t * NewMacro(Macro_e type) { Macro_t *ret; ret = (Macro_t *)malloc(sizeof(Macro_t)); if (! ret) return NULL; ret->Type = type; return ret; } /* copy constructor of Macro_t */ Macro_t * DupMacro(Macro_t *src) { RETDUP(Macro_t, src); } /* constructor of MacroProduction_t */ MacroProduction_t * NewMacroProduction(MacroProduction_e type) { MacroProduction_t *ret; ret = (MacroProduction_t *)malloc(sizeof(MacroProduction_t)); if (! ret) return NULL; memset(ret, 0, sizeof(MacroProduction_t)); ret->Type = type; switch (type) { case eMacroProduction_Alternative: // ret->U.Alternative.Production1 = NULL; // ret->U.Alternative.Production2 = NULL; break; case eMacroProduction_Sequence: // ret->U.Sequence.Production1 = NULL; // ret->U.Sequence.Production2 = NULL; break; case eMacroProduction_AString: // ret->U.AString.String = NULL; break; case eMacroProduction_ProductionReference: // ret->U.ProductionReference.Reference = NULL; break; case eMacroProduction_String: case eMacroProduction_Identifier: case eMacroProduction_Number: case eMacroProduction_Empty: break; case eMacroProduction_Type: // ret->U.Type.LocalTypeReference = NULL; break; case eMacroProduction_Value: // ret->U.Value.LocalTypeReference = NULL; // ret->U.Value.LocalValueReference = NULL; // ret->U.Value.Type = NULL; break; case eMacroProduction_LocalTypeAssignment: // ret->U.LocalTypeAssignment.LocalTypeReference = NULL; // ret->U.LocalTypeAssignment.Type = NULL; break; case eMacroProduction_LocalValueAssignment: // ret->U.LocalValueAssignment.LocalValueReference = NULL; // ret->U.LocalValueAssignment.Value = NULL; break; } return ret; } /* copy constructor of MacroProduction_t */ MacroProduction_t * DupMacroProduction(MacroProduction_t *src) { RETDUP(MacroProduction_t, src); } /* constructor of NamedMacroProduction_t */ NamedMacroProduction_t * NewNamedMacroProduction() { NamedMacroProduction_t *ret; ret = (NamedMacroProduction_t *)malloc(sizeof(NamedMacroProduction_t)); if (! ret) return NULL; memset(ret, 0, sizeof(NamedMacroProduction_t)); // ret->Next = NULL; // ret->Identifier = NULL; // ret->Production = NULL; return ret; } /* copy constructor of NamedMacroProduction */ NamedMacroProduction_t * DupNamedMacroProduction(NamedMacroProduction_t *src) { RETDUP(NamedMacroProduction_t, src); } /* constructor of MacroLocalAssignment_t */ MacroLocalAssignment_t * NewMacroLocalAssignment(MacroLocalAssignment_e type) { MacroLocalAssignment_t *ret; ret = (MacroLocalAssignment_t *)malloc(sizeof(MacroLocalAssignment_t)); if (! ret) return NULL; memset(ret, 0, sizeof(MacroLocalAssignment_t)); // ret->Next = NULL; ret->Type = type; // ret->Identifier = NULL; switch (type) { case eMacroLocalAssignment_Type: // ret->U.Type = NULL; break; case eMacroLocalAssignment_Value: // ret->U.Value = NULL; break; } return ret; } /* copy constructor of MacroLocalAssignment_t */ MacroLocalAssignment_t * DupMacroLocalAssignment(MacroLocalAssignment_t *src) { RETDUP(MacroLocalAssignment_t, src); } /* find a macrolocalassignment by name in a list of macrolocalassignments */ MacroLocalAssignment_t * FindMacroLocalAssignment(MacroLocalAssignmentList_t la, char *ide) { for (; la; la = la->Next) { if (!strcmp(la->Identifier, ide)) break; } return la; } /* constructor of EndPoint_t */ EndPoint_t * NewEndPoint() { EndPoint_t *ret; ret = (EndPoint_t *)malloc(sizeof(EndPoint_t)); if (! ret) return NULL; memset(ret, 0, sizeof(EndPoint_t)); // ret->Flags = 0; // ret->Value = NULL; return ret; } /* constructor of Constraint_t */ Constraint_t * NewConstraint() { Constraint_t *ret; ret = (Constraint_t *)malloc(sizeof(Constraint_t)); if (! ret) return NULL; memset(ret, 0, sizeof(Constraint_t)); ret->Type = eExtension_Unextended; // ret->Root = NULL; // ret->Additional = NULL; return ret; } /* copy constructor of Constraint_t */ Constraint_t *DupConstraint(Constraint_t *src) { RETDUP(Constraint_t, src); } /* constructor of ElementSetSpec_t */ ElementSetSpec_t * NewElementSetSpec(ElementSetSpec_e type) { ElementSetSpec_t *ret; ret = (ElementSetSpec_t *)malloc(sizeof(ElementSetSpec_t)); if (! ret) return NULL; memset(ret, 0, sizeof(ElementSetSpec_t)); ret->Type = type; switch (type) { case eElementSetSpec_AllExcept: // ret->U.AllExcept.Elements = NULL; break; case eElementSetSpec_Union: // ret->U.Union.Elements1 = NULL; // ret->U.Union.Elements2 = NULL; break; case eElementSetSpec_Intersection: // ret->U.Intersection.Elements1 = NULL; // ret->U.Intersection.Elements2 = NULL; break; case eElementSetSpec_Exclusion: // ret->U.Exclusion.Elements1 = NULL; // ret->U.Exclusion.Elements2 = NULL; break; case eElementSetSpec_SubtypeElement: // ret->U.SubtypeElement.SubtypeElement = NULL; break; case eElementSetSpec_ObjectSetElement: // ret->U.ObjectSetElement.ObjectSetElement = NULL; break; default: MyAbort(); } return ret; } /* constructor of SubtypeElement_t */ SubtypeElement_t * NewSubtypeElement(SubtypeElement_e type) { SubtypeElement_t *ret; ret = (SubtypeElement_t *)malloc(sizeof(SubtypeElement_t)); if (! ret) return NULL; memset(ret, 0, sizeof(SubtypeElement_t)); ret->Type = type; switch (type) { case eSubtypeElement_ValueRange: ret->U.ValueRange.Lower.Flags = eEndPoint_Min; // ret->U.ValueRange.Lower.Value = NULL; ret->U.ValueRange.Upper.Flags = eEndPoint_Max; // ret->U.ValueRange.Upper.Value = NULL; break; case eSubtypeElement_Size: // ret->U.Size.Constraints = NULL; break; case eSubtypeElement_SingleValue: // ret->U.SingleValue.Value = NULL; break; case eSubtypeElement_PermittedAlphabet: // ret->U.PermittedAlphabet.Constraints = NULL; break; case eSubtypeElement_ContainedSubtype: // ret->U.ContainedSubtype.Type = NULL; break; case eSubtypeElement_Type: // ret->U.Type.Type = NULL; break; case eSubtypeElement_SingleType: // ret->U.SingleType.Constraints = NULL; break; case eSubtypeElement_FullSpecification: // ret->U.FullSpecification.NamedConstraints = NULL; break; case eSubtypeElement_PartialSpecification: // ret->U.PartialSpecification.NamedConstraints = NULL; break; case eSubtypeElement_ElementSetSpec: // ret->U.ElementSetSpec.ElementSetSpec = NULL; break; } return ret; } /* constructor of ObjectSetElement_t */ ObjectSetElement_t *NewObjectSetElement(ObjectSetElement_e type) { ObjectSetElement_t *ret; ret = (ObjectSetElement_t *)malloc(sizeof(ObjectSetElement_t)); if (! ret) return NULL; memset(ret, 0, sizeof(ObjectSetElement_t)); ret->Type = type; switch (type) { case eObjectSetElement_Object: // ret->U.Object.Object = NULL; break; case eObjectSetElement_ObjectSet: // ret->U.ObjectSet.ObjectSet = NULL; break; case eObjectSetElement_ElementSetSpec: // ret->U.ElementSetSpec.ElementSetSpec = NULL; break; } return ret; } /* constructor of ValueConstraint_t */ ValueConstraint_t * NewValueConstraint() { ValueConstraint_t *ret; ret = (ValueConstraint_t *)malloc(sizeof(ValueConstraint_t)); if (! ret) return NULL; memset(ret, 0, sizeof(ValueConstraint_t)); // ret->Next = NULL; // ret->Lower.Flags = ret->Upper.Flags = 0; // ret->Lower.Value = ret->Upper.Value = NULL; return ret; } /* constructor of NamedConstraint_t */ NamedConstraint_t * NewNamedConstraint() { NamedConstraint_t *ret; ret = (NamedConstraint_t *)malloc(sizeof(NamedConstraint_t)); if (! ret) return NULL; memset(ret, 0, sizeof(NamedConstraint_t)); // ret->Next = NULL; // ret->Identifier = NULL; // ret->Constraint = NULL; ret->Presence = ePresence_Normal; return ret; } /* constructor of Tag_t */ Tag_t * NewTag(TagType_e type) { Tag_t *tag; tag = (Tag_t *)malloc(sizeof(Tag_t)); if (! tag) return NULL; memset(tag, 0, sizeof(Tag_t)); tag->Type = type; tag->Class = eTagClass_Unknown; // tag->Tag = NULL; // tag->Next = NULL; return tag; } /* copy constructor of Tag_t */ Tag_t * DupTag(Tag_t *src) { RETDUP(Tag_t, src); } /* constructor of Directive_t */ Directive_t * NewDirective(Directives_e type) { Directive_t *ret; ret = (Directive_t *)malloc(sizeof(Directive_t)); if (! ret) return NULL; memset(ret, 0, sizeof(Directive_t)); ret->Type = type; // ret->Next = NULL; return ret; } /* copy constructor of Directive_t */ Directive_t * DupDirective(Directive_t *src) { RETDUP(Directive_t, src); } /* constructor of ModuleIdentifier_t */ ModuleIdentifier_t * NewModuleIdentifier() { ModuleIdentifier_t *ret; ret = (ModuleIdentifier_t *)malloc(sizeof(ModuleIdentifier_t)); if (! ret) return NULL; memset(ret, 0, sizeof(ModuleIdentifier_t)); // ret->Identifier = NULL; // ret->ObjectIdentifier = NULL; return ret; } /* constructor of ObjectClass_t */ ObjectClass_t * NewObjectClass(ObjectClass_e type) { ObjectClass_t *ret; ret = (ObjectClass_t *)malloc(sizeof(ObjectClass_t)); if (! ret) return NULL; memset(ret, 0, sizeof(ObjectClass_t)); ret->Type = type; switch (type) { case eObjectClass_ObjectClass: // ret->U.ObjectClass.FieldSpec = NULL; // ret->U.ObjectClass.SyntaxSpec = NULL; break; case eObjectClass_Reference: // ret->U.Reference.Identifier = NULL; // ret->U.Reference.Module = NULL; break; } return ret; } /* constructor of Object_t */ Object_t * NewObject(Object_e type) { Object_t *ret; ret = (Object_t *)malloc(sizeof(Object_t)); if (! ret) return NULL; memset(ret, 0, sizeof(Object_t)); ret->Type = type; switch (type) { case eObject_Object: // ret->U.Object.ObjectClass = NULL; // ret->U.Object.Settings = NULL; break; case eObject_Reference: // ret->U.Reference.Identifier = NULL; // ret->U.Reference.Module = NULL; break; } return ret; } /* constructor of ObjectSet_t */ ObjectSet_t * NewObjectSet(ObjectSet_e type) { ObjectSet_t *ret; ret = (ObjectSet_t *)malloc(sizeof(ObjectSet_t)); if (! ret) return NULL; memset(ret, 0, sizeof(ObjectSet_t)); ret->Type = type; switch (type) { case eObjectSet_ObjectSet: // ret->U.ObjectSet.ObjectClass = NULL; // ret->U.ObjectSet.Elements = NULL; break; case eObjectSet_Reference: // ret->U.Reference.Identifier = NULL; // ret->U.Reference.Module = NULL; break; case eObjectSet_ExtensionMarker: // ret->U.ExtensionMarker.ObjectClass = NULL; // ret->U.ExtensionMarker.Elements = NULL; break; } return ret; } /* constructor of Setting_t */ Setting_t * NewSetting(Settings_e type) { Setting_t *ret; ret = (Setting_t *)malloc(sizeof(Setting_t)); if (! ret) return NULL; memset(ret, 0, sizeof(Setting_t)); ret->Type = type; // ret->Identifier = NULL; // ret->Next = NULL; switch (type) { case eSetting_Type: // ret->U.Type.Type = NULL; break; case eSetting_Value: // ret->U.Value.Value = NULL; break; case eSetting_ValueSet: // ret->U.ValueSet.ValueSet = NULL; break; case eSetting_Object: // ret->U.Object.Object = NULL; break; case eSetting_ObjectSet: // ret->U.ObjectSet.ObjectSet = NULL; break; } return ret; } /* copy constructor of Setting_t */ Setting_t * DupSetting(Setting_t *src) { RETDUP(Setting_t, src); } /* get the type of a setting */ Settings_e GetSettingType(Setting_t *se) { return se ? se->Type : eSetting_Undefined; } /* find a setting by name in a list of settings */ Setting_t * FindSetting(SettingList_t se, char *identifier) { for (; se; se = se->Next) { if (!strcmp(se->Identifier, identifier)) return se; } return NULL; } /* constructor of FieldSpec_t */ FieldSpec_t * NewFieldSpec(FieldSpecs_e type) { FieldSpec_t *ret; ret = (FieldSpec_t *)malloc(sizeof(FieldSpec_t)); if (! ret) return NULL; memset(ret, 0, sizeof(FieldSpec_t)); ret->Type = type; // ret->Identifier = NULL; // ret->Next = NULL; switch (type) { case eFieldSpec_Type: // ret->U.Type.Optionality = NULL; break; case eFieldSpec_FixedTypeValue: // ret->U.FixedTypeValue.Type = NULL; // ret->U.FixedTypeValue.Unique = 0; // ret->U.FixedTypeValue.Optionality = NULL; break; case eFieldSpec_VariableTypeValue: // ret->U.VariableTypeValue.Fields = NULL; // ret->U.VariableTypeValue.Optionality = NULL; break; case eFieldSpec_FixedTypeValueSet: // ret->U.FixedTypeValueSet.Type = NULL; // ret->U.FixedTypeValueSet.Optionality = NULL; break; case eFieldSpec_VariableTypeValueSet: // ret->U.VariableTypeValueSet.Fields = NULL; // ret->U.VariableTypeValueSet.Optionality = NULL; break; case eFieldSpec_Object: // ret->U.Object.ObjectClass = NULL; // ret->U.Object.Optionality = NULL; break; case eFieldSpec_ObjectSet: // ret->U.ObjectSet.ObjectClass = NULL; // ret->U.ObjectSet.Optionality = NULL; break; default: MyAbort(); } return ret; } /* copy constructor of FieldSpec_t */ FieldSpec_t * DupFieldSpec(FieldSpec_t *src) { RETDUP(FieldSpec_t, src); } /* find a fieldspec by name in a list of fieldspecs */ FieldSpec_t * FindFieldSpec(FieldSpecList_t fs, char *identifier) { if (!identifier) return NULL; for (; fs; fs = fs->Next) { if (!strcmp(fs->Identifier, identifier)) return fs; } return NULL; } /* constructor of Optionality_t */ Optionality_t * NewOptionality(Optionality_e type) { Optionality_t *ret; ret = (Optionality_t *)malloc(sizeof(Optionality_t)); if (! ret) return NULL; memset(ret, 0, sizeof(Optionality_t)); ret->Type = type; switch (type) { case eOptionality_Normal: break; case eOptionality_Optional: break; case eOptionality_Default_Type: // ret->U.Type = NULL; break; case eOptionality_Default_Value: // ret->U.Value = NULL; break; case eOptionality_Default_ValueSet: // ret->U.ValueSet = NULL; break; case eOptionality_Default_Object: // ret->U.Object = NULL; break; case eOptionality_Default_ObjectSet: // ret->U.ObjectSet = NULL; break; } return ret; } /* constructor of String_t */ String_t * NewString() { String_t *ret; ret = (String_t *)malloc(sizeof(String_t)); if (! ret) return NULL; memset(ret, 0, sizeof(String_t)); // ret->String = NULL; // ret->Next = NULL; return ret; } /* copy constructor of String_t */ String_t * DupString(String_t *src) { RETDUP(String_t, src); } /* find a string by name in a string list */ String_t * FindString(StringList_t list, char *string) { for (; list; list = list->Next) { if (!strcmp(list->String, string)) return list; } return NULL; } /* constructor of StringModule_t */ StringModule_t * NewStringModule() { StringModule_t *ret; ret = (StringModule_t *)malloc(sizeof(StringModule_t)); if (! ret) return NULL; memset(ret, 0, sizeof(StringModule_t)); // ret->String = NULL; // ret->Module = NULL; // ret->Next = NULL; return ret; } /* copy constructor of StringModule_t */ StringModule_t * DupStringModule(StringModule_t *src) { RETDUP(StringModule_t, src); } /* find a stringmodule by name/module in a list of stringmodules */ StringModule_t * FindStringModule(AssignmentList_t ass, StringModuleList_t list, char *string, ModuleIdentifier_t *module) { for (; list; list = list->Next) { if (!strcmp(list->String, string) && !CmpModuleIdentifier(ass, list->Module, module)) return list; } return NULL; } /* constructor of SyntaxSpec_t */ SyntaxSpec_t * NewSyntaxSpec(SyntaxSpecs_e type) { SyntaxSpec_t *ret; ret = (SyntaxSpec_t *)malloc(sizeof(SyntaxSpec_t)); if (! ret) return NULL; memset(ret, 0, sizeof(SyntaxSpec_t)); // ret->Next = NULL; ret->Type = type; switch (type) { case eSyntaxSpec_Literal: // ret->U.Literal.Literal = NULL; break; case eSyntaxSpec_Field: // ret->U.Field.Field = NULL; break; case eSyntaxSpec_Optional: // ret->U.Optional.SyntaxSpec = NULL; break; } return ret; } /* copy constructor of SyntaxSpec_t */ SyntaxSpec_t * DupSyntaxSpec(SyntaxSpec_t *src) { RETDUP(SyntaxSpec_t, src); } /* check if a type depends on other types which would be declared later */ /* returns 1 if the type depends on a type of the unknown list and */ /* therefore has to be defined later */ /* returns 0 if the type can be defined now */ int Depends(AssignmentList_t known, AssignmentList_t unknown, Type_t *type, Type_t *parent) { Type_t *reftype; int isunknown = 0; /* no dependency if no type is referenced */ if (type->Type != eType_Reference && type->Type != eType_FieldReference) return 0; /* get the directly referenced type */ reftype = GetReferencedType(known, type); if (!reftype) { reftype = GetReferencedType(unknown, type); isunknown = 1; } if (!reftype) MyAbort(); // fix intermediate pdu if (IsStructuredType(reftype) || IsSequenceType(reftype) || IsReferenceType(reftype)) { reftype->Flags |= eTypeFlags_MiddlePDU; } /* no dependency if a structured type is referenced by use of pointer */ /* because a 'struct XXX_s *' can be used */ if (IsStructuredType(reftype) && (type->Rules & eTypeRules_IndirectMask)) return 0; /* no dependency if a structured type is referenced in an length-pointer */ /* type, because a 'struct XXX_s *values' can be used */ if (IsStructuredType(reftype) && (parent->Rules & eTypeRules_LengthPointer)) return 0; // special case for pointer related components if (! isunknown && IsStructuredType(reftype) && (parent->Rules & eTypeRules_LinkedListMask)) return 0; // special case for SequenceOf and SetOf because they are using Pxxx. if ((reftype->Type == eType_SequenceOf || reftype->Type == eType_SetOf) && (reftype->Rules & (eTypeRules_LinkedListMask | eTypeRules_PointerToElement))) // && (type->Rules & eTypeRules_IndirectMask)) return 0; /* return true if referenced type is unknown up to now */ return isunknown; } /* sort the assignments */ /* obtain an order usable by C type definitions */ void SortAssignedTypes(AssignmentList_t *a) { Assignment_t *list, *curr, *next, **prev, **last; int depends; Component_t *components; Type_t *type; int flag; int structured; /* list will contain the unordered assignments */ list = *a; /* *a is the ordered list of assignments */ *a = NULL; /* last will be used for appending to the list of ordered assignments */ last = a; /* at first try to dump all non-structured types */ structured = 0; /* we have to move all elements of the unordered assignment list into */ /* the list of the ordered assignments */ while (list) { /* flag if any assignment has been moved */ flag = 0; /* examine every element in the unordered list */ for (prev = &list, curr = list; curr; ) { /* flag if the current type depends on another type and */ /* therefore cannot be moved now */ depends = 0; /* only types will need dependencies */ if (curr->Type == eAssignment_Type) { /* examine the current type */ switch (curr->U.Type.Type->Type) { case eType_Sequence: case eType_Set: case eType_Choice: case eType_External: case eType_EmbeddedPdv: case eType_CharacterString: case eType_Real: case eType_InstanceOf: /* structured types shall not be moved in the first pass */ if (!structured) { depends = 1; break; } /* examine all components of the current type */ for (components = curr->U.Type.Type->U.SSC.Components; components && !depends; components = components->Next) { switch (components->Type) { case eComponent_Normal: case eComponent_Optional: case eComponent_Default: /* check if the type of the component depends */ /* on an undefined type */ type = components->U.NOD.NamedType->Type; depends |= Depends(*a, list, type, curr->U.Type.Type); break; case eComponent_ComponentsOf: /* components of should have been already */ /* resolved */ MyAbort(); /*NOTREACHED*/ case eComponent_ExtensionMarker: break; } } break; case eType_SequenceOf: case eType_SetOf: /* structured types shall not be moved in the first pass */ if (!structured) { depends = 1; break; } /* check if the type of the elements depends on an */ /* undefined type */ type = curr->U.Type.Type->U.SS.Type; depends |= Depends(*a, list, type, curr->U.Type.Type); break; case eType_Reference: /* check if the referenced type depends on an */ /* undefined type */ type = curr->U.Type.Type; depends |= Depends(*a, list, type, curr->U.Type.Type); break; } } /* move assignment into ordered assignment list if there's no */ /* unresolved dependency */ if (!depends) { next = curr->Next; *last = curr; curr->Next = NULL; last = &curr->Next; curr = next; *prev = curr; flag = 1; } else { prev = &curr->Next; curr = curr->Next; } } /* if no types have been moved, allow examination of structured types */ /* if already allowed structured types, MyAbort because of cyclic */ /* type definitions */ if (!flag) { if (!structured) { structured = 1; } else { if (! curr || ! curr->Next) { error(E_recursive_type_definition, NULL); } } } } } // --- The following is added by Microsoft --- static const char *c_aReservedWords[] = { // special for C language "__asm", "__based", "__cdecl", "__declspec", "__except", "__fastcall", "__finally", "__inline", "__int16", "__int32", "__int64", "__int8", "__leave", "__multiple_inheritance", "__single_inheritance", "__stdcall", "__try", "__uuidof", "__virtual_inheritance", "auto", "bool", "break", "case", "catch", "char", "class", "const", "const_cast", "continue", "default", "delete", "dllexport", "dllimport", "do", "double", "dynamic_cast", "else", "enum", "explicit", "extern", "false", "float", "for", "friend", "goto", "if", "inline", "int", "long", "main", "mutable", "naked", "namespace", "new", "operator", "private", "protected", "public", "register", "reinterpret_cast", "return", "short", "signed", "sizeof", "static", "static_cast", "struct", "switch", "template", "this", "thread", "throw", "true", "try", "typedef", "typeid", "typename", "union", "unsigned", "using", "uuid", "virtual", "void", "volatile", "while", "wmain", "xalloc" }; int IsReservedWord ( char *psz ) { int cWords = sizeof(c_aReservedWords) / sizeof(c_aReservedWords[0]); const char **ppszWord; for (ppszWord = &c_aReservedWords[0]; cWords--; ppszWord++) { if (strcmp(psz, *ppszWord) == 0) return 1; } return 0; } typedef struct ConflictNameList_s { struct ConflictNameList_s *next; char *pszName; unsigned int cInstances; } ConflictNameList_t; static ConflictNameList_t *g_pEnumNameList = NULL; // ENUMERATED static ConflictNameList_t *g_pOptNameList = NULL; // OPTIONAL static ConflictNameList_t *g_pChoiceNameList = NULL; // CHOICE void KeepConflictNames ( ConflictNameList_t **ppListHead, char *pszName ) { ConflictNameList_t *p; char *psz; char szName[256]; strcpy(&szName[0], pszName); for (psz = &szName[0]; *psz; psz++) { if (*psz == '-') *psz = '_'; } for (p = *ppListHead; p; p = p->next) { if (strcmp(p->pszName, &szName[0]) == 0) { p->cInstances++; return; } } p = (ConflictNameList_t *) malloc(sizeof(ConflictNameList_t)); if (p) { memset(p, 0, sizeof(ConflictNameList_t)); p->next = *ppListHead; *ppListHead = p; p->cInstances = 1; p->pszName = strdup(&szName[0]); } } void KeepEnumNames ( char *pszEnumName ) { KeepConflictNames(&g_pEnumNameList, pszEnumName); } void KeepOptNames ( char *pszOptName ) { KeepConflictNames(&g_pOptNameList, pszOptName); } void KeepChoiceNames ( char *pszChoiceName ) { KeepConflictNames(&g_pChoiceNameList, pszChoiceName); } unsigned int GetConflictNameInstanceCount ( ConflictNameList_t *pListHead, char *pszName ) { ConflictNameList_t *p; for (p = pListHead; p; p = p->next) { if (strcmp(p->pszName, pszName) == 0) { return p->cInstances; } } return 0; } int DoesEnumNameConflict ( char *pszEnumName ) { return (GetConflictNameInstanceCount(g_pEnumNameList, pszEnumName) > 2); // counted twice } int DoesOptNameConflict ( char *pszOptName ) { return (GetConflictNameInstanceCount(g_pOptNameList, pszOptName) > 2); // counted twice } int DoesChoiceNameConflict ( char *pszChoiceName ) { return (GetConflictNameInstanceCount(g_pChoiceNameList, pszChoiceName) > 2); // counted twice } int IsImportedLocalDuplicate(AssignmentList_t ass, ModuleIdentifier_t *pMainModule, Assignment_t *curr) { if (0 == CmpModuleIdentifier(ass, curr->Module, pMainModule)) { Assignment_t *a; for (a = ass; a; a = a->Next) { if (a->Flags & eAssignmentFlags_LongName) { if (0 == strcmp(a->Identifier, curr->Identifier)) { if (0 != CmpModuleIdentifier(ass, a->Module, curr->Module)) { return 1; } } } } } return 0; } DefinedObjectID_t *g_pDefinedObjectIDs = NULL; Value_t *GetDefinedOIDValue ( char *pszName ) { if (pszName) { DefinedObjectID_t *p; for (p = g_pDefinedObjectIDs; p; p = p->next) { if (strcmp(pszName, p->pszName) == 0) { return p->pValue; } } } return NULL; } void AddDefinedOID ( char *pszName, Value_t *pValue ) { // add it only when it does not exist if (! GetDefinedOIDValue(pszName)) { DefinedObjectID_t *p; p = (DefinedObjectID_t *) malloc(sizeof(DefinedObjectID_t)); if (p) { p->next = g_pDefinedObjectIDs; p->pszName = pszName; p->pValue = pValue; g_pDefinedObjectIDs = p; } } } void PropagatePrivateDirectives ( Type_t *pDst, PrivateDirectives_t *pSrc ) { if (pSrc && pDst) { if (! pDst->PrivateDirectives.pszTypeName) { pDst->PrivateDirectives.pszTypeName = pSrc->pszTypeName; } if (! pDst->PrivateDirectives.pszFieldName) { pDst->PrivateDirectives.pszFieldName = pSrc->pszFieldName; } if (! pDst->PrivateDirectives.pszValueName) { pDst->PrivateDirectives.pszValueName = pSrc->pszValueName; } pDst->PrivateDirectives.fPublic |= pSrc->fPublic; pDst->PrivateDirectives.fIntx |= pSrc->fIntx; pDst->PrivateDirectives.fLenPtr |= pSrc->fLenPtr; pDst->PrivateDirectives.fPointer |= pSrc->fPointer; pDst->PrivateDirectives.fArray |= pSrc->fArray; pDst->PrivateDirectives.fNoCode |= pSrc->fNoCode; pDst->PrivateDirectives.fNoMemCopy |= pSrc->fNoMemCopy; pDst->PrivateDirectives.fOidPacked |= pSrc->fOidPacked; pDst->PrivateDirectives.fOidArray |= pSrc->fOidArray; pDst->PrivateDirectives.fSLinked |= pSrc->fSLinked; pDst->PrivateDirectives.fDLinked |= pSrc->fDLinked; } } void PropagateReferenceTypePrivateDirectives ( Type_t *pDst, PrivateDirectives_t *pSrc ) { if (pSrc && pDst) { pDst->PrivateDirectives.fPublic |= pSrc->fPublic; pDst->PrivateDirectives.fIntx |= pSrc->fIntx; pDst->PrivateDirectives.fLenPtr |= pSrc->fLenPtr; pDst->PrivateDirectives.fPointer |= pSrc->fPointer; pDst->PrivateDirectives.fArray |= pSrc->fArray; pDst->PrivateDirectives.fNoCode |= pSrc->fNoCode; pDst->PrivateDirectives.fNoMemCopy |= pSrc->fNoMemCopy; pDst->PrivateDirectives.fOidPacked |= pSrc->fOidPacked; pDst->PrivateDirectives.fOidArray |= pSrc->fOidArray; pDst->PrivateDirectives.fSLinked |= pSrc->fSLinked; pDst->PrivateDirectives.fDLinked |= pSrc->fDLinked; } } char *GetPrivateValueName(PrivateDirectives_t *pPrivateDirectives, char *pszDefValueName) { return pPrivateDirectives->pszValueName ? pPrivateDirectives->pszValueName : pszDefValueName; }