MOF_Instance_Decl* MOF_Instance_Decl::find_by_alias( char* alias, bool fix_case) { MOF_Instance_Decl* p; if (!alias) return 0; for (p = MOF_Instance_Decl::list; p; p = (MOF_Instance_Decl*)p->next) { if (p->alias && MOF_stricmp(p->alias, alias) == 0) { if (fix_case && strcmp(p->alias, alias) != 0) { #if 0 MOF_warning_printf("changing case of \"%s\" to \"%s\"", alias, p->alias); #endif strcpy(alias, p->alias); } return p; } } return 0; }
static MOF_mask _make_qual_mask( MOF_Qualifier_Info* qual_info_list, bool prop, bool param) { MOF_Qualifier_Info* p; MOF_mask mask = 0; size_t i; /* * Set bits for qualifiers whose default is true. */ if (prop) mask |= MOF_QT_READ; if (param) mask |= MOF_QT_IN; /* * Iterate over qualifier list and either set or clear the corresponding * qualifier bit. */ for (p = qual_info_list; p != 0; p = (MOF_Qualifier_Info*)p->next) { for (i = 0; i < NUM_PAIRS; i++) { if (MOF_stricmp(_pairs[i].name, p->qualifier->name) == 0) { MOF_Literal* lit = p->qualifier->params; bool flag = true; /* * Ignore errors (these are checked elsewhere). */ if (lit && (lit->next || lit->value_type != TOK_BOOL_VALUE)) continue; if (lit && !lit->bool_value) flag = false; if (flag) mask |= _pairs[i].mask; else mask &= ~_pairs[i].mask; } } } return mask; }
static void _check_duplicate_properties( MOF_Instance_Decl* inst_decl) { MOF_Property* p; MOF_Property* q; for (p = inst_decl->properties; p; p = (MOF_Property*)p->next) { for (q = inst_decl->properties; q != p; q = (MOF_Property*)q->next) { if (MOF_stricmp(p->name, q->name) == 0) MOF_error_printf("duplicate property: \"%s\"", p->name); } } }
static void _check_undefined_properties( const MOF_Class_Decl* class_decl, MOF_Instance_Decl* inst_decl) { MOF_Property* p; /* * First check that all instance properties are declared in class * and that the types are consistent. */ for (p = inst_decl->properties; p; p = (MOF_Property*)p->next) { bool found; MOF_Feature_Info* q; found = false; for (q = class_decl->all_features; q; q = (MOF_Feature_Info*)q->next) { MOF_Feature* feature = q->feature; if (MOF_stricmp(p->name, feature->name) == 0) { MOF_fix_case(p->name, feature->name); if (feature->type != MOF_FEATURE_METHOD) found = true; break; } } if (!found) { MOF_error_printf("no such property found in class: \"%s\"", p->name); return; } } }
static void _build_all_features_list( const MOF_Class_Decl* class_decl, MOF_Instance_Decl* inst_decl) { MOF_Feature_Info* p; MOF_Feature_Info* all_features = 0; MOF_Property* q; /* * Iterate the properties in the class and build the all-properties list. */ for (p = class_decl->all_features; p; p = (MOF_Feature_Info*)p->next) { MOF_Feature* feature = p->feature; MOF_Feature_Info* new_feature_info; MOF_Property* inst_prop = 0; /* * First, search for this feature in the instance declaration. */ for (q = inst_decl->properties; q; q = (MOF_Property*)q->next) { if (MOF_stricmp(feature->name, q->name) == 0) { inst_prop = q; break; } } /* * Create a new MOF_Feature_Info object. */ if ((new_feature_info = new MOF_Feature_Info()) == 0) { MOF_error("out of memory"); return; } /* * If instance contains a property with this name: */ if (inst_prop) { if (feature->type == MOF_FEATURE_PROP) { MOF_Property_Decl* prop_decl; /* * Clone the feature (and initialize). */ prop_decl = (MOF_Property_Decl*) ((MOF_Property_Decl*)feature)->clone(); if (prop_decl == 0) { MOF_error("out of memory"); return; } prop_decl->qualifiers = inst_prop->qualifiers; prop_decl->all_qualifiers = 0; prop_decl->qual_mask = 0; prop_decl->initializer = inst_prop->initializer; /* * Initialize the new_feature_info structure: */ new_feature_info->feature = (MOF_Feature*)prop_decl; new_feature_info->class_origin = p->class_origin; new_feature_info->propagated = p->propagated; /* * Build the all qualifiers list */ prop_decl->all_qualifiers = MOF_Qualifier_Info::make_all_qualifiers( class_decl->name, 0, inst_prop->name, 0, prop_decl->qualifiers, feature->all_qualifiers, &prop_decl->qual_mask, true); /* prop */ /* * Validate the initializer (if any). */ if (inst_prop->initializer) { inst_prop->initializer->validate("property", inst_prop->name, prop_decl->data_type, prop_decl->array_index); } } else if (feature->type == MOF_FEATURE_REF) { MOF_Reference_Decl* ref_decl; /* * Clone the feature (and initialize). */ ref_decl = (MOF_Reference_Decl*) ((MOF_Reference_Decl*)feature)->clone(); if (ref_decl == 0) { MOF_error("out of memory"); return; } ref_decl->qualifiers = inst_prop->qualifiers; ref_decl->all_qualifiers = 0; ref_decl->qual_mask = 0; ref_decl->alias = 0; /* * Initialize the new_feature_info structure: */ new_feature_info->feature = (MOF_Feature*)ref_decl; new_feature_info->class_origin = p->class_origin; new_feature_info->propagated = p->propagated; /* * Build the all qualifiers list */ ref_decl->all_qualifiers = MOF_Qualifier_Info::make_all_qualifiers( class_decl->name, 0, inst_prop->name, 0, ref_decl->qualifiers, feature->all_qualifiers, &ref_decl->qual_mask, false); /* prop */ /* * Validate the alias (ATTN) OR object reference. */ if (inst_prop->initializer) { MOF_Object_Reference* obj_ref = 0; /* * Since it's a reference, we expect a string initializer. */ if (inst_prop->initializer->value_type != TOK_STRING_VALUE) { MOF_error_printf( "bad ref initializer for property: \"%s\"", inst_prop->name); return; } /* * Parse the object reference string: */ if (REF_parse( inst_prop->initializer->string_value, &obj_ref) != 0) { MOF_error_printf( "bad ref initializer for property: \"%s\"", inst_prop->name); return; } /* * Validate and normalize new object reference. */ obj_ref->validate(); obj_ref->normalize(); /* * Be sure the class of the initializer is a sub-class * of the class of the class's ref decl. */ ref_decl->validate_obj_ref(obj_ref); ref_decl->obj_ref = obj_ref; } else if (inst_prop->alias) { MOF_Object_Reference* obj_ref = MOF_Instance_Decl::alias_to_obj_ref(inst_prop->alias); /* * Be sure the class of the initializer is a sub-class * of the class of the class's ref decl. */ ref_decl->validate_obj_ref(obj_ref); ref_decl->obj_ref = obj_ref; } } } else { /* * Propagate feature from class. */ new_feature_info->feature = p->feature; new_feature_info->class_origin = p->class_origin; new_feature_info->propagated = true; } /* * Append to list: */ if (all_features) all_features->append(new_feature_info); else all_features = new_feature_info; } inst_decl->all_features = all_features; }
void MOF_Qualifier::validate() { MOF_Qualifier_Decl* qual_decl; /* * Find qualifier declaration: */ if ((qual_decl = MOF_Qualifier_Decl::find(name)) == 0) MOF_error_printf("undefined qualifier: \"%s\"\n", name); /* * The presence of a scalar boolean qualifier without arguments implies * true. */ if (qual_decl->data_type == TOK_BOOLEAN && qual_decl->array_index == 0 && (params == 0 || params->value_type == TOK_NULL_VALUE)) { params->delete_list(); params = new MOF_Literal(); params->value_type = TOK_BOOL_VALUE; params->bool_value = true; } /* * Check the qualifier params (if any): */ if (params) { params->validate("qualifier", name, qual_decl->data_type, qual_decl->array_index); } /* * Free descriptions: */ #if 0 /* * Release descriptions (to see how much memory they take). */ if (MOF_stricmp(name, "description") == 0) { if (params && params->u.string_value) { free (params->u.string_value); params->u.string_value = 0; free (params); params = 0; } free (name); name = (char*)DESCRIPTION; } #endif }