tab_size = child.GetSize()

for page_idx in xrange(child.GetPageCount()):

page = child.GetWindowFromIdx(page_idx)

tab["size"] = (tab_size[0], tab_size[1] + page.GetSize()[1])

tab_infos = self.GetTabInfos(page)

if tab_infos is not None:

return

raise ValueError, "Not supported"

self.LoadTabLayout(notebook, tabs["others"])

split_dir, split_ratio = tabs["split"]

self.TreeImageDict[self.Controler.GetPouBodyType(infos["name"])])

if item_alone:

self.ProjectTree.SetItemExtraImage(root, self.Controler.GetPouType(infos["name"]))

icon_name = infos["icon"]

self.TreeImageDict[icon_name] = self.TreeImageList.Add(GetBitmap(icon_name))

self.ProjectTree.SetItemImage(root, self.TreeImageDict[icon_name])

self.ProjectTree.SetItemImage(root, self.TreeImageDict[infos["type"]])

item, root_cookie = self.ProjectTree.GetFirstChild(root)

# Return Base Type of given possible derived type

def GetBaseType(self, typename, debug=False):

return typename

datatype = self.GetDataType(typename, debug)

exclude[stepname] = True

instance.setname(stepname)

localid = instance.getlocalId()

new_id[localid] = True

idx = 1

for instance in instances:

localId = instance.getlocalId()

bbox.union(instance.getBoundingBox())

idx += 1

new_id[idx] = True

instance.setlocalId(idx)

pou = self.Project.getpou(pou_name)

pou_type = pou.getpouType()

# Verify that POU type exists

# Create a POU program generator

pou_program = PouProgramGenerator(self, pou.getname(), pouTypeNames[pou_type], self.Errors, self.Warnings)

program = pou_program.GenerateProgram(pou)

if isinstance(instance, (OutVariableClass, InOutVariableClass)):

self.ConnectionTypes[instance.connectionPointIn] = var_type

connected = self.GetConnectedConnector(instance.connectionPointIn, body)

for related in self.ExtractRelatedConnections(connected):

self.ConnectionTypes[related] = var_type

elif isinstance(instance, (ContactClass, CoilClass)):

self.ConnectionTypes[instance.connectionPointIn] = "BOOL"

for link in instance.connectionPointIn.getconnections():

connected = self.GetLinkedConnector(link, body)

for related in self.ExtractRelatedConnections(connected):

self.ConnectionTypes[related] = "BOOL"

elif isinstance(instance, LeftPowerRailClass):

self.ConnectionTypes[connection] = "BOOL"

for link in connection.getconnections():

connected = self.GetLinkedConnector(link, body)

for related in self.ExtractRelatedConnections(connected):

self.ConnectionTypes[related] = "BOOL"

elif isinstance(instance, TransitionClass):

raise PLCGenException, _("SFC transition in POU \"%s\" must be connected.") % self.Name

for link in connections:

connected = self.GetLinkedConnector(link, body)

for related in self.ExtractRelatedConnections(connected):

self.ConnectionTypes[related] = "BOOL"

elif isinstance(instance, ContinuationClass):

undefined.append(connected)

related = []

for connection in undefined:

var_type = self.ConnectionTypes[connection]

else:

related.extend(self.ExtractRelatedConnections(connection))

for oname, otype, oqualifier in block_infos["outputs"]:

if output_name == oname:

if otype.startswith("ANY"):

undefined[otype] = []

undefined[otype].append(variable.connectionPointOut)

for connection in self.ExtractRelatedConnections(variable.connectionPointOut):

self.ConnectionTypes[connection] = otype

for variable in instance.inputVariables.getvariable():

if input_name == iname:

connected = self.GetConnectedConnector(variable.connectionPointIn, body)

if itype.startswith("ANY"):

undefined[itype] = []

undefined[itype].append(variable.connectionPointIn)

if connected is not None:

undefined[itype].append(connected)

else:

self.ConnectionTypes[variable.connectionPointIn] = itype

for connection in self.ExtractRelatedConnections(connected):

self.ConnectionTypes[connection] = itype

for var_type, connections in undefined.items():

[(input_name, None) for input_name in input_names])

for variable in input_variables:

parameter = variable.getformalParameter()

input_connected[parameter] = variable

