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): 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

#Lesser 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

import sys,re

    27

from types import *

    28

from datetime import *

    29

    30

"""

    31

Time and date definitions

    32

"""

    33

TimeType = time(0,0,0).__class__

    34

DateType = date(1,1,1).__class__

    35

DateTimeType = datetime(1,1,1,0,0,0).__class__

    36

    37

"""

    38

Regular expression models for extracting dates and times from a string

    39

"""

    40

time_model = re.compile('([0-9]{2}):([0-9]{2}):([0-9]{2})')

    41

date_model = re.compile('([0-9]{4})-([0-9]{2})-([0-9]{2})')

    42

datetime_model = re.compile('([0-9]{4})-([0-9]{2})-([0-9]{2})[ T]([0-9]{2}):([0-9]{2}):([0-9]{2})')

    43

    44

"""

    45

Dictionaries for stocking Classes and Types created from XML

    46

"""

    47

XMLClasses = {}

    48

    49

"""

    50

This function calculates the number of whitespace for indentation

    51

"""

    52

def getIndent(indent, balise):

    53

    first = indent * 2

    54

    second = first + len(balise) + 1

    55

    return "\t".expandtabs(first), "\t".expandtabs(second)

    56

    57

"""

    58

This function opens the xsd file and generate the classes from the xml tree

    59

"""

    60

def GenerateClassesFromXSD(filename):

    61

    xsdfile = open(filename, 'r')

    62

    Generate_xsd_classes(minidom.parse(xsdfile), None)

    63

    xsdfile.close()

    64

    65

"""

    66

This function recursively creates a definition of the classes and their attributes

    67

for plcopen from the xsd file of plcopen opened in a DOM model

    68

"""

    69

