1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library is distributed in the hope that it will be useful,

    17

#but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

from xml.dom import minidom

    26

from types import *

    27

import re, datetime

    28

from xmlclass import *

    29

    30

def GenerateDictFacets(facets):

    31

    return dict([(name, (None, False)) for name in facets])

    32

    33

def GenerateSimpleTypeXMLText(function):

    34

    def generateXMLTextMethod(value, name = None, indent = 0):

    35

        text = ""

    36

        if name is not None:

    37

            ind1, ind2 = getIndent(indent, name)

    38

            text += ind1 + "<%s>"%name

    39

        text += function(value)

    40

        if name is not None:

    41

            text += "</%s>\n"%name

    42

        return text

    43

    return generateXMLTextMethod

    44

    45

def GenerateFloatXMLText(extra_values = []):

    46

    def generateXMLTextMethod(value, name = None, indent = 0):

    47

        text = ""

    48

        if name is not None:

    49

            ind1, ind2 = getIndent(indent, name)

    50

            text += ind1 + "<%s>"%name

    51

        if value in extra_values or value % 1 != 0 or isinstance(value, IntType):

    52

            text += str(value)

    53

        else:

    54

            text += "%.0f"%value

    55

        if name is not None:

    56

            text += "</%s>\n"%name

    57

        return text

    58

    return generateXMLTextMethod

    59

    60

DEFAULT_FACETS = GenerateDictFacets(["pattern", "whiteSpace", "enumeration"])

    61

NUMBER_FACETS = GenerateDictFacets(DEFAULT_FACETS.keys() + ["maxInclusive", "maxExclusive", "minInclusive", "minExclusive"])

    62

DECIMAL_FACETS = GenerateDictFacets(NUMBER_FACETS.keys() + ["totalDigits", "fractionDigits"])

    63

STRING_FACETS = GenerateDictFacets(DEFAULT_FACETS.keys() + ["length", "minLength", "maxLength"])

    64

    65

ALL_FACETS = ["pattern", "whiteSpace", "enumeration", "maxInclusive", 

    66

    "maxExclusive", "minInclusive", "minExclusive", "totalDigits", 

    67

    "fractionDigits", "length", "minLength", "maxLength"]

    68

    69

    70

#-------------------------------------------------------------------------------

    71

#                           Structure reducing functions

    72

#-------------------------------------------------------------------------------

    73

    74

    75

# Documentation elements

    76

    77

def ReduceAppInfo(factory, attributes, elements):

    78

    return {"type" : "appinfo", "source" : attributes.get("source", None), 

    79

        "content" : "\n".join(elements)}

    80

    81

    82

def ReduceDocumentation(factory, attributes, elements):

    83

    return {"type" : "documentation", "source" : attributes.get("source", None), 

    84

        "language" : attributes.get("lang", "any"), "content" : "\n".join(elements)}

    85

    86

    87

def ReduceAnnotation(factory, attributes, elements):

    88

    annotations, children = factory.ReduceElements(elements)

    89

    annotation = {"type" : "annotation", "appinfo" : [], "documentation" : {}}

    90

    for child in children:

    91

        if child["type"] == "appinfo":

    92

            annotation["appinfo"].append((child["source"], child["content"]))

    93

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

    94

            if child["source"] is not None:

    95

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

    96

            else:

    97

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

    98

            if child["language"] not in annotation["documentation"]:

    99

                annotation["documentation"] = text

   100

            else:

   101

                annotation["documentation"] += text

   102

    return annotation

   103

   104

# Simple type elements

   105

   106

def GenerateFacetReducing(facetname, canbefixed):

   107

    def ReduceFacet(factory, attributes, elements):

   108

        annotations, children = factory.ReduceElements(elements)

   109

        if "value" in attributes:

   110

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

   111

            if canbefixed:

   112

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

   113

            return facet

   114

        raise ValueError, "A value must be defined for the \"%s\" facet!"%facetname

   115

    return ReduceFacet

   116

   117

   118

def ReduceList(factory, attributes, elements):

   119

    annotations, children = factory.ReduceElements(elements)

   120

    list = {"type" : "list", "itemType" : attributes.get("itemType", None), "doc" : annotations}

   121

   122

    if len(children) > 0 and children[0]["type"] == SIMPLETYPE:

   123

        if list["itemType"] is None:

   124

            list["itemType"] = children[0]

   125

        else:

   126

            raise ValueError, "Only one base type can be defined for restriction!"

   127

    if list["itemType"] is None:

   128

        raise ValueError, "No base type has been defined for list!"

   129

    return list

   130

   131

   132