if input_connected["EN"] is None:

input_connected.pop("EN")

if connections is not None:

if parameter != "EN":

one_input_connected = True

expression = self.ComputeExpression(body, connections, executionOrderId > 0, True)

if expression is not None:

inout_variables[parameter] = value

if one_input_connected:

for i, variable in enumerate(output_variables):

parameter = variable.getformalParameter()

if variable.getformalParameter() == "":

variable_name = "%s%d" % (type, block.getlocalId())

else:

input_info = (self.TagName, "block", block.getlocalId(), "input", input_idx)

connections = variable.connectionPointIn.getconnections()

if connections is not None:

if expression is not None:

vars.append([(parameter, input_info),

(" := ", ())] + self.ExtractModifier(variable, expression, input_info))

if output_variable is not None:

if block_infos["type"] == "function":

output_info = (self.TagName, "block", block.getlocalId(), "output", output_idx)

output_value = inout_variables[output_parameter]

else:

if output_parameter == "":

transition_infos["content"] = [("\n%s:= " % self.CurrentIndent, ())] + expression + [(";\n", ())]

self.SFCComputedBlocks += self.Program

self.Program = []

raise PLCGenException, _("Transition \"%s\" body must contain an output variable or coil referring to its name") % transitionValues["value"]

self.TagName = previous_tagname

elif transitionValues["type"] == "connection":

elif name is not None and name.find("::") != -1:

filepath, editor_name = name.split("::")

if os.path.isfile(filepath):

file_extension = os.path.splitext(filepath)[1]

if isinstance(self._FileEditors[filepath], DebugViewer):

self._FileEditors[filepath].SetDataProducer(self)

editor = self._FileEditors[filepath]

self.AppFrame.EditProjectElement(editor, editor.GetTagName())

to a WeakKeyDictionary linking

weakly referenced callables