def Generate_xsd_classes(tree, parent, sequence = False):

    70

    attributes = {}

    71

    inheritance = []

    72

    if sequence:

    73

        order = []

    74

    # The lists of attributes and inheritance of the node are generated from the childrens 

    75

    for node in tree.childNodes:

    76

        # We make fun of #text elements and all other tags that don't are xsd tags

    77

        if node.nodeName != "#text" and node.nodeName.startswith("xsd:"):

    78

            recursion = False

    79

            name = node.nodeName[4:].encode()

    80

    81

            # This tags defines an attribute of the class

    82

            if name in ["element", "attribute"]:

    83

                nodename = GetAttributeValue(node._attrs["name"])

    84

                if "type" in node._attrs:

    85

                    nodetype = GetAttributeValue(node._attrs["type"])

    86

                    if nodetype.startswith("xsd"):

    87

                        nodetype = nodetype.replace("xsd", "bse")

    88

                    elif nodetype.startswith("ppx"):

    89

                        nodetype = nodetype.replace("ppx", "cls")

    90

                else:

    91

                    # The type of attribute is defines in the child tree so we generate a new class

    92

                    # No name is defined so we create one from nodename and parent class name

    93

                    # (because some different nodes can have the same name)

    94

                    if parent:

    95

                        classname = "%s_%s"%(parent, nodename)

    96

                    else:

    97

                        classname = nodename

    98

                    Generate_xsd_classes(node, classname)

    99

                    nodetype = "cls:%s"%classname

   100

                if name == "attribute":

   101

                    if "use" in node._attrs:

   102

                        use = GetAttributeValue(node._attrs["use"])

   103

                    else:

   104

                        use = "optional"

   105

                if name == "element":

   106

                    # If a tag can be written more than one time we define a list attribute

   107

                    if "maxOccurs" in node._attrs and GetAttributeValue(node._attrs["maxOccurs"]) == "unbounded":

   108

                        nodetype = "%s[]"%nodetype

   109

                    if "minOccurs" in node._attrs and GetAttributeValue(node._attrs["minOccurs"]) == "0":

   110

                        use = "optional"

   111

                    else:

   112

                        use = "required"

   113

                attributes[nodename] = (nodetype, name, use)

   114

                if sequence:

   115

                    order.append(nodename)

   116

   117

            # This tag defines a new class

   118

            elif name == "complexType" or name == "simpleType":

   119

                if "name" in node._attrs:

   120

                    classname = GetAttributeValue(node._attrs["name"])

   121

                    super, attrs = Generate_xsd_classes(node, classname)

   122

                else:

   123

                    classname = parent

   124

                    super, attrs = Generate_xsd_classes(node, classname.split("_")[-1])

   125

                # When all attributes and inheritances have been extracted, the

   126

                # values are added in the list of classes to create

   127

                if classname not in XMLClasses:

   128

                    XMLClasses[classname] = (super, attrs)

   129

                elif XMLClasses[classname] != (super, attrs):

   130

                    print "A different class has already got %s for name"%classname

   131

   132

            # This tag defines an attribute that can have different types

   133

            elif name == "choice":

   134

                super, attrs = Generate_xsd_classes(node, parent)

   135

                if "ref" in attrs.keys():

   136

                    choices = attrs

   137

                else:

   138

                    choices = {}

   139

                    for attr, (attr_type, xml_type, write_type) in attrs.items():

   140

                        choices[attr] = attr_type

   141

                if "maxOccurs" in node._attrs and GetAttributeValue(node._attrs["maxOccurs"]) == "unbounded":

   142

                    attributes["multichoice_content"] = choices

   143

                    if sequence:

   144

                        order.append("multichoice_content")

   145

                else:

   146

                    attributes["choice_content"] = choices

   147

                    if sequence:

   148

                        order.append("choice_content")

   149

   150

            # This tag defines the order in which class attributes must be written

   151

            # in plcopen xml file. We have to store this order like an attribute

   152

            elif name in "sequence":

   153

                super, attrs, order = Generate_xsd_classes(node, parent, True)

   154

                if "maxOccurs" in node._attrs and GetAttributeValue(node._attrs["maxOccurs"]) == "unbounded":

   155

                    for attr, (attr_type, xml_type, write_type) in attrs.items():

   156

                        attrs[attr] = ("%s[]"%attr_type, xml_type, write_type)

   157

                if "minOccurs" in node._attrs and GetAttributeValue(node._attrs["minOccurs"]) == "0":

   158

                    for attr, (attr_type, xml_type, write_type) in attrs.items():

   159

                        attrs[attr] = (attr_type, xml_type, "optional")

   160

                inheritance.extend(super)

   161

                attributes.update(attrs)

   162

                attributes["order"] = order

   163

   164

            # This tag defines of types

   165

            elif name == "group":

   166

                if "name" in node._attrs:

   167

                    nodename = GetAttributeValue(node._attrs["name"])

   168

                    super, attrs = Generate_xsd_classes(node, None)

   169

                    XMLClasses[nodename] = (super, {"group":attrs["choice_content"]})

   170

                elif "ref" in node._attrs:

   171

                    if "ref" not in attributes:

   172

                        attributes["ref"] = [GetAttributeValue(node._attrs["ref"])]

   173

                    else:

   174

                        attributes["ref"].append(GetAttributeValue(node._attrs["ref"]))

   175

   176

            # This tag define a base class for the node

   177

            elif name == "extension":

   178

                super = GetAttributeValue(node._attrs["base"])

   179

                if super.startswith("xsd"):

   180

                    super = super.replace("xsd", "bse")

   181

                elif super.startswith("ppx"):

   182

                    super = super.replace("ppx", "cls")

   183

                inheritance.append(super[4:])

   184

                recursion = True

   185

   186

            # This tag defines a restriction on the type of attribute

   187

            elif name == "restriction":

   188

                basetype = GetAttributeValue(node._attrs["base"])

   189

                if basetype.startswith("xsd"):

   190

                    basetype = basetype.replace("xsd", "bse")

   191

                elif basetype.startswith("ppx"):

   192

                    basetype = basetype.replace("ppx", "cls")

   193

                attributes["basetype"] = basetype

   194

                recursion = True

   195

   196

            # This tag defines an enumerated type

   197

            elif name == "enumeration":

   198

                if "enum" not in attributes:

   199

                    attributes["enum"] = [GetAttributeValue(node._attrs["value"])]

   200

                else:

   201

                    attributes["enum"].append(GetAttributeValue(node._attrs["value"]))

   202

   203

            # This tags defines a restriction on a numerical value

   204

            elif name in ["minInclusive","maxInclusive"]:

   205

                if "limit" not in attributes:

   206

                    attributes["limit"] = {}

   207

                if name == "minInclusive":

   208

                    attributes["limit"]["min"] = eval(GetAttributeValue(node._attrs["value"]))

   209

                elif name == "maxInclusive":

   210

                    attributes["limit"]["max"] = eval(GetAttributeValue(node._attrs["value"]))

   211

   212

            # This tag are not important but their childrens are. The childrens are then parsed. 

   213

            elif name in ["complexContent", "schema"]:

   214

                recursion = True

   215

   216

            # We make fun of xsd documentation

   217

            elif name in ["annotation"]:

   218

                pass

   219

   220

            else:

   221

                #print name

   222

                Generate_xsd_classes(node, parent)

   223

   224

            # Parse the childrens of node

   225

            if recursion:

   226

                super, attrs = Generate_xsd_classes(node, parent)

   227

                inheritance.extend(super)

   228

                attributes.update(attrs)

   229

   230

    # if sequence tag have been found, order is returned

   231

    if sequence:

   232

        return inheritance, attributes, order

   233

    else:

   234

        return inheritance, attributes

   235