def ReduceUnion(factory, attributes, elements):

   133

    annotations, children = factory.ReduceElements(elements)

   134

    union = {"type" : "union", "memberTypes" : attributes.get("memberTypes", []), "doc" : annotations}

   135

   136

    if child in children:

   137

        if child["type"] == SIMPLETYPE:

   138

            union["memberTypes"] = child

   139

    if len(union["memberTypes"]) == 0:

   140

        raise ValueError, "No base type has been defined for union!"

   141

    return list

   142

   143

   144

def ReduceSimpleType(factory, attributes, elements):

   145

    # Reduce all the simple type children

   146

    annotations, children = factory.ReduceElements(elements)

   147

   148

    typeinfos = children[0]

   149

   150

    # Initialize type informations

   151

    facets = {}

   152

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

   153

    if "name" in attributes:

   154

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

   155

   156

    if typeinfos["type"] == "restriction":

   157

        # Search for base type definition

   158

        if isinstance(typeinfos["base"], (StringType, UnicodeType)):

   159

            basetypeinfos = factory.FindSchemaElement(typeinfos["base"], SIMPLETYPE)

   160

            if basetypeinfos is None:

   161

                raise "\"%s\" isn't defined!"%typeinfos["base"] 

   162

        else:

   163

            basetypeinfos = typeinfos["base"]

   164

   165

        # Check that base type is a simple type

   166

        if basetypeinfos["type"] != SIMPLETYPE:

   167

            raise ValueError, "Base type given isn't a simpleType!"

   168

   169

        typeinfos["basename"] = basetypeinfos["basename"]

   170

   171

        # Check that derivation is allowed

   172

        if "final" in basetypeinfos:

   173

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

   174

                raise ValueError, "Base type can't be derivated!"

   175

            if "restriction" in basetypeinfos["final"]:

   176

                raise ValueError, "Base type can't be derivated by restriction!"

   177

   178

        # Extract simple type facets

   179

        for facet in typeinfos["facets"]:

   180

            facettype = facet["type"]

   181

            if facettype not in basetypeinfos["facets"]:

   182

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

   183

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

   184

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

   185

            value = facet["value"]

   186

            basevalue = basetypeinfos["facets"][facettype][0]

   187

            if facettype == "enumeration":

   188

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

   189

                if len(facets) == 0:

   190

                    facets["enumeration"] = ([value], False)

   191

                    continue

   192

                elif facets.keys() == ["enumeration"]:

   193

                    facets["enumeration"][0].append(value)

   194

                    continue

   195

                else:

   196

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

   197

            elif "enumeration" in facets:

   198

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

   199

            elif facettype in facets:

   200

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

   201

            elif facettype == "length":

   202

                if "minLength" in facets:

   203

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

   204

                if "maxLength" in facets:

   205

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

   206

                try:

   207

                    value = int(value)

   208

                except:

   209

                    raise ValueError, "\"length\" must be an integer!"

   210

                if value < 0:

   211

                    raise ValueError, "\"length\" can't be negative!"

   212

                elif basevalue is not None and basevalue != value:

   213

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

   214

            elif facettype == "minLength":

   215

                if "length" in facets:

   216

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

   217

                try:

   218

                    value = int(value)

   219

                except:

   220

                    raise ValueError, "\"minLength\" must be an integer!"

   221

                if value < 0:

   222

                    raise ValueError, "\"minLength\" can't be negative!"

   223

                elif "maxLength" in facets and value > facets["maxLength"]:

   224

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

   225

                elif basevalue is not None and basevalue < value:

   226

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

   227

            elif facettype == "maxLength":

   228

                if "length" in facets:

   229

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

   230

                try:

   231

                    value = int(value)

   232

                except:

   233

                    raise ValueError, "\"maxLength\" must be an integer!"

   234

                if value < 0:

   235

                    raise ValueError, "\"maxLength\" can't be negative!"

   236

                elif "minLength" in facets and value < facets["minLength"]:

   237

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

   238

                elif basevalue is not None and basevalue > value:

   239

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

   240

            elif facettype == "minInclusive":

   241

                if "minExclusive" in facets:

   242

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

   243

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

   244

                if "maxInclusive" in facets and value > facets["maxInclusive"][0]:

   245

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

   246

                elif "maxExclusive" in facets and value >= facets["maxExclusive"][0]:

   247

                    raise ValueError, "\"minInclusive\" must be lesser than \"maxExclusive\"!"

   248

            elif facettype == "minExclusive":

   249

                if "minInclusive" in facets:

   250

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

   251

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

   252

                if "maxInclusive" in facets and value >= facets["maxInclusive"][0]:

   253

                    raise ValueError, "\"minExclusive\" must be lesser than \"maxInclusive\"!"

   254

                elif "maxExclusive" in facets and value >= facets["maxExclusive"][0]:

   255

                    raise ValueError, "\"minExclusive\" must be lesser than \"maxExclusive\"!"

   256

            elif facettype == "maxInclusive":

   257

                if "maxExclusive" in facets:

   258

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

   259

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

   260

                if "minInclusive" in facets and value < facets["minInclusive"][0]:

   261

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

   262

                elif "minExclusive" in facets and value <= facets["minExclusive"][0]:

   263

                    raise ValueError, "\"minExclusive\" must be lesser than \"maxInclusive\"!"

   264

            elif facettype == "maxExclusive":

   265

                if "maxInclusive" in facets:

   266

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

   267

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

   268

                if "minInclusive" in facets and value <= facets["minInclusive"][0]:

   269

                    raise ValueError, "\"minInclusive\" must be lesser than \"maxExclusive\"!"

   270

                elif "minExclusive" in facets and value <= facets["minExclusive"][0]:

   271

                    raise ValueError, "\"minExclusive\" must be lesser than \"maxExclusive\"!"

   272

            elif facettype == "whiteSpace":

   273

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

   274

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

   275

            elif facettype == "totalDigits":

   276

                if "fractionDigits" in facets and value <= facets["fractionDigits"][0]:

   277

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

   278

                elif basevalue is not None and value > basevalue:

   279

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

   280

            elif facettype == "fractionDigits":

   281

                if "totalDigits" in facets and value <= facets["totalDigits"][0]:

   282

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

   283

                elif basevalue is not None and value > basevalue:

   284

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

   285

            facets[facettype] = (value, facet.get("fixed", False))

   286

   287

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

   288

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

   289

            if facettype not in facets:

   290

                facets[facettype] = facetvalue

   291

   292

        # Generate extract value for new created type

   293

        def ExtractSimpleTypeValue(attr, extract = True):

   294

            value = basetypeinfos["extract"](attr, extract)

   295

            for facetname, (facetvalue, facetfixed) in facets.items():

   296

                if facetvalue is not None:

   297

                    if facetname == "enumeration" and value not in facetvalue:

   298

                        raise ValueError, "\"%s\" not in enumerated values"%value

   299

                    elif facetname == "length" and len(value) != facetvalue:

   300

                        raise ValueError, "value must have a length of %d"%facetvalue

   301

                    elif facetname == "minLength" and len(value) < facetvalue:

   302

                        raise ValueError, "value must have a length of %d at least"%facetvalue

   303

                    elif facetname == "maxLength" and len(value) > facetvalue:

   304

                        raise ValueError, "value must have a length of %d at most"%facetvalue

   305

                    elif facetname == "minInclusive" and value < facetvalue:

   306

                        raise ValueError, "value must be greater than or equal to %s"%str(facetvalue)

   307

                    elif facetname == "minExclusive" and value <= facetvalue:

   308

                        raise ValueError, "value must be greater than %s"%str(facetvalue)

   309

                    elif facetname == "maxInclusive" and value > facetvalue:

   310

                        raise ValueError, "value must be lesser than or equal to %s"%str(facetvalue)

   311

                    elif facetname == "maxExclusive"  and value >= facetvalue:

   312

                        raise ValueError, "value must be lesser than %s"%str(facetvalue)

   313

                    elif facetname == "pattern":

   314

                        model = re.compile("(?:%s)?$"%facetvalue)

   315

                        result = model.match(value)

   316

                        if result is None:

   317

                            raise ValueError, "value doesn't follow the pattern %s"%facetvalue

   318

                    elif facetname == "whiteSpace":

   319

                        if facetvalue == "replace":

   320

                            value = GetNormalizedString(value, False)

   321

                        elif facetvalue == "collapse":

   322

                            value = GetToken(value, False)

   323

            return value

   324

   325

        def CheckSimpleTypeValue(value):

   326

            for facetname, (facetvalue, facetfixed) in facets.items():

   327

                if facetvalue is not None:

   328

                    if facetname == "enumeration" and value not in facetvalue:

   329

                        return False

   330

                    elif facetname == "length" and len(value) != facetvalue:

   331

                        return False

   332

                    elif facetname == "minLength" and len(value) < facetvalue:

   333

                        return False

   334

                    elif facetname == "maxLength" and len(value) > facetvalue:

   335

                        return False

   336

                    elif facetname == "minInclusive" and value < facetvalue:

   337

                        return False

   338

                    elif facetname == "minExclusive" and value <= facetvalue:

   339

                        return False

   340

                    elif facetname == "maxInclusive" and value > facetvalue:

   341

                        return False

   342

                    elif facetname == "maxExclusive"  and value >= facetvalue:

   343

                        return False

   344

                    elif facetname == "pattern":

   345

                        model = re.compile("(?:%s)?$"%facetvalue)

   346

                        result = model.match(value)

   347

                        if result is None:

   348

                            raise ValueError, "value doesn't follow the pattern %s"%facetvalue

   349

            return True

   350

   351

        def SimpleTypeInitialValue():

   352

            for facetname, (facetvalue, facetfixed) in facets.items():

   353

                if facetvalue is not None:

   354

                    if facetname == "enumeration":

   355

                        return facetvalue[0]

   356

                    elif facetname == "length":

   357

                        return " "*facetvalue

   358

                    elif facetname == "minLength":

   359

                        return " "*minLength

   360

                    elif facetname == "minInclusive" and facetvalue > 0:

   361

                        return facetvalue

   362

                    elif facetname == "minExclusive" and facetvalue >= 0:

   363

                        return facetvalue + 1

   364

                    elif facetname == "maxInclusive" and facetvalue < 0:

   365

                        return facetvalue

   366

                    elif facetname == "maxExclusive"  and facetvalue <= 0:

   367

                        return facetvalue - 1

   368

            return basetypeinfos["initial"]()

   369

   370

        GenerateSimpleType = basetypeinfos["generate"]

   371

   372

    elif typeinfos["type"] == "list":

   373

        # Search for item type definition

   374

        if isinstance(typeinfos["itemType"], (StringType, UnicodeType)):

   375

            itemtypeinfos = factory.FindSchemaElement(typeinfos["itemType"], SIMPLETYPE)

   376

            if itemtypeinfos is None:

   377

                raise "\"%s\" isn't defined!"%typeinfos["itemType"]

   378

        else:

   379

            itemtypeinfos = typeinfos["itemType"]

   380

   381

        # Check that item type is a simple type

   382

        if itemtypeinfos["type"] != SIMPLETYPE:

   383

            raise ValueError, "Item type given isn't a simpleType!"

   384

   385

        # Check that derivation is allowed

   386

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

   387

            raise ValueError, "Item type can't be derivated!"

   388

        if "list" in itemtypeinfos["final"]:

   389

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

   390

   391

        # Generate extract value for new created type

   392

        def ExtractSimpleTypeValue(attr, extract = True):

   393

            values = []

   394

            for value in GetToken(attr, extract).split(" "):

   395

                values.append(itemtypeinfos["extract"](value, False))

   396

            return values

   397

   398

        def CheckSimpleTypeValue(value):

   399

            for value in GetToken(attr, extract).split(" "):

   400

                result = itemtypeinfos["check"](value)

   401

                if not result:

   402

                    return result

   403

            return True

   404

   405

        SimpleTypeInitialValue = lambda: ""

   406

   407

        GenerateSimpleType = GenerateSimpleTypeXMLText(lambda x : " ".join(map(itemtypeinfos, values)))

   408

   409

        facets = GenerateDictFacets(["length", "maxLength", "minLength", "enumeration", "pattern"])

   410

        facet["whiteSpace"] = ("collapse", False)

   411

   412

    elif typeinfos["type"] == "union":

   413

        # Search for member types definition

   414

        membertypesinfos = []

   415

        for membertype in typeinfos["memberTypes"]:

   416

            if isinstance(membertype, (StringType, UnicodeType)):

   417

                infos = factory.FindSchemaElement(typeinfos["memberTypes"], SIMPLETYPE)

   418

                if infos is None:

   419

                    raise "\"%s\" isn't defined!"%typeinfos["itemType"]

   420

            else:

   421

                infos = membertype

   422

   423

            # Check that member type is a simple type

   424

            if infos["type"] != SIMPLETYPE:

   425

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

   426

   427

            # Check that derivation is allowed

   428

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

   429

                raise ValueError, "Item type can't be derivated!"

   430

            if "union" in infos["final"]:

   431

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

   432

   433

            membertypesinfos.append(infos)

   434

   435

        # Generate extract value for new created type

   436

        def ExtractSimpleTypeValue(attr, extract = True):

   437

            if extract:

   438

                value = GetAttributeValue(attr)

   439

            else:

   440

                value = attr

   441

            for infos in membertypesinfos:

   442

                try:

   443

                    return infos["extract"](attr, False)

   444

                except:

   445

                    pass

   446

            raise ValueError, "\"%s\" isn't valid for type defined for union!"

   447

   448

        def CheckSimpleTypeValue(value):

   449

            for infos in membertypesinfos:

   450

                result = infos["check"](value)

   451

                if result:

   452

                    return result

   453

            return False

   454

   455

        SimpleTypeInitialValue = membertypesinfos[0]["initial"]

   456

   457

        def GenerateSimpleTypeFunction(value):

   458

            if isinstance(value, BooleanType):

   459

                return {True : "true", False : "false"}[value]

   460

            else:

   461

                return str(value)

   462

        GenerateSimpleType = GenerateSimpleTypeXMLText(GenerateSimpleTypeFunction)

   463

   464

        facets = GenerateDictFacets(["pattern", "enumeration"])

   465

   466

    simpleType["facets"] = facets

   467

    simpleType["extract"] = ExtractSimpleTypeValue

   468

    simpleType["initial"] = SimpleTypeInitialValue

   469

    simpleType["check"] = CheckSimpleTypeValue

   470

    simpleType["generate"] = GenerateSimpleType

   471

    return simpleType

   472

   473

   474

