1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

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

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

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

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

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

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

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

    22

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

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import os

    26

import re

    27

import datetime

    28

from xml.dom import minidom

    29

from types import *

    30

    31

from xmlclass import *

    32

    34

def GenerateDictFacets(facets):

    35

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

    36

    38

def GenerateSimpleTypeXMLText(function):

    39

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

    40

        text = ""

    41

        if name is not None:

    42

            ind1, ind2 = getIndent(indent, name)

    43

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

    44

        text += function(value)

    45

        if name is not None:

    46

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

    47

        return text

    48

    return generateXMLTextMethod

    49

    51

def GenerateFloatXMLText(extra_values=[], decimal=None):

    52

    float_format = (lambda x: "{:.{width}f}".format(x, width=decimal).rstrip('0')

    53

                    if decimal is not None else str)

    54

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

    55

        text = ""

    56

        if name is not None:

    57

            ind1, ind2 = getIndent(indent, name)

    58

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

    59

        if isinstance(value, IntType):

    60

            text += str(value)

    61

        elif value in extra_values or value % 1 != 0:

    62

            text += float_format(value)

    63

        else:

    64

            text += "{:.0f}".format(value)

    65

        if name is not None:

    66

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

    67

        return text

    68

    return generateXMLTextMethod

    69

    70

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

    71

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

    72

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

    73

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

    74

    75

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

    76

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

    77

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

    78

    79

    80

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

    81

#                           Structure reducing functions

    82

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

    83

    84

    85

# Documentation elements

    86

    87

def ReduceAppInfo(factory, attributes, elements):

    88

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

    89

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

    90

    91

    92

def ReduceDocumentation(factory, attributes, elements):

    93

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

    94

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

    95

    96

    97

def ReduceAnnotation(factory, attributes, elements):

    98

    annotations, children = factory.ReduceElements(elements)

    99

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

   100

    for child in children:

   101

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

   102

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

   103

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

   104

            if child["source"] is not None:

   105

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

   106

            else:

   107

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

   108

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

   109

                annotation["documentation"] = text

   110

            else:

   111

                annotation["documentation"] += text

   112

    return annotation

   113

   114

# Simple type elements

   115

   117

def GenerateFacetReducing(facetname, canbefixed):

   118

    def ReduceFacet(factory, attributes, elements):

   119

        annotations, children = factory.ReduceElements(elements)

   120

        if attributes.has_key("value"):

   121

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

   122

            if canbefixed:

   123

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

   124

            return facet

   125

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

   126

    return ReduceFacet

   127

   128

   129

def ReduceList(factory, attributes, elements):

   130

    annotations, children = factory.ReduceElements(elements)

   131

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

   132

   133

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

   134

        if list["itemType"] is None:

   135

            list["itemType"] = children[0]

   136

        else:

   137

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

   138

    if list["itemType"] is None:

   139

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

   140

    return list

   141

   142

   143

def ReduceUnion(factory, attributes, elements):

   144

    annotations, children = factory.ReduceElements(elements)

   145

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

   146

   147

    for child in children:

   148

        if child["type"] == SIMPLETYPE:

   149

            union["memberTypes"].appendchild

   150

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

   151

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

   152

    return union

   153

   154

   155

