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

import os, re

    26

import datetime

    27

from xml.dom import minidom

    28

from types import *

    29

    30

from xmlclass import *

    31

    32

def GenerateDictFacets(facets):

    33

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

    34

    35

def GenerateSimpleTypeXMLText(function):

    36

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

    37

        text = ""

    38

        if name is not None:

    39

            ind1, ind2 = getIndent(indent, name)

    40

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

    41

        text += function(value)

    42

        if name is not None:

    43

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

    44

        return text

    45

    return generateXMLTextMethod

    46

    47

def GenerateFloatXMLText(extra_values=[]):

    48

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

    49

        text = ""

    50

        if name is not None:

    51

            ind1, ind2 = getIndent(indent, name)

    52

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

    53

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

    54

            text += str(value)

    55

        else:

    56

            text += "%.0f" % value

    57

        if name is not None:

    58

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

    59

        return text

    60

    return generateXMLTextMethod

    61

    62

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

    63

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

    64

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

    65

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

    66

    67

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

    68

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

    69

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

    70

    71

    72

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

    73

#                           Structure reducing functions

    74

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

    75

    76

    77

# Documentation elements

    78

    79

def ReduceAppInfo(factory, attributes, elements):

    80

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

    81

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

    82

    83

    84

def ReduceDocumentation(factory, attributes, elements):

    85

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

    86

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

    87

    88

    89

def ReduceAnnotation(factory, attributes, elements):

    90

    annotations, children = factory.ReduceElements(elements)

    91

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

    92

    for child in children:

    93

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

    94

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

    95

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

    96

            if child["source"] is not None:

    97

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

    98

            else:

    99

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

   100

            if not annotation["documentation"].has_key(child["language"]):

   101

                annotation["documentation"] = text

   102

            else:

   103

                annotation["documentation"] += text

   104

    return annotation

   105

   106

# Simple type elements

   107

   108

def GenerateFacetReducing(facetname, canbefixed):

   109

    def ReduceFacet(factory, attributes, elements):

   110

        annotations, children = factory.ReduceElements(elements)

   111

        if attributes.has_key("value"):

   112

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

   113

            if canbefixed:

   114

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

   115

            return facet

   116

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

   117

    return ReduceFacet

   118

   119

   120

def ReduceList(factory, attributes, elements):

   121

    annotations, children = factory.ReduceElements(elements)

   122

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

   123

   124

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

   125

        if list["itemType"] is None:

   126

            list["itemType"] = children[0]

   127

        else:

   128

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

   129

    if list["itemType"] is None:

   130

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

   131

    return list

   132

   133

   134

def ReduceUnion(factory, attributes, elements):

   135

    annotations, children = factory.ReduceElements(elements)

   136

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

   137

   138

    for child in children:

   139

        if child["type"] == SIMPLETYPE:

   140

            union["memberTypes"].appendchild

   141

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

   142

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

   143

    return union

   144

   145

   146