# Complex type

   475

   476

def ExtractAttributes(factory, elements, base = None):

   477

    if base is not None:

   478

        basetypeinfos = factory.FindSchemaElement(base, COMPLEXTYPE)

   479

        if isinstance(basetypeinfos, (UnicodeType, StringType)):

   480

            attrnames = {}

   481

        else:

   482

            attrnames = dict(map(lambda x:(x["name"], True), basetypeinfos["attributes"]))

   483

    else:

   484

        attrnames = {}

   485

    attrs = []

   486

    for element in elements:

   487

        if element["type"] == ATTRIBUTE:

   488

            if attrnames.get(element["name"], False):

   489

                raise ValueError, "\"%s\" attribute has been defined two times!"%element["name"]

   490

            else:

   491

                attrnames[element["name"]] = True

   492

                attrs.append(element)

   493

        elif element["type"] == "attributeGroup":

   494

            attrgroup = factory.FindSchemaElement(element["ref"], ATTRIBUTESGROUP)

   495

            for attr in attrgroup["attributes"]:

   496

                if attrnames.get(attr["name"], False):

   497

                    raise ValueError, "\"%s\" attribute has been defined two times!"%attr["name"]

   498

                else:

   499

                    attrnames[attr["name"]] = True

   500

                    attrs.append(attr)

   501

        elif element["type"] == "anyAttribute":

   502

            raise ValueError, "\"anyAttribute\" element isn't supported yet!"

   503

    return attrs

   504

   505

   506