def CreateSimpleType(factory, attributes, typeinfos):

   156

    # Initialize type informations

   157

    facets = {}

   158

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

   159

    if attributes.has_key("name"):

   160

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

   161

   162

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

   163

        # Search for base type definition

   164

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

   165

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

   166

            if basetypeinfos is None:

   167

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

   168

        else:

   169

            basetypeinfos = typeinfos["base"]

   170

   171

        # Check that base type is a simple type

   172

        if basetypeinfos["type"] != SIMPLETYPE:

   173

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

   174

   175

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

   176

   177

        # Check that derivation is allowed

   178

        if basetypeinfos.has_key("final"):

   179

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

   180

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

   181

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

   182

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

   183

   184

        # Extract simple type facets

   185

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

   186

            facettype = facet["type"]

   187

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

   188

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

   189

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

   190

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

   191

            value = facet["value"]

   192

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

   193

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

   194

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

   195

                if len(facets) == 0:

   196

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

   197

                    continue

   198

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

   199

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

   200

                    continue

   201

                else:

   202

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

   203

            elif facets.has_key("enumeration"):

   204

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

   205

            elif facets.has_key("pattern"):

   206

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

   207

            elif facets.has_key(facettype):

   208

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

   209

            elif facettype == "length":

   210

                if facets.has_key("minLength"):

   211

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

   212

                if facets.has_key("maxLength"):

   213

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

   214

                try:

   215

                    value = int(value)

   216

                except:

   217

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

   218

                if value < 0:

   219

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

   220

                elif basevalue is not None and basevalue != value:

   221

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

   222

            elif facettype == "minLength":

   223

                if facets.has_key("length"):

   224

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

   225

                try:

   226

                    value = int(value)

   227

                except:

   228

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

   229

                if value < 0:

   230

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

   231

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

   232

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

   233

                elif basevalue is not None and basevalue < value:

   234

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

   235

            elif facettype == "maxLength":

   236

                if facets.has_key("length"):

   237

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

   238

                try:

   239

                    value = int(value)

   240

                except:

   241

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

   242

                if value < 0:

   243

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

   244

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

   245

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

   246

                elif basevalue is not None and basevalue > value:

   247

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

   248

            elif facettype == "minInclusive":

   249

                if facets.has_key("minExclusive"):

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

            elif facettype == "minExclusive":

   257

                if facets.has_key("minInclusive"):

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

            elif facettype == "maxInclusive":

   265

                if facets.has_key("maxExclusive"):

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

            elif facettype == "maxExclusive":

   273

                if facets.has_key("maxInclusive"):

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

            elif facettype == "whiteSpace":

   281

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

   282

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

   283

            elif facettype == "totalDigits":

   284

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

   285

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

   286

                elif basevalue is not None and value > basevalue:

   287

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

   288

            elif facettype == "fractionDigits":

   289

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

   290

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

   291

                elif basevalue is not None and value > basevalue:

   292

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

   293

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

   294

   295

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

   296

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

   297

            if not facets.has_key(facettype):

   298

                facets[facettype] = facetvalue

   299

   300

        # Generate extract value for new created type

   301

        def ExtractSimpleTypeValue(attr, extract=True):

   302

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

   303

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

   304

                if facetvalue is not None:

   305

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

   306

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

   307

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

   308

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

   309

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

   310

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

   311

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

   312

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

   313

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

   314

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

   315

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

   316

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

   317

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

   318

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

   319

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

   320

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

   321

                    elif facetname == "pattern":

   322

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

   323

                        result = model.match(value)

   324

                        if result is None:

   325

                            if len(facetvalue) > 1:

   326

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

   327

                            else:

   328

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

   329

                    elif facetname == "whiteSpace":

   330

                        if facetvalue == "replace":

   331

                            value = GetNormalizedString(value, False)

   332

                        elif facetvalue == "collapse":

   333

                            value = GetToken(value, False)

   334

            return value

   335

   336

        def CheckSimpleTypeValue(value):

   337

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

   338

                if facetvalue is not None:

   339

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

   340

                        return False

   341

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

   342

                        return False

   343

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

   344

                        return False

   345

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

   346

                        return False

   347

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

   348

                        return False

   349

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

   350

                        return False

   351

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

   352

                        return False

   353

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

   354

                        return False

   355

                    elif facetname == "pattern":

   356

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

   357

                        result = model.match(value)

   358

                        if result is None:

   359

                            if len(facetvalue) > 1:

   360

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

   361

                            else:

   362

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

   363

            return True

   364

   365

        def SimpleTypeInitialValue():

   366

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

   367

                if facetvalue is not None:

   368

                    if facetname == "enumeration":

   369

                        return facetvalue[0]

   370

                    elif facetname == "length":

   371

                        return " "*facetvalue

   372

                    elif facetname == "minLength":

   373

                        return " "*minLength

   374

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

   375

                        return facetvalue

   376

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

   377

                        return facetvalue + 1

   378

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

   379

                        return facetvalue

   380

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

   381

                        return facetvalue - 1

   382

            return basetypeinfos["initial"]()

   383

   384

        GenerateSimpleType = basetypeinfos["generate"]

   385

   386

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

   387

        # Search for item type definition

   388

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

   389

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

   390

            if itemtypeinfos is None:

   391

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

   392

        else:

   393

            itemtypeinfos = typeinfos["itemType"]

   394

   395

        # Check that item type is a simple type

   396

        if itemtypeinfos["type"] != SIMPLETYPE:

   397

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

   398

   399

        simpleType["basename"] = "list"

   400

   401

        # Check that derivation is allowed

   402

        if itemtypeinfos.has_key("final"):

   403

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

   404

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

   405

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

   406

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

   407

   408

        # Generate extract value for new created type

   409

        def ExtractSimpleTypeValue(attr, extract = True):

   410

            values = []

   411

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

   412

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

   413

            return values

   414

   415

        def CheckSimpleTypeValue(value):

   416

            for item in value:

   417

                result = itemtypeinfos["check"](item)

   418

                if not result:

   419

                    return result

   420

            return True

   421

   422

        SimpleTypeInitialValue = lambda: []

   423

   424

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

   425

   426

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

   427

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

   428

   429

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

   430

        # Search for member types definition

   431

        membertypesinfos = []

   432

        for membertype in typeinfos["memberTypes"]:

   433

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

   434

                infos = factory.FindSchemaElement(membertype, SIMPLETYPE)

   435

                if infos is None:

   436

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

   437

            else:

   438

                infos = membertype

   439

   440

            # Check that member type is a simple type

   441

            if infos["type"] != SIMPLETYPE:

   442

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

   443

   444

            # Check that derivation is allowed

   445

            if infos.has_key("final"):

   446

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

   447

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

   448

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

   449

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

   450

   451

            membertypesinfos.append(infos)

   452

   453

        simpleType["basename"] = "union"

   454

   455

        # Generate extract value for new created type

   456

        def ExtractSimpleTypeValue(attr, extract = True):

   457

            if extract:

   458

                value = GetAttributeValue(attr)

   459

            else:

   460

                value = attr

   461

            for infos in membertypesinfos:

   462

                try:

   463

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

   464

                except:

   465

                    pass

   466

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

   467

   468

        def CheckSimpleTypeValue(value):

   469

            for infos in membertypesinfos:

   470

                result = infos["check"](value)

   471

                if result:

   472

                    return result

   473

            return False

   474

   475

        SimpleTypeInitialValue = membertypesinfos[0]["initial"]

   476

   477

        def GenerateSimpleTypeFunction(value):

   478

            if isinstance(value, BooleanType):

   479

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

   480

            else:

   481

                return str(value)

   482

        GenerateSimpleType = GenerateSimpleTypeXMLText(GenerateSimpleTypeFunction)

   483

   484

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

   485

   486

    simpleType["facets"] = facets

   487

    simpleType["extract"] = ExtractSimpleTypeValue

   488

    simpleType["initial"] = SimpleTypeInitialValue

   489

    simpleType["check"] = CheckSimpleTypeValue

   490

    simpleType["generate"] = GenerateSimpleType

   491

    return simpleType

   492

   494

def ReduceSimpleType(factory, attributes, elements):

   495

    # Reduce all the simple type children

   496

    annotations, children = factory.ReduceElements(elements)

   497

   498

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

   499

    simpleType["doc"] = annotations

   500

   501

    return simpleType

   502

   503

# Complex type

   504

   506

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

   507

    attrs = []

   508

    attrnames = {}

   509

    if base is not None:

   510

        basetypeinfos = factory.FindSchemaElement(base)

   511

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

   512

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

   513

   514

    for element in elements:

   515

        if element["type"] == ATTRIBUTE:

   516

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

   517