"""

return None

self.IECdebug_lock.acquire()

self.ReArmDebugRegisterTimer()

def ForceDebugIECVariable(self, IECPath, fvalue):

return

self.IECdebug_lock.acquire()

self.ReArmDebugRegisterTimer()

def ReleaseDebugIECVariable(self, IECPath):

return

self.IECdebug_lock.acquire()

if blocktype["type"] == "function" and blockname not in self.Keywords and blockname not in self.Variables.keys():

interface = dict([(name, {}) for name, type, modifier in blocktype["inputs"] + blocktype["outputs"] if name != ''])

for param in ["EN", "ENO"]:

interface[param] = {}

self.Functions[blockname]["interface"].update(interface)

self.Functions[blockname]["extensible"] |= blocktype["extensible"]

else:

self.RefreshRect(self.GetScrolledRect(rect), False)

elif not self.Debug and keycode == wx.WXK_RETURN and self.SelectedElement is not None:

self.SelectedElement.OnLeftDClick(event, self.GetLogicalDC(), self.Scaling)

move = self.ARROW_KEY_MOVE[keycode]

if event.ControlDown() and event.ShiftDown():

self.Scroll({-1: 0, 0: xpos, 1: xmax}[move[0]],

for variable in instance.inputVariables.getvariable():

connections = variable.connectionPointIn.getconnections()

if connections and len(connections) == 1:

self.compileelementExecutionOrder(connections[0])

if instance.getexecutionOrderId() == 0:

instance.setexecutionOrderId(self.getnewExecutionOrderId())

if in_connections is not None:

for connection in in_connections:

connected = connection.getrefLocalId()

connectionPointIn.remove(connection)

mod_name = pyjs.strip_py(mod_name)

override_name = "%s.%s" % (platform.lower(), mod_name)

mod_cache_name = "%s.cache.js" % (override_name)

else:

mod_cache_name = "%s.cache.js" % (mod_name)

def has_nodeps(mod, deps):

return True

return False

return {'success': False, 'errors': builderrors(f)}

return {'success': True}

field_names = command['describe_errors']

return describe_fields_errors(f.fields, field_names)

field_names = command['describe']

return describe_fields(f.fields, field_names)

if not f.is_valid():

return {'success': False, 'errors': builderrors(f)}

instance = f.save() # XXX: if you want more, over-ride save.

return {'success': True, 'instance': json_convert(instance)}

return {'success': True, 'html': f.as_table()}

return "unrecognised command"

return self.items().__iter__()

def setdefault(self, key, default_value):

self[key] = default_value

def get(self, key, default_=None):

return default_

return self[key]

prefix = sys.prefix

prefix = os.environ['PYJSPREFIX']

# pyjs.path is the list of paths, just like sys.path, from which

path = [os.path.abspath('')]

for p in os.environ['PYJSPATH'].split(os.pathsep):

p = os.path.abspath(p)

if os.path.isdir(p):

call_name = self.modpfx() + v.node.name

elif v.node.name in self.top_level_classes:

call_name = self.modpfx() + v.node.name

call_name = self.imported_classes[v.node.name] + '.' + v.node.name

elif v.node.name in PYJSLIB_BUILTIN_FUNCTIONS:

call_name = 'pyjslib.' + v.node.name

return UU+self.modpfx() + v.name

elif v.name in local_var_names:

return v.name

return UU+self.imported_classes[v.name] + '.__' + v.name + ".prototype.__class__"

elif v.name in self.top_level_classes:

return UU+self.modpfx() + "__" + v.name + ".prototype.__class__"

if obj in self.method_imported_globals:

call_name = UU+self.modpfx() + obj + "." + attr_name

#attr_str = ""

#if attr_name != "__init__":

attr_str = ".prototype.__class__." + attr_name

base_class = "pyjslib.__Object"

elif len(node.bases) == 1:

if isinstance(node.bases[0], ast.Name):

base_class_ = self.imported_classes[node.bases[0].name] + '.__' + node.bases[0].name

base_class = self.imported_classes[node.bases[0].name] + '.' + node.bases[0].name

else:

def parseModule(self, module_name, file_name):

importing = False

importing = True

mod = compiler.parseFile(file_name)

self.parse_cache[file_name] = mod

self.inputs[attrname] = value

def getinput(self, attrname, default=None):

self.inputs[attrname] = default

return self.inputs[attrname]

for element in infos["elements"]:

if element["type"] == CHOICE:

element["elmt_type"] = GenerateContentInfos(factory, name, ComputeContentChoices(factory, name, element))

raise ValueError("'%s' element defined two times in choice" % choice_name)

else:

choices_dict[element["name"]] = infos

else:

raise ValueError("'%s' element defined two times in choice" % choice_name)

choices_dict[choice_name] = infos

prefix = ("%s:" % factory.TargetNamespace

infos = factory.GetQualifiedNameInfos(childname, namespace)

if infos["type"] != SYNTAXELEMENT:

raise ValueError("\"%s\" can't be a member child!" % name)

children.append(infos["extract"][element_name](factory, child))

else:

children.append(infos["extract"]["default"](factory, child))

def GetQualifiedNameInfos(self, name, namespace=None, canbenone=False):

if namespace is None:

return self.Namespaces[self.SchemaNamespace][name]

for space, elements in self.Namespaces.iteritems():

return elements[name]

parts = name.split("_", 1)

if len(parts) > 1:

group = self.GetQualifiedNameInfos(parts[0], namespace)

if group is not None and group["type"] == ELEMENTSGROUP:

elements = []

elements = group["elements"]

elements = group["choices"]

for element in elements:

if element["name"] == parts[1]:

return element

if not canbenone:

raise ValueError("Unknown element \"%s\" for any defined namespaces!" % name)

return self.Namespaces[namespace][name]

parts = name.split("_", 1)

if len(parts) > 1:

group = self.GetQualifiedNameInfos(parts[0], namespace)

if group is not None and group["type"] == ELEMENTSGROUP:

elements = []

elements = group["elements"]

elements = group["choices"]

for element in elements:

if element["name"] == parts[1]:

def SplitQualifiedName(self, name, namespace=None, canbenone=False):

if namespace is None:

return name, None

for space, elements in self.Namespaces.items():

return name, None

parts = name.split("_", 1)

if len(parts) > 1:

group = self.GetQualifiedNameInfos(parts[0], namespace)

if group is not None and group["type"] == ELEMENTSGROUP:

elements = []

elements = group["elements"]

elements = group["choices"]

for element in elements:

if element["name"] == parts[1]:

return part[1], part[0]

if not canbenone:

raise ValueError("Unknown element \"%s\" for any defined namespaces!" % name)

return name, None

parts = name.split("_", 1)

if len(parts) > 1:

group = self.GetQualifiedNameInfos(parts[0], namespace)

if group is not None and group["type"] == ELEMENTSGROUP:

elements = []

elements = group["elements"]

elements = group["choices"]

for element in elements:

if element["name"] == parts[1]:

raise ValueError("Invalid attribute \"%s\" for member \"%s\"!" % (qualified_name, node.nodeName))

for attr in valid_attrs:

if attr not in attrs and \

default = self.Namespaces[self.SchemaNamespace][attr]["default"][element_name]

else:

default = self.Namespaces[self.SchemaNamespace][attr]["default"]["default"]

result = []

for child_infos in elements:

if child_infos is not None:

self.CurrentCompilations.append(child_infos[1]["name"])

namespace, name = DecomposeQualifiedName(child_infos[0])

infos = self.GetQualifiedNameInfos(name, namespace)

element = infos["reduce"](self, child_infos[1], child_infos[2])

if element is not None:

result.append(element)

self.CurrentCompilations.pop(-1)

annotations = []

children = []

return annotations, children

def AddComplexType(self, typename, infos):

self.XMLClassDefinitions[typename] = infos

else:

raise ValueError("\"%s\" class already defined. Choose another name!" % typename)

self.Namespaces[self.TargetNamespace][result["name"]] = result

elif infos["type"] == ELEMENTSGROUP:

elements = []

elements = infos["elements"]

elements = infos["choices"]

for element in elements:

if not isinstance(element["elmt_type"], (UnicodeType, StringType)) and \

def GetStructurePattern(classinfos):

base_structure_pattern = (

classinfos["base"].StructurePattern.pattern[:-1]

elements = []

for element in classinfos["elements"]:

if element["type"] == ANY:

elements = dict([(element["name"], element) for element in classinfos["elements"]])

def getattrMethod(self, name):

attribute_infos = attributes[name]

attribute_infos["attr_type"] = FindTypeInfos(factory, attribute_infos["attr_type"])

value = self.get(name)

if value is not None:

return attribute_infos["attr_type"]["extract"](value, extract=False)

return attribute_infos["attr_type"]["extract"](attribute_infos["fixed"], extract=False)

return attribute_infos["attr_type"]["extract"](attribute_infos["default"], extract=False)

return None

element_infos = elements[name]

element_infos["elmt_type"] = FindTypeInfos(factory, element_infos["elmt_type"])

if element_infos["type"] == CHOICE:

return element_infos["elmt_type"]["extract"](value.text, extract=False)

return value

return classinfos["base"].__getattr__(self, name)

return DefaultElementClass.__getattribute__(self, name)

elements = OrderedDict([(element["name"], element) for element in classinfos["elements"]])

def setattrMethod(self, name, value):

attribute_infos = attributes[name]

attribute_infos["attr_type"] = FindTypeInfos(factory, attribute_infos["attr_type"])

if optional_attributes.get(name, False):

if value is None or value == default:

self.attrib.pop(name, None)

return

return

return self.set(name, attribute_infos["attr_type"]["generate"](value))

element_infos = elements[name]

element_infos["elmt_type"] = FindTypeInfos(factory, element_infos["elmt_type"])

if element_infos["type"] == ANY:

element = tmp_element

self.insert(insertion_point, element)

return classinfos["base"].__setattr__(self, name, value)

else:

def gettypeinfos(name, facets):

return facets["enumeration"][0]

limits = {"max": None, "min": None}

if facets["maxInclusive"][0] is not None:

limits["max"] = facets["maxInclusive"][0]

def generateGetElementAttributes(factory, classinfos):

def getElementAttributes(self):

attr_list = []

attr_list.extend(classinfos["base"].getElementAttributes(self))

for attr in classinfos["attributes"]:

if attr["use"] != "prohibited":

children = []

if path is not None:

parts = path.split(".", 1)

if len(parts) != 1:

raise ValueError("Wrong path!")

attr_type = gettypeinfos(attributes[parts[0]]["attr_type"]["basename"],

attributes[parts[0]]["attr_type"]["facets"])

value = getattr(self, parts[0], "")

if elements[parts[0]]["elmt_type"]["type"] == SIMPLETYPE:

if len(parts) != 1:

raise ValueError("Wrong path!")

return attr.getElementInfos(parts[0])

else:

return attr.getElementInfos(parts[0], parts[1])

if len(parts) > 0:

return self.content.getElementInfos(name, path)

classinfos["base"].getElementInfos(name, path)

else:

raise ValueError("Wrong path!")

else:

if not derived:

children.extend(self.getElementAttributes())

children.extend(classinfos["base"].getElementInfos(self, name, derived=True)["children"])

for element_name, element in elements.items():

if element["minOccurs"] == 0:

def setElementValue(self, path, value):

if path is not None:

parts = path.split(".", 1)

if len(parts) != 1:

raise ValueError("Wrong path!")

if attributes[parts[0]]["attr_type"]["basename"] == "boolean":

setattr(self, parts[0], value)

elif attributes[parts[0]]["use"] == "optional" and value == "":

setattr(self, parts[0],

attributes[parts[0]]["attr_type"]["extract"](

attributes[parts[0]]["default"], False))

setattr(self, parts[0], None)

else:

setattr(self, parts[0], attributes[parts[0]]["attr_type"]["extract"](value, False))

if elements[parts[0]]["elmt_type"]["type"] == SIMPLETYPE:

if len(parts) != 1:

raise ValueError("Wrong path!")

instance.setElementValue(parts[1], value)

else:

instance.setElementValue(None, value)

if len(parts) > 0:

self.content.setElementValue(path, value)

classinfos["base"].setElementValue(self, path, value)

if value == "":

if elements["content"]["minOccurs"] == 0:

self.setcontent([])

"""