def ReduceRestriction(factory, attributes, elements):

   507

    annotations, children = factory.ReduceElements(elements)

   508

    restriction = {"type" : "restriction", "base" : attributes.get("base", None), "facets" : [], "doc" : annotations}

   509

    if len(children) > 0 and children[0]["type"] == SIMPLETYPE:

   510

        if restriction["base"] is None:

   511

            restriction["base"] = children.pop(0)

   512

        else:

   513

            raise ValueError, "Only one base type can be defined for restriction!"

   514

    if restriction["base"] is None:

   515

        raise ValueError, "No base type has been defined for restriction!"

   516

   517

    while len(children) > 0 and children[0]["type"] in ALL_FACETS:

   518

        restriction["facets"].append(children.pop(0))

   519

    restriction["attributes"] = ExtractAttributes(factory, children)

   520

    return restriction

   521

   522

   523

def ReduceExtension(factory, attributes, elements):

   524

    annotations, children = factory.ReduceElements(elements)

   525

    extension = {"type" : "extension", "attributes" : [], "elements" : [], "base" : attributes.get("base", None), "doc" : annotations}

   526

    if len(children) > 0:

   527

        if children[0]["type"] in ["group", "all", CHOICE, "sequence"]:

   528

            group = children.pop(0)

   529

            if group["type"] in ["all", "sequence"]:

   530

                extension["elements"] = group["elements"]