def write_macro_for_listof(self, sbml_class): if sbml_class['hasListOf']: if 'lo_elementName' in sbml_class \ and sbml_class['lo_elementName'] != '': lo_name = strFunctions.upper_first( sbml_class['lo_elementName']) else: lo_name = strFunctions.cap_list_of_name(sbml_class['name']) self.write_line('\\newcommand{0}\\{1}{2}{0}\\defRef{0}{1}{2}' '{0}{3}{2}{2}' .format(self.start_b, lo_name, self.end_b, strFunctions.make_class(lo_name))) # hack for render if sbml_class['name'] == 'GradientBase': self.write_line('\\newcommand{0}\\{4}{2}{0}\\defRef{0}{1}{2}' '{0}{3}{2}{2}' .format(self.start_b, lo_name, self.end_b, strFunctions.make_class(lo_name), 'ListOfGradientBases')) elif sbml_class['name'] == 'RenderPoint': self.write_line('\\newcommand{0}\\{4}{2}{0}\\defRef{0}{1}{2}' '{0}{3}{2}{2}' .format(self.start_b, lo_name, self.end_b, strFunctions.make_class(lo_name), 'ListOfRenderPoints'))
def __init__(self, object_desc, spec_name, number, package, pkg_ref): # members from object self.name = object_desc['name'] self.fullname = spec_name self.number = number self.package = package.lower() self.pkg_ref = pkg_ref # useful repeated text strings self.valid = '\\validRule{' self.start_b = '{' self.end_b = '}' self.formatted_name = '\{}'.format(object_desc['name']) self.indef = strFunctions.get_indefinite(object_desc['name']) self.indef_u = strFunctions.upper_first(self.indef) self.reqd_att = [] self.opt_att = [] self.reqd_elem = [] self.opt_elem = [] self.reqd_child_lo_elem = [] self.opt_child_lo_elem = [] self.parse_attributes(self, object_desc['attribs']) self.rules = []
def __init__(self, name, extension, object_desc): BaseFile.BaseFile.__init__(self, name, extension) # change the comment delimiter and line length self.comment = '%' self.line_length = 72 self.package = object_desc['name'] self.fullname = object_desc['fullname'] self.sbml_classes = object_desc['sbmlElements'] self.offset = object_desc['offset'] self.plugins = object_desc['plugins'] self.enums = object_desc['enums'] self.level = object_desc['sbml_level'] self.version = object_desc['sbml_version'] self.pkg_version = object_desc['pkg_version'] self.prim_class = [] self.start_b = '{' self.end_b = '}' # expand the information for the classes self.fulltexname = strFunctions.texify(self.fullname) self.upper_package = strFunctions.upper_first(self.package) self.sort_class_names(self.sbml_classes) self.sort_attribute_names(self.sbml_classes) self.sort_enum_names(self.enums) self.full_pkg_command = '\\{}Package'.format(self.fulltexname) self.brief_pkg_command = '\\{}'.format(self.upper_package)
def get_class(name, root_object): if name.startswith('listOf') or name.startswith('ListOf'): name = strFunctions.singular(name[6:]) else: name = strFunctions.upper_first(name) if root_object is None: return None elif root_object['baseElements'] is None: return None else: for i in range(0, len(root_object['baseElements'])): if name == root_object['baseElements'][i]['name']: return root_object['baseElements'][i]
def write_body_for_lo_class(self, sbml_class, nested=False): lo_name = 'default' if sbml_class['hasListOf']: if 'lo_elementName' in sbml_class \ and sbml_class['lo_elementName'] != '': lo_name = strFunctions.upper_first( sbml_class['lo_elementName']) else: lo_name = strFunctions.cap_list_of_name(sbml_class['name']) # do not write if already written if lo_name in self.classes_written: return self.classes_written.append(lo_name) if 'texname' in sbml_class: classname = sbml_class['texname'] else: classname = sbml_class['name'] self.write_comment_line('---------------------------------------------' '------------') self.write_line('\subsection{0}The \class{0}{1}{2} class{2}' .format(self.start_b, lo_name, self.end_b)) self.write_line('\label{}{}-class{}' .format(self.start_b, lo_name.lower(), self.end_b)) self.skip_line() self.write_to_do('explain {}'.format(lo_name)) self.write_line('The \\{0} object derives from the \\class{1}ListOf{2}' ' and inherits the core attributes and subobjects ' 'from the \\class{1}SBase{2} class. It contains ' 'one or more objects of type \\{3}.' .format(lo_name, self.start_b, self.end_b, classname)) self.skip_line() written = False for i in range(0, len(sbml_class['lo_attribs'])): if not written: self.write_line('In addition the \\{} object has the ' 'following attributes.' .format(lo_name)) self.skip_line() written = True att = sbml_class['lo_attribs'][i] self.write_attibute_paragraph(att, lo_name) if not nested: self.write_body_for_class(self.get_class(sbml_class['name']))
def get_static_extension_attribs(num_versions): attribs = [] att = dict({'name': 'packageName', 'capAttName': 'PackageName', 'attTypeCode': 'std::string&', 'attType': 'string', 'memberName': ''}) attribs.append(att) att = dict({'name': 'defaultLevel', 'capAttName': 'DefaultLevel', 'attTypeCode': 'unsigned int', 'attType': 'unsigned integer', 'memberName': 3}) attribs.append(att) att = dict({'name': 'defaultVersion', 'capAttName': 'DefaultVersion', 'attTypeCode': 'unsigned int', 'attType': 'unsigned integer', 'memberName': 1}) attribs.append(att) att = dict({'name': 'defaultPackageVersion', 'capAttName': 'DefaultPackageVersion', 'attTypeCode': 'unsigned int', 'attType': 'unsigned integer', 'memberName': 1}) attribs.append(att) for i in range(0, num_versions): name = 'xmlnsL3V1V{0}'.format(i+1) cap_name = strFunctions.upper_first(name) att = dict({'name': name, 'capAttName': cap_name, 'attTypeCode': 'std::string&', 'attType': 'string', 'memberName': 'fix this'}) attribs.append(att) return attribs
def write_attribute_type_rule(self, attribute): att_type = attribute['type'] name = strFunctions.wrap_token(attribute['texname'], self.package) if att_type == 'SId': return elif att_type == 'SIdRef': ref_name = strFunctions.upper_first(attribute['name']) # hack for render if ref_name == 'StartHead' or ref_name == 'EndHead': ref_name = 'LineEnding' text = 'The value of the attribute {} of {} {} object must be ' \ 'the identifier of an existing \{} object defined in the ' \ 'enclosing \Model object.'\ .format(name, self.indef, self.formatted_name, ref_name) elif att_type == 'string': text = 'The attribute {} on {} {} must have a value of data ' \ 'type {}.'\ .format(name, self.indef, self.formatted_name, strFunctions.wrap_token('string')) elif att_type == 'int' or att_type == 'uint': text = 'The attribute {} on {} {} must have a value of data ' \ 'type {}.'\ .format(name, self.indef, self.formatted_name, strFunctions.wrap_token('integer')) elif att_type == 'double': text = 'The attribute {} on {} {} must have a value of data ' \ 'type {}.'\ .format(name, self.indef, self.formatted_name, strFunctions.wrap_token('double')) elif att_type == 'boolean' or att_type == 'bool': text = 'The attribute {} on {} {} must have a value of data ' \ 'type {}.'\ .format(name, self.indef, self.formatted_name, strFunctions.wrap_token('boolean')) elif att_type == 'enum': enum_name = strFunctions.texify(attribute['element']) enums = attribute['parent']['root']['enums'] enum_values = self.parse_enum_values(attribute['element'], enums) text = 'The value of the attribute {0} of {1} {2} object must ' \ 'conform to the syntax of SBML data type {3} and ' \ 'may only take on the allowed values of {3} defined ' \ 'in SBML; that is the value must be one of the ' \ 'following {4}.'.format(name, self.indef, self.formatted_name, strFunctions.wrap_enum(enum_name), enum_values) elif att_type == 'array': text = 'The value of the attribute {} of {} {} object must ' \ 'be an array of values of type {}.'\ .format(name, self.indef, self.formatted_name, strFunctions.wrap_token(attribute['element'])) elif att_type == 'element' and attribute['element'] == 'RelAbsVector': text = 'The value of the attribute {0} of {1} {2} object must ' \ 'conform to the syntax of SBML data type \\RelAbsVector ' \ 'i.e. a string encoding optionally an absolute number ' \ 'followed by an optional relative number followed ' \ 'by a \\% sign. Adding spaces between the ' \ 'coordinates is encouraged, but not required.'\ .format(name, self.indef, self.formatted_name) else: text = 'FIX ME: Encountered an unknown attribute type {} in ' \ 'ValidationRulesForClass:write_attribute_type_rule'\ .format(att_type) ref = '{}, {}.'\ .format(self.pkg_ref, strFunctions.wrap_section(self.name)) sev = 'ERROR' return dict({'number': self.number, 'text': text, 'reference': ref, 'severity': sev})
def expand_attributes(attributes): for i in range(0, len(attributes)): capname = strFunctions.upper_first(attributes[i]['name']) attributes[i]['capAttName'] = capname attributes[i]['memberName'] = 'm' + capname attributes[i]['pluralName'] = \ strFunctions.plural(attributes[i]['name']) attributes[i]['isEnum'] = False att_type = attributes[i]['type'] if att_type == 'SId' or att_type == 'SIdRef': attributes[i]['attType'] = 'string' attributes[i]['attTypeCode'] = 'std::string&' attributes[i]['CType'] = 'const char *' attributes[i]['isNumber'] = False elif att_type == 'UnitSId' or att_type == 'UnitSIdRef': attributes[i]['attType'] = 'string' attributes[i]['attTypeCode'] = 'std::string&' attributes[i]['CType'] = 'const char *' attributes[i]['isNumber'] = False elif att_type == 'string': attributes[i]['attType'] = 'string' attributes[i]['attTypeCode'] = 'std::string&' attributes[i]['CType'] = 'const char *' attributes[i]['isNumber'] = False elif att_type == 'double': attributes[i]['attType'] = 'double' attributes[i]['attTypeCode'] = 'double' attributes[i]['CType'] = 'double' attributes[i]['isNumber'] = True elif att_type == 'int': attributes[i]['attType'] = 'integer' attributes[i]['attTypeCode'] = 'int' attributes[i]['CType'] = 'int' attributes[i]['isNumber'] = True elif att_type == 'uint': attributes[i]['attType'] = 'unsigned integer' attributes[i]['attTypeCode'] = 'unsigned int' attributes[i]['CType'] = 'unsigned int' attributes[i]['isNumber'] = True elif att_type == 'bool' or att_type == 'boolean': attributes[i]['attType'] = 'boolean' attributes[i]['attTypeCode'] = 'bool' attributes[i]['CType'] = 'int' attributes[i]['isNumber'] = False elif att_type == 'enum': attributes[i]['isEnum'] = True attributes[i]['attType'] = 'enum' attributes[i]['attTypeCode'] = attributes[i]['element'] + '_t' attributes[i]['CType'] = attributes[i]['element'] + '_t' attributes[i]['isNumber'] = False elif att_type == 'element': attributes[i]['attType'] = 'element' if attributes[i]['name'] == 'math': attributes[i]['attTypeCode'] = 'ASTNode*' attributes[i]['CType'] = 'ASTNode_t*' else: attributes[i]['attTypeCode'] = attributes[i]['element']+'*' attributes[i]['CType'] = attributes[i]['element']+'_t*' attributes[i]['isNumber'] = False elif att_type == 'lo_element': name = strFunctions.list_of_name(attributes[i]['element']) attributes[i]['attType'] = 'lo_element' attributes[i]['attTypeCode'] = name attributes[i]['CType'] = name + '_t' attributes[i]['memberName'] = 'm' + name attributes[i]['isNumber'] = False else: attributes[i]['attType'] = 'FIX ME' attributes[i]['attTypeCode'] = 'FIX ME' attributes[i]['CType'] = 'FIX ME' attributes[i]['isNumber'] = False return attributes
def parse_deviser_xml(filename): """ Parses the given filename and returns a dictionary with the definition contained in it """ sbml_elements = [] elements = [] plugins = [] enums = [] dom = parse(filename) temp = get_value(dom.documentElement, 'name') # we expect this to be lower case package_name = temp.lower() number = to_int(get_value(dom.documentElement, 'number')) offset = to_int(get_value(dom.documentElement, 'offset')) fullname = get_value(dom.documentElement, 'fullname') required = to_bool(get_value(dom.documentElement, 'required')) # get package information (assume we want the first only) sbml_level = 3 sbml_version = 1 pkg_version = 1 for node in dom.getElementsByTagName('pkgVersion'): sbml_level = to_int(get_value(node, 'level')) sbml_version = to_int(get_value(node, 'version')) pkg_version = to_int(get_value(node, 'pkg_version')) break concrete_dict = dict({}) # read concrete versions of abstract classes and fill dictionary for node in dom.getElementsByTagName('element'): element_name = get_value(node, 'name') concrete_list = [] for concrete in node.getElementsByTagName('concrete'): concrete_list.append( dict( {'name': get_value(concrete, "name"), 'element': get_value(concrete, "element")} )) concrete_dict[element_name] = concrete_list # read element for node in dom.getElementsByTagName('element'): element_name = get_value(node, 'name') base_class = get_value(node, 'baseClass') type_code = get_value(node, 'typeCode') has_math = to_bool(get_value(node, 'hasMath')) has_children = to_bool(get_value(node, 'hasChildren')) has_list_of = to_bool(get_value(node, 'hasListOf')) abstract = to_bool(get_value(node, 'abstract')) children_overwrite_element_name = to_bool( get_value(node, 'childrenOverwriteElementName')) temp = get_value(node, 'elementName') # we expect this to be camel case starting with lower if temp is not None: xml_element_name = strFunctions.lower_first(temp) else: xml_element_name = '' temp = get_value(node, 'listOfName') # we expect this to be camel case starting with lower if temp is not None: xml_lo_element_name = strFunctions.lower_first(temp) else: xml_lo_element_name = '' temp = get_value(node, 'listOfClassName') # we expect this to be camel case starting with upper if temp is not None: lo_class_name = strFunctions.upper_first(temp) else: lo_class_name = '' add_decls = get_value(node, 'additionalDecls') add_defs = get_value(node, 'additionalDefs') attributes = [] # add attributes for attr in node.getElementsByTagName('attribute'): attr_name = get_value(attr, 'name') required = to_bool(get_value(attr, 'required')) attr_type = standardize_types(get_value(attr, 'type')) attr_abstract = to_bool(get_value(attr, 'abstract')) attr_element = get_value(attr, 'element') attribute_dict = dict({'type': attr_type, 'reqd': required, 'name': attr_name, 'element': attr_element, 'abstract': attr_abstract, }) if attr_abstract: attribute_dict['concrete'] = concrete_dict[attr_element] attributes.append(attribute_dict) lo_attributes = [] # add attributes for attr in node.getElementsByTagName('listOfAttribute'): attr_name = get_value(attr, 'name') required = to_bool(get_value(attr, 'required')) attr_type = get_value(attr, 'type') attr_abstract = to_bool(get_value(attr, 'abstract')) attr_element = get_value(attr, 'element') attribute_dict = dict({'type': attr_type, 'reqd': required, 'name': attr_name, 'element': attr_element, 'abstract': attr_abstract}) if attr_abstract: attribute_dict['concrete'] = concrete_dict[attr_element] lo_attributes.append(attribute_dict) # construct element element = dict({'name': element_name, 'package': package_name, 'typecode': type_code, 'hasListOf': has_list_of, 'attribs': attributes, 'lo_attribs': lo_attributes, 'hasChildren': has_children, 'hasMath': has_math, 'childrenOverwriteElementName': children_overwrite_element_name, 'baseClass': base_class, 'abstract': abstract }) if xml_element_name is not None: element['elementName'] = xml_element_name if xml_lo_element_name is not None: element['lo_elementName'] = xml_lo_element_name if lo_class_name is not None: element['lo_class_name'] = lo_class_name if add_decls is not None: if os.path.exists(os.path.dirname(filename) + '/' + add_decls): add_decls += os.path.dirname(filename) + '/' element['addDecls'] = add_decls if add_defs is not None: if os.path.exists(os.path.dirname(filename) + '/' + add_defs): add_defs += os.path.dirname(filename) + '/' element['addDefs'] = add_defs if abstract: element['concrete'] = concrete_dict[element_name] elements.append(dict({'name': element_name, 'typecode': type_code, 'isListOf': has_list_of, 'listOfName': xml_lo_element_name if xml_lo_element_name is not None else '', 'listOfClassName': lo_class_name if lo_class_name is not None else ''})) sbml_elements.append(element) for node in dom.getElementsByTagName('plugin'): plug_elements = [] plug_lo_elements = [] ext_point = get_value(node, 'extensionPoint') add_decls = get_value(node, 'additionalDecls') add_defs = get_value(node, 'additionalDefs') # read references to elements for reference in node.getElementsByTagName('reference'): temp = find_element(elements, get_value(reference, 'name')) if temp is not None: plug_elements.append(temp) # look for references to ListOf elements for reference in node.getElementsByTagName('reference'): temp = find_lo_element(elements, get_value(reference, 'name')) if temp is not None: plug_lo_elements.append(temp) attributes = [] # read additional attributes for attr in node.getElementsByTagName('attribute'): attr_name = get_value(attr, 'name') required = to_bool(get_value(attr, 'required')) attr_type = get_value(attr, 'type') attr_abstract = to_bool(get_value(attr, 'abstract')) attr_element = get_value(attr, 'element') attribute_dict = dict({'type': attr_type, 'reqd': required, 'name': attr_name, 'element': attr_element, 'abstract': attr_abstract }) if attr_abstract: attribute_dict['concrete'] = concrete_dict[attr_element] attributes.append(attribute_dict) plugin_dict = dict({'sbase': ext_point, 'extension': plug_elements, 'attribs': attributes, 'lo_extension': plug_lo_elements}) if add_decls is not None: if os.path.exists(os.path.dirname(filename) + '/' + add_decls): add_decls += os.path.dirname(filename) + '/' plugin_dict['addDecls'] = add_decls if add_defs is not None: if os.path.exists(os.path.dirname(filename) + '/' + add_defs): add_defs += os.path.dirname(filename) + '/' plugin_dict['addDefs'] = add_defs plugins.append(plugin_dict) for node in dom.getElementsByTagName('enum'): values = [] enum_name = get_value(node, 'name') for val in node.getElementsByTagName('enumValue'): values.append(dict({'name': get_value(val, 'name'), 'value': get_value(val, 'value')})) enums.append(dict({'name': enum_name, 'values': values})) package = dict({'name': package_name, 'elements': elements, 'plugins': plugins, 'number': number, 'sbmlElements': sbml_elements, 'enums': enums, 'offset': offset, 'fullname': fullname, 'sbml_level': sbml_level, 'sbml_version': sbml_version, 'pkg_version': pkg_version, 'required': required }) # link elements for elem in package['elements']: elem['root'] = package if 'attribs' in elem: for attr in elem['attribs']: attr['parent'] = elem attr['root'] = package for elem in package['sbmlElements']: elem['root'] = package if 'attribs' in elem: for attr in elem['attribs']: attr['parent'] = elem attr['root'] = package if 'concrete' in elem: for attr in elem['concrete']: attr['parent'] = elem attr['root'] = package return package