def initMethod(self):

classinfos["base"]._init_(self)

for attribute in classinfos["attributes"]:

attribute["attr_type"] = FindTypeInfos(factory, attribute["attr_type"])

def addMethod(self):

if infos["type"] == ATTRIBUTE:

infos["attr_type"] = FindTypeInfos(factory, infos["attr_type"])

setattr(self, attr, infos["attr_type"]["initial"]())

elif infos["type"] == ELEMENT:

infos["elmt_type"] = FindTypeInfos(factory, infos["elmt_type"])

choices = dict([(choice["name"], choice) for choice in choice_types])

def setChoiceMethod(self, content_type):

raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type)

choices[content_type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"])

new_content = choices[content_type]["elmt_type"]["initial"]()

choices = dict([(choice["name"], choice) for choice in choice_types])

def appendChoiceMethod(self, content_type):

raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type)

choices[content_type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"])

if maxOccurs == "unbounded" or len(self.content) < maxOccurs:

choices = dict([(choice["name"], choice) for choice in choice_types])

def insertChoiceMethod(self, index, content_type):

raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type)

choices[type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"])

if maxOccurs == "unbounded" or len(self.content) < maxOccurs:

text = "(source: %(source)s):\n%(content)s\n\n" % child

else:

text = child["content"] + "\n\n"

annotation["documentation"] = text

else:

annotation["documentation"] += text

def GenerateFacetReducing(facetname, canbefixed):

def ReduceFacet(factory, attributes, elements):

annotations, children = factory.ReduceElements(elements)

facet = {"type": facetname, "value": attributes["value"], "doc": annotations}

if canbefixed:

facet["fixed"] = attributes.get("fixed", False)

# Initialize type informations

facets = {}

simpleType = {"type": SIMPLETYPE, "final": attributes.get("final", [])}

simpleType["name"] = attributes["name"]

if typeinfos["type"] in ["restriction", "extension"]:

simpleType["basename"] = basetypeinfos["basename"]

# Check that derivation is allowed

if "#all" in basetypeinfos["final"]:

raise ValueError("Base type can't be derivated!")

if "restriction" in basetypeinfos["final"] and typeinfos["type"] == "restriction":

# Extract simple type facets

for facet in typeinfos.get("facets", []):

facettype = facet["type"]

raise ValueError("\"%s\" facet can't be defined for \"%s\" type!" % (facettype, type))

elif basetypeinfos["facets"][facettype][1]:

raise ValueError("\"%s\" facet is fixed on base type!" % facettype)

continue

else:

raise ValueError("\"%s\" facet can't be defined with another facet type!" % facettype)

raise ValueError("\"enumeration\" facet can't be defined with another facet type!")

raise ValueError("\"pattern\" facet can't be defined with another facet type!")

raise ValueError("\"%s\" facet can't be defined two times!" % facettype)

elif facettype == "length":

raise ValueError("\"length\" and \"minLength\" facets can't be defined at the same time!")

raise ValueError("\"length\" and \"maxLength\" facets can't be defined at the same time!")

try:

value = int(value)

elif basevalue is not None and basevalue != value:

raise ValueError("\"length\" can't be different from \"length\" defined in base type!")

elif facettype == "minLength":

raise ValueError("\"length\" and \"minLength\" facets can't be defined at the same time!")

try:

value = int(value)

raise ValueError("\"minLength\" must be an integer!")

if value < 0:

raise ValueError("\"minLength\" can't be negative!")

raise ValueError("\"minLength\" must be lesser than or equal to \"maxLength\"!")

elif basevalue is not None and basevalue < value:

raise ValueError("\"minLength\" can't be lesser than \"minLength\" defined in base type!")

elif facettype == "maxLength":

raise ValueError("\"length\" and \"maxLength\" facets can't be defined at the same time!")

try:

value = int(value)

raise ValueError("\"maxLength\" must be an integer!")

if value < 0:

raise ValueError("\"maxLength\" can't be negative!")

raise ValueError("\"minLength\" must be lesser than or equal to \"maxLength\"!")

elif basevalue is not None and basevalue > value:

raise ValueError("\"maxLength\" can't be greater than \"maxLength\" defined in base type!")

elif facettype == "minInclusive":

raise ValueError("\"minExclusive\" and \"minInclusive\" facets can't be defined at the same time!")

value = basetypeinfos["extract"](facet["value"], False)

raise ValueError("\"minInclusive\" must be lesser than or equal to \"maxInclusive\"!")

raise ValueError("\"minInclusive\" must be lesser than \"maxExclusive\"!")

elif facettype == "minExclusive":

raise ValueError("\"minExclusive\" and \"minInclusive\" facets can't be defined at the same time!")

value = basetypeinfos["extract"](facet["value"], False)

raise ValueError("\"minExclusive\" must be lesser than \"maxInclusive\"!")

raise ValueError("\"minExclusive\" must be lesser than \"maxExclusive\"!")

elif facettype == "maxInclusive":

raise ValueError("\"maxExclusive\" and \"maxInclusive\" facets can't be defined at the same time!")

value = basetypeinfos["extract"](facet["value"], False)

raise ValueError("\"minInclusive\" must be lesser than or equal to \"maxInclusive\"!")

raise ValueError("\"minExclusive\" must be lesser than \"maxInclusive\"!")

elif facettype == "maxExclusive":

raise ValueError("\"maxExclusive\" and \"maxInclusive\" facets can't be defined at the same time!")

value = basetypeinfos["extract"](facet["value"], False)

raise ValueError("\"minInclusive\" must be lesser than \"maxExclusive\"!")

raise ValueError("\"minExclusive\" must be lesser than \"maxExclusive\"!")

elif facettype == "whiteSpace":

if basevalue == "collapse" and value in ["preserve", "replace"] or basevalue == "replace" and value == "preserve":

raise ValueError("\"whiteSpace\" is incompatible with \"whiteSpace\" defined in base type!")

elif facettype == "totalDigits":

raise ValueError("\"fractionDigits\" must be lesser than or equal to \"totalDigits\"!")

elif basevalue is not None and value > basevalue:

raise ValueError("\"totalDigits\" can't be greater than \"totalDigits\" defined in base type!")

elif facettype == "fractionDigits":

raise ValueError("\"fractionDigits\" must be lesser than or equal to \"totalDigits\"!")

elif basevalue is not None and value > basevalue:

raise ValueError("\"totalDigits\" can't be greater than \"totalDigits\" defined in base type!")

# Report not redefined facet from base type to new created type

for facettype, facetvalue in basetypeinfos["facets"].items():

facets[facettype] = facetvalue

# Generate extract value for new created type

simpleType["basename"] = "list"

# Check that derivation is allowed

raise ValueError("Item type can't be derivated!")

raise ValueError("Item type can't be derivated by list!")

# Generate extract value for new created type

raise ValueError("Member type given isn't a simpleType!")

# Check that derivation is allowed

raise ValueError("Item type can't be derivated!")

raise ValueError("Member type can't be derivated by union!")

membertypesinfos.append(infos)

def ReduceExtension(factory, attributes, elements):

annotations, children = factory.ReduceElements(elements)

raise ValueError("No base type has been defined for extension!")

extension = {"type": "extension", "attributes": [], "elements": [], "base": attributes["base"], "doc": annotations}

if len(children) > 0:

extension["elements"].append(content)

elif group["type"] == "group":

elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)