def CreateSimpleType(factory, attributes, typeinfos):

   147

    # Initialize type informations

   148

    facets = {}

   149

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

   150

    if attributes.has_key("name"):

   151

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

   152

   153

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

   154

        # Search for base type definition

   155

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

   156

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

   157

            if basetypeinfos is None:

   158

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

   159

        else:

   160

            basetypeinfos = typeinfos["base"]

   161

   162

        # Check that base type is a simple type

   163

        if basetypeinfos["type"] != SIMPLETYPE:

   164

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

   165

   166

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

   167

   168

        # Check that derivation is allowed

   169

        if basetypeinfos.has_key("final"):

   170

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

   171

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

   172

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

   173

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

   174

   175

        # Extract simple type facets

   176

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

   177

            facettype = facet["type"]

   178

            if not basetypeinfos["facets"].has_key(facettype):

   179

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

   180

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

   181

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

   182

            value = facet["value"]

   183

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

   184

            if facettype in ["enumeration", "pattern"]:

   185

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

   186

                if len(facets) == 0:

   187

                    facets[facettype] = ([value], False)

   188

                    continue

   189

                elif facets.keys() == [facettype]:

   190

                    facets[facettype][0].append(value)

   191

                    continue

   192

                else:

   193

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

   194

            elif facets.has_key("enumeration"):

   195

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

   196

            elif facets.has_key("pattern"):

   197

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

   198

            elif facets.has_key(facettype):

   199

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

   200

            elif facettype == "length":

   201

                if facets.has_key("minLength"):

   202

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

   203

                if facets.has_key("maxLength"):

   204

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

   205

                try:

   206

                    value = int(value)

   207

                except:

   208

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

   209

                if value < 0:

   210

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

   211

                elif basevalue is not None and basevalue != value:

   212

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

   213

            elif facettype == "minLength":

   214

                if facets.has_key("length"):

   215

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

   216

                try:

   217

                    value = int(value)

   218

                except:

   219

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

   220

                if value < 0:

   221

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

   222

                elif facets.has_key("maxLength") and value > facets["maxLength"]:

   223

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

   224

                elif basevalue is not None and basevalue < value:

   225

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

   226

            elif facettype == "maxLength":

   227

                if facets.has_key("length"):

   228

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

   229

                try:

   230

                    value = int(value)

   231

                except:

   232

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

   233

                if value < 0:

   234

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

   235

                elif facets.has_key("minLength") and value < facets["minLength"]:

   236

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

   237

                elif basevalue is not None and basevalue > value:

   238

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

   239

            elif facettype == "minInclusive":

   240

                if facets.has_key("minExclusive"):

   241

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

   242

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

   243

                if facets.has_key("maxInclusive") and value > facets["maxInclusive"][0]:

   244

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

   245

                elif facets.has_key("maxExclusive") and value >= facets["maxExclusive"][0]:

   246

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

   247

            elif facettype == "minExclusive":

   248

                if facets.has_key("minInclusive"):

   249

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

   250

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

   251

                if facets.has_key("maxInclusive") and value >= facets["maxInclusive"][0]:

   252

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

   253

                elif facets.has_key("maxExclusive") and value >= facets["maxExclusive"][0]:

   254

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

   255

            elif facettype == "maxInclusive":

   256

                if facets.has_key("maxExclusive"):

   257

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

   258

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

   259

                if facets.has_key("minInclusive") and value < facets["minInclusive"][0]:

   260

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

   261

                elif facets.has_key("minExclusive") and value <= facets["minExclusive"][0]:

   262

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

   263

            elif facettype == "maxExclusive":

   264

                if facets.has_key("maxInclusive"):

   265

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

   266

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

   267

                if facets.has_key("minInclusive") and value <= facets["minInclusive"][0]:

   268

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

   269

                elif facets.has_key("minExclusive") and value <= facets["minExclusive"][0]:

   270

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

   271

            elif facettype == "whiteSpace":

   272

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

   273

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

   274

            elif facettype == "totalDigits":

   275

                if facets.has_key("fractionDigits") and value <= facets["fractionDigits"][0]:

   276

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

   277

                elif basevalue is not None and value > basevalue:

   278

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

   279

            elif facettype == "fractionDigits":

   280

                if facets.has_key("totalDigits") and value <= facets["totalDigits"][0]:

   281

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

   282

                elif basevalue is not None and value > basevalue:

   283

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

   284

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

   285

   286

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

   287

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

   288

            if not facets.has_key(facettype):

   289

                facets[facettype] = facetvalue

   290

   291

        # Generate extract value for new created type

   292

        def ExtractSimpleTypeValue(attr, extract=True):

   293

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

   294

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

   295

                if facetvalue is not None:

   296

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

   297

                        raise ValueError("\"%s\" not in enumerated values" % value)

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

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

   306

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

   307

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

   308

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

   309

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

   310

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

   311

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

   312

                    elif facetname == "pattern":

   313

                        model = re.compile("(?:%s)?$" % "|".join(map(lambda x: "(?:%s)" % x, facetvalue)))

   314

                        result = model.match(value)

   315

                        if result is None:

   316

                            if len(facetvalue) > 1:   

   317

                                raise ValueError("value doesn't follow any of the patterns %s" % ",".join(facetvalue))

   318

                            else:

   319

                                raise ValueError("value doesn't follow the pattern %s" % facetvalue[0])

   320

                    elif facetname == "whiteSpace":

   321

                        if facetvalue == "replace":

   322

                            value = GetNormalizedString(value, False)

   323

                        elif facetvalue == "collapse":

   324

                            value = GetToken(value, False)

   325

            return value

   326

   327

        def CheckSimpleTypeValue(value):

   328

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

   329

                if facetvalue is not None:

   330

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

   331

                        return False

   332

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

   333

                        return False

   334

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

   335

                        return False

   336

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

   337

                        return False

   338

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

   339

                        return False

   340

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

   341

                        return False

   342

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

   343

                        return False

   344

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

   345

                        return False

   346

                    elif facetname == "pattern":

   347

                        model = re.compile("(?:%s)?$" % "|".join(map(lambda x: "(?:%s)" % x, facetvalue)))

   348

                        result = model.match(value)

   349

                        if result is None:

   350

                            if len(facetvalue) > 1:   

   351

                                raise ValueError("value doesn't follow any of the patterns %s" % ",".join(facetvalue))

   352

                            else:

   353

                                raise ValueError("value doesn't follow the pattern %s" % facetvalue[0])

   354

            return True

   355

   356

        def SimpleTypeInitialValue():

   357

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

   358

                if facetvalue is not None:

   359

                    if facetname == "enumeration":

   360

                        return facetvalue[0]

   361

                    elif facetname == "length":

   362

                        return " "*facetvalue

   363

                    elif facetname == "minLength":

   364

                        return " "*minLength

   365

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

   366

                        return facetvalue

   367

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

   368

                        return facetvalue + 1

   369

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

   370

                        return facetvalue

   371

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

   372

                        return facetvalue - 1

   373

            return basetypeinfos["initial"]()

   374

   375

        GenerateSimpleType = basetypeinfos["generate"]

   376

   377

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

   378

        # Search for item type definition

   379

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

   380

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

   381

            if itemtypeinfos is None:

   382

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

   383

        else:

   384

            itemtypeinfos = typeinfos["itemType"]

   385

   386

        # Check that item type is a simple type

   387

        if itemtypeinfos["type"] != SIMPLETYPE:

   388

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

   389

   390

        simpleType["basename"] = "list"

   391

   392

        # Check that derivation is allowed

   393

        if itemtypeinfos.has_key("final"):

   394

            if itemtypeinfos["final"].has_key("#all"):

   395

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

   396

            if itemtypeinfos["final"].has_key("list"):

   397

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

   398

   399

        # Generate extract value for new created type

   400

        def ExtractSimpleTypeValue(attr, extract = True):

   401

            values = []

   402

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

   403

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

   404

            return values

   405

   406

        def CheckSimpleTypeValue(value):

   407

            for item in value:

   408

                result = itemtypeinfos["check"](item)

   409

                if not result:

   410

                    return result

   411

            return True

   412

   413

        SimpleTypeInitialValue = lambda: []

   414

   415

        GenerateSimpleType = GenerateSimpleTypeXMLText(lambda x: " ".join(map(itemtypeinfos["generate"], x)))

   416

   417

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

   418

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

   419

   420

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

   421

        # Search for member types definition

   422

        membertypesinfos = []

   423

        for membertype in typeinfos["memberTypes"]:

   424

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

   425

                infos = factory.FindSchemaElement(membertype, SIMPLETYPE)

   426

                if infos is None:

   427

                    raise ValueError("\"%s\" isn't defined!" % membertype)

   428

            else:

   429

                infos = membertype

   430

   431

            # Check that member type is a simple type

   432

            if infos["type"] != SIMPLETYPE:

   433

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

   434

   435

            # Check that derivation is allowed

   436

            if infos.has_key("final"):

   437

                if infos["final"].has_key("#all"):

   438

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

   439

                if infos["final"].has_key("union"):

   440

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

   441

   442

            membertypesinfos.append(infos)

   443

   444

        simpleType["basename"] = "union"

   445

   446

        # Generate extract value for new created type

   447

        def ExtractSimpleTypeValue(attr, extract = True):

   448

            if extract:

   449

                value = GetAttributeValue(attr)

   450

            else:

   451

                value = attr

   452

            for infos in membertypesinfos:

   453

                try:

   454

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

   455

                except:

   456

                    pass

   457

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

   458

   459

        def CheckSimpleTypeValue(value):

   460

            for infos in membertypesinfos:

   461

                result = infos["check"](value)

   462

                if result:

   463

                    return result

   464

            return False

   465

   466

        SimpleTypeInitialValue = membertypesinfos[0]["initial"]

   467

   468

        def GenerateSimpleTypeFunction(value):

   469

            if isinstance(value, BooleanType):

   470

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

   471

            else:

   472

                return str(value)

   473

        GenerateSimpleType = GenerateSimpleTypeXMLText(GenerateSimpleTypeFunction)

   474

   475

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

   476

   477

    simpleType["facets"] = facets

   478

    simpleType["extract"] = ExtractSimpleTypeValue

   479

    simpleType["initial"] = SimpleTypeInitialValue

   480

    simpleType["check"] = CheckSimpleTypeValue

   481

    simpleType["generate"] = GenerateSimpleType

   482

    return simpleType

   483

   484

def ReduceSimpleType(factory, attributes, elements):

   485

    # Reduce all the simple type children

   486

    annotations, children = factory.ReduceElements(elements)

   487

   488

    simpleType = CreateSimpleType(factory, attributes, children[0])

   489

    simpleType["doc"] = annotations

   490

   491

    return simpleType

   492

   493

# Complex type

   494

   495

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

   496

    attrs = []

   497

    attrnames = {}

   498

    if base is not None:

   499

        basetypeinfos = factory.FindSchemaElement(base)

   500

        if not isinstance(basetypeinfos, (UnicodeType, StringType)) and basetypeinfos["type"] == COMPLEXTYPE:

   501

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

   502

   503

    for element in elements:

   504

        if element["type"] == ATTRIBUTE:

   505

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

   506

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

   507

            else:

   508

                attrnames[element["name"]] = True

   509

                attrs.append(element)

   510

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

   511

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

   512

            for attr in attrgroup["attributes"]:

   513

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

   514

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

   515

                else:

   516

                    attrnames[attr["name"]] = True

   517

                    attrs.append(attr)

   518

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

   519

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

   520

    return attrs

   521

   522

   523

def ReduceRestriction(factory, attributes, elements):

   524

    annotations, children = factory.ReduceElements(elements)