"""

   236

Function that extracts data from a node

   237

"""

   238

def GetAttributeValue(attr):

   239

    if len(attr.childNodes) == 1:

   240

        return attr.childNodes[0].data.encode()

   241

    else:

   242

        return ""

   243

   244

"""

   245

Funtion that returns the Python type and default value for a given type

   246

"""

   247

def GetTypeInitialValue(attr_type):

   248

    type_compute = attr_type[4:].replace("[]", "")

   249

    if attr_type.startswith("bse:"):

   250

        if type_compute == "boolean":

   251

            return BooleanType, "False"

   252

        elif type_compute in ["decimal","unsignedLong","long","integer"]:

   253

            return IntType, "0"

   254

        elif type_compute in ["string","anyURI","NMTOKEN"]:

   255

            return StringType, "\"\""

   256

        elif type_compute == "time":

   257

            return TimeType, "time(0,0,0)"

   258

        elif type_compute == "date":

   259

            return DateType, "date(1,1,1)"

   260

        elif type_compute == "dateTime":

   261

            return DateTimeType, "datetime(1,1,1,0,0,0)"

   262

        elif type_compute == "language":

   263

            return StringType, "\"en-US\""

   264

        else:

   265

            print "Can't affect: %s"%type_compute

   266

    elif attr_type.startswith("cls:"):

   267

        if type_compute in XMLClasses:

   268

            return XMLClasses[type_compute],"%s()"%type_compute

   269

   270

"""

   271

Function that computes value from a python type (Only Boolean are critical because

   272

there is no uppercase in plcopen)

   273

"""

   274

def ComputeValue(value):

   275

    if type(value) == BooleanType:

   276

        if value:

   277

            return "true"

   278

        else:

   279

            return "false"

   280

    else:

   281

        return str(value)

   282

   283

"""

   284

Function that extracts a value from a string following the xsd type given

   285

"""

   286