extension["elements"] = elmtgroup["elements"]

extension["order"] = elmtgroup["order"]

else:

elif basetypeinfos["type"] == COMPLEXTYPE and \

len(basetypeinfos["elements"]) == 1 and \

basetypeinfos["elements"][0]["name"] == "content" and \

basetypeinfos["elements"][0]["elmt_type"]["type"] == SIMPLETYPE:

contenttypeinfos = simpleContent.copy()

contenttypeinfos["base"] = basetypeinfos["elements"][0]["elmt_type"]

complexType["elements"].append(content)

elif group["type"] == "group":

elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)

complexType["elements"] = elmtgroup["elements"]

complexType["order"] = elmtgroup["order"]

else:

def ReduceAttribute(factory, attributes, elements):

annotations, children = factory.ReduceElements(elements)

raise ValueError("\"default\" and \"fixed\" can't be defined at the same time!")

elif attributes.get("use", "optional") != "optional":

raise ValueError("if \"default\" present, \"use\" can only have the value \"optional\"!")

else:

raise ValueError("Only one type can be defined for attribute!")

raise ValueError("\"ref\" and \"name\" can't be defined at the same time!")

raise ValueError("\"ref\" and \"form\" can't be defined at the same time!")

elif attribute["attr_type"] is not None:

raise ValueError("if \"ref\" is present, no type can be defined!")