def GetComputedValue(attr_type, value):

   287

    type_compute = attr_type[4:].replace("[]", "")

   288

    if type_compute == "boolean":

   289

         if value == "true":

   290

             return True

   291

         elif value == "false":

   292

             return False

   293

         else:

   294

            raise ValueError, "\"%s\" is not a valid boolean!"%value

   295

    elif type_compute in ["decimal","unsignedLong","long","integer"]:

   296

        return int(value)

   297

    elif type_compute in ["string","anyURI","NMTOKEN","language"]:

   298

        return value

   299

    elif type_compute == "time":

   300

        result = time_model.match(value)

   301

        if result:

   302

            time_values = [int(v) for v in result.groups()]

   303

            return time(*time_values)

   304

        else:

   305

            raise ValueError, "\"%s\" is not a valid time!"%value

   306

    elif type_compute == "date":

   307

        result = date_model.match(value)

   308

        if result:

   309

            date_values = [int(v) for v in result.groups()]

   310

            return date(*date_values)

   311

        else:

   312

            raise ValueError, "\"%s\" is not a valid date!"%value

   313

    elif type_compute == "dateTime":

   314

        result = datetime_model.match(value)

   315

        if result:

   316

            datetime_values = [int(v) for v in result.groups()]

   317

            return datetime(*datetime_values)

   318

        else:

   319

            raise ValueError, "\"%s\" is not a valid datetime!"%value

   320

    else:

   321

        print "Can't affect: %s"%type_compute

   322

        return None

   323

   324

"""

   325

This is the Metaclass for PLCOpen element classes. It generates automatically

   326

the basic useful methods for manipulate the differents attributes of the classes

   327

"""

   328