elif attribute["attr_type"] is None:

raise ValueError("No type has been defined for attribute \"%s\"!" % attributes["name"])

tmp_attrs = attributes.copy()

tmp_attrs.pop("type")

attribute.update(tmp_attrs)

def ReduceAttributeGroup(factory, attributes, elements):

annotations, children = factory.ReduceElements(elements)

return {"type": "attributeGroup", "ref": attributes["ref"], "doc": annotations}

else:

return {"type": ATTRIBUTESGROUP, "attributes": ExtractAttributes(factory, children), "doc": annotations}

else:

types.append(child)

raise ValueError("\"default\" and \"fixed\" can't be defined at the same time!")

for attr in ["name", "default", "fixed", "form", "block", "type"]:

raise ValueError("\"ref\" and \"%s\" can't be defined at the same time!" % attr)

raise ValueError("\"ref\" and \"nillable\" can't be defined at the same time!")

if len(types) > 0:

raise ValueError("No type and no constraints can be defined where \"ref\" is defined!")

else:

raise ValueError("\"%s\" base type isn't defined or circular referenced!" % name)

element = {"type": ELEMENT, "elmt_type": attributes.get("type", None), "constraints": constraints, "doc": annotations}

if len(types) > 0:

if element["elmt_type"] is None:

element["elmt_type"] = "tag"

element["type"] = TAG

tmp_attrs = attributes.copy()

tmp_attrs.pop("type")

element.update(tmp_attrs)

choices.extend(child["choices"])

elif child["type"] == "group":

elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)

raise ValueError("Only group composed of \"choice\" can be referenced in \"choice\" element!")

choices_tmp = []

for choice in elmtgroup["choices"]:

sequence.extend(child["elements"])

elif child["type"] == "group":

elmtgroup = factory.FindSchemaElement(child["ref"], ELEMENTSGROUP)

raise ValueError("Only group composed of \"sequence\" can be referenced in \"sequence\" element!")

elements_tmp = []

for element in elmtgroup["elements"]:

def ReduceGroup(factory, attributes, elements):

annotations, children = factory.ReduceElements(elements)

return {"type": "group", "ref": attributes["ref"], "doc": annotations}

else:

element = children[0]

annotations, children = factory.ReduceElements(elements, True)

for child in children:

infos = factory.GetQualifiedNameInfos(child["name"], factory.TargetNamespace, True)

if infos is None:

factory.Namespaces[factory.TargetNamespace][child["name"]] = child