class MetaClass(type):

   329

   330

    def __init__(cls, name, bases, dict, user_classes):

   331

        super(MetaClass, cls).__init__(name, bases, {})

   332

        #print name, bases, dict, "\n"

   333

        initialValues = {}

   334

        for attr, values in dict.items():

   335

            if attr in ["order", "basetype"]:

   336

                pass

   337

   338

            # Class is a enumerated type

   339

            elif attr == "enum":

   340

                value_type, initial = GetTypeInitialValue(dict["basetype"])

   341

                initialValues["value"] = "\"%s\""%values[0]

   342

                setattr(cls, "value", values[0])

   343

                setattr(cls, "setValue", MetaClass.generateSetEnumMethod(cls, values, value_type))

   344

                setattr(cls, "getValue", MetaClass.generateGetMethod(cls, "value"))

   345

   346

            # Class is a limited type

   347

            elif attr == "limit":

   348

                value_type, initial = GetTypeInitialValue(dict["basetype"])

   349

                initial = 0

   350

                if "min" in values:

   351

                    initial = max(initial, values["min"])

   352

                if "max" in values:

   353

                    initial = min(initial, values["max"])

   354

                initialValues["value"] = "%d"%initial

   355

                setattr(cls, "value", initial)

   356

                setattr(cls, "setValue", MetaClass.generateSetLimitMethod(cls, values, value_type))

   357

                setattr(cls, "getValue", MetaClass.generateGetMethod(cls, "value"))

   358

   359

            # Class has an attribute that can have different value types

   360

            elif attr == "choice_content":

   361

                setattr(cls, "content", None)

   362

                initialValues["content"] = "None"

   363

                setattr(cls, "deleteContent", MetaClass.generateDeleteMethod(cls, "content"))

   364

                setattr(cls, "setContent", MetaClass.generateSetChoiceMethod(cls, values))

   365

                setattr(cls, "getContent", MetaClass.generateGetMethod(cls, "content"))

   366

            elif attr == "multichoice_content":

   367

                setattr(cls, "content", [])

   368

                initialValues["content"] = "[]"

   369

                setattr(cls, "appendContent", MetaClass.generateAppendChoiceMethod(cls, values))

   370

                setattr(cls, "insertContent", MetaClass.generateInsertChoiceMethod(cls, values))

   371

                setattr(cls, "removeContent", MetaClass.generateRemoveMethod(cls, "content"))

   372

                setattr(cls, "countContent", MetaClass.generateCountMethod(cls, "content"))

   373

                setattr(cls, "setContent", MetaClass.generateSetMethod(cls, "content", ListType))

   374

                setattr(cls, "getContent", MetaClass.generateGetMethod(cls, "content"))

   375

   376

            # It's an attribute of the class

   377

            else:

   378

                attrname = attr[0].upper()+attr[1:]

   379

                attr_type, xml_type, write_type = values

   380

                value_type, initial = GetTypeInitialValue(attr_type)

   381

                # Value of the attribute is a list

   382

                if attr_type.endswith("[]"):

   383

                    setattr(cls, attr, [])

   384

                    initialValues[attr] = "[]"

   385

                    setattr(cls, "append"+attrname, MetaClass.generateAppendMethod(cls, attr, value_type))

   386

                    setattr(cls, "insert"+attrname, MetaClass.generateInsertMethod(cls, attr, value_type))

   387

                    setattr(cls, "remove"+attrname, MetaClass.generateRemoveMethod(cls, attr))

   388

                    setattr(cls, "count"+attrname, MetaClass.generateCountMethod(cls, attr))

   389

                    setattr(cls, "set"+attrname, MetaClass.generateSetMethod(cls, attr, ListType))

   390

                else:

   391

                    if write_type == "optional":

   392

                        setattr(cls, attr, None)

   393

                        initialValues[attr] = "None"

   394

                        setattr(cls, "add"+attrname, MetaClass.generateAddMethod(cls, attr, initial, user_classes))

   395

                        setattr(cls, "delete"+attrname, MetaClass.generateDeleteMethod(cls, attr))

   396

                    else:

   397

                        setattr(cls, attr, initial)

   398

                        initialValues[attr] = initial

   399

                    setattr(cls, "set"+attrname, MetaClass.generateSetMethod(cls, attr, value_type))

   400

                setattr(cls, "get"+attrname, MetaClass.generateGetMethod(cls, attr))

   401

        setattr(cls, "__init__", MetaClass.generateInitMethod(cls, bases, initialValues, user_classes))

   402

        setattr(cls, "loadXMLTree", MetaClass.generateLoadXMLTree(cls, bases, dict, user_classes))

   403

        setattr(cls, "generateXMLText", MetaClass.generateGenerateXMLText(cls, bases, dict))

   404

        setattr(cls, "singleLineAttributes", True)

   405

   406

    """

   407

    Method that generate the method for loading an xml tree by following the

   408

    attributes list defined

   409

    """

   410

    def generateLoadXMLTree(cls, bases, dict, user_classes):

   411

        def loadXMLTreeMethod(self, tree):

   412

            # If class is derived, values of inheritance classes are loaded

   413

            for base in bases:

   414

                base.loadXMLTree(self, tree)

   415

            # Class is a enumerated or limited value

   416

            if "enum" in dict.keys() or "limit" in dict.keys():

   417

                attr_value = GetAttributeValue(tree)

   418

                attr_type = dict["basetype"]

   419

                val = GetComputedValue(attr_type, attr_value)

   420

                self.setValue(val)

   421

            else:

   422

   423

                # Load the node attributes if they are defined in the list

   424

                for attrname, attr in tree._attrs.items():

   425

                    if attrname in dict.keys():

   426

                        attr_type, xml_type, write_type = dict[attrname]

   427

                        attr_value = GetAttributeValue(attr)

   428

                        if write_type != "optional" or attr_value != "":

   429

                            # Extracts the value

   430

                            if attr_type.startswith("bse:"):

   431

                                val = GetComputedValue(attr_type, attr_value)

   432

                            elif attr_type.startswith("cls:"):

   433

                                val = eval("%s()"%attr_type[4:], globals().update(user_classes))

   434

                                val.loadXMLTree(attr)

   435

                            setattr(self, attrname, val)

   436

   437

                # Load the node childs if they are defined in the list

   438

                for node in tree.childNodes:

   439

                    name = node.nodeName

   440

                    # We make fun of #text elements

   441

                    if name != "#text":

   442

   443

                        # Class has an attribute that can have different value types

   444

                        if "choice_content" in dict.keys() and name in dict["choice_content"].keys():

   445

                            attr_type = dict["choice_content"][name]

   446

                            # Extracts the value

   447

                            if attr_type.startswith("bse:"):

   448

                                attr_value = GetAttributeValue(node)

   449

                                if write_type != "optional" or attr_value != "":

   450

                                    val = GetComputedValue(attr_type.replace("[]",""), attr_value)

   451

                                else:

   452

                                    val = None

   453

                            elif attr_type.startswith("cls:"):

   454

                                val = eval("%s()"%attr_type[4:].replace("[]",""), globals().update(user_classes))

   455

                                val.loadXMLTree(node)

   456

                            # Stock value in content attribute

   457

                            if val:

   458

                                if attr_type.endswith("[]"):

   459

                                    if self.content:

   460

                                        self.content["value"].append(val)

   461

                                    else:

   462

                                        self.content = {"name":name,"value":[val]}

   463

                                else:

   464

                                    self.content = {"name":name,"value":val}

   465

   466

                        # Class has a list of attributes that can have different value types

   467

                        elif "multichoice_content" in dict.keys() and name in dict["multichoice_content"].keys():

   468

                            attr_type = dict["multichoice_content"][name]

   469

                            # Extracts the value

   470

                            if attr_type.startswith("bse:"):

   471

                                attr_value = GetAttributeValue(node)

   472

                                if write_type != "optional" or attr_value != "":

   473

                                    val = GetComputedValue(attr_type, attr_value)

   474

                                else:

   475

                                    val = None

   476

                            elif attr_type.startswith("cls:"):

   477

                                val = eval("%s()"%attr_type[4:], globals().update(user_classes))

   478

                                val.loadXMLTree(node)

   479

                            # Add to content attribute list

   480

                            if val:

   481

                                self.content.append({"name":name,"value":val})

   482

   483

                        # The node child is defined in the list

   484

                        elif name in dict.keys():

   485

                            attr_type, xml_type, write_type = dict[name]

   486

                            # Extracts the value

   487

                            if attr_type.startswith("bse:"):

   488

                                attr_value = GetAttributeValue(node)

   489

                                if write_type != "optional" or attr_value != "":

   490

                                    val = GetComputedValue(attr_type.replace("[]",""), attr_value)

   491

                                else:

   492

                                    val = None

   493

                            elif attr_type.startswith("cls:"):

   494

                                val = eval("%s()"%attr_type[4:].replace("[]",""), globals().update(user_classes))

   495

                                val.loadXMLTree(node)

   496

                            # Stock value in attribute

   497

                            if val:

   498

                                if attr_type.endswith("[]"):

   499

                                    getattr(self, name).append(val)

   500

                                else:

   501

                                    setattr(self, name, val)

   502

        return loadXMLTreeMethod

   503

   504

    """

   505

    Method that generates the method for generating an xml text by following the

   506

    attributes list defined

   507

    """

   508

    def generateGenerateXMLText(cls, bases, dict):

   509

        def generateXMLTextMethod(self, name, indent, extras = {}, derived = False):

   510

            ind1, ind2 = getIndent(indent, name)

   511

            if not derived:

   512

                text = ind1 + "<%s"%name

   513

            else:

   514

                text = ""

   515

            if len(bases) > 0:

   516

                base_extras = {}

   517

            if "order" in dict.keys():

   518

                order = dict["order"]

   519

            else:

   520

                order = []

   521

            if "choice_content" in dict.keys() and "choice_content" not in order:

   522

                order.append("choice_content") 

   523

            if "multichoice_content" in dict.keys() and "multichoice_content" not in order:

   524

                order.append("multichoice_content") 

   525

            size = 0

   526

            first = True

   527

            for attr, value in extras.items():

   528

                if not first and not self.singleLineAttributes:

   529

                    text += "\n%s"%(ind2)

   530