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

import sys,re

    27

from types import *

    28

from datetime import *

    29

from new import classobj

    30

    31

"""

    32

Time and date definitions

    33

"""

    34

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

    35

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

    36

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

    37

    38

"""

    39

Regular expression models for extracting dates and times from a string

    40

"""

    41

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

    42

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

    43

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

    44

    45

"""

    46

This function calculates the number of whitespace for indentation

    47

"""

    48

def getIndent(indent, balise):

    49

    first = indent * 2

    50

    second = first + len(balise) + 1

    51

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

    52

    53

"""

    54

Function that extracts data from a node

    55

"""

    56

def GetAttributeValue(attr):

    57

    if len(attr.childNodes) == 1:

    58

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

    59

    else:

    60

        text = ""

    61

        for node in attr.childNodes:

    62

            if node.nodeName != "#text":

    63

                text += node.data.encode()

    64

        return text

    65

    66

"""

    67

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

    68

there is no uppercase in plcopen)

    69

"""

    70

def ComputeValue(value):

    71

    if type(value) == BooleanType:

    72

        if value:

    73

            return "true"

    74

        else:

    75

            return "false"

    76

    else:

    77

        return str(value)

    78

    79

"""

    80

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

    81

"""

    82

def GetComputedValue(attr_type, value):

    83

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

    84

    if type_compute == "boolean":

    85

         if value == "true":

    86

             return True

    87

         elif value == "false":

    88

             return False

    89

         else:

    90

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

    91

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

    92

        return int(value)

    93

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

    94

        return value

    95

    elif type_compute == "time":

    96

        result = time_model.match(value)

    97

        if result:

    98

            values = result.groups()

    99

            time_values = [int(v) for v in values[:2]]

   100

            seconds = float(values[2])

   101

            time_values.extend([int(seconds), int((seconds % 1) * 1000000)])

   102

            return time(*time_values)

   103

        else:

   104

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

   105

    elif type_compute == "date":

   106

        result = date_model.match(value)

   107

        if result:

   108

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

   109

            return date(*date_values)

   110

        else:

   111

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

   112

    elif type_compute == "dateTime":

   113

        result = datetime_model.match(value)

   114

        if result:

   115

            values = result.groups()

   116

            datetime_values = [int(v) for v in values[:5]]

   117

            seconds = float(values[5])

   118

            datetime_values.extend([int(seconds), int((seconds % 1) * 1000000)])

   119

            return datetime(*datetime_values)

   120

        else:

   121

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

   122

    else:

   123

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

   124

        return None

   125

   126

"""

   127

Class that generate class from an XML Tree 

   128

"""

   129

class ClassFactory:

   130

   131

    def __init__(self, xsd_tree):

   132

        self.XML_Tree = xsd_tree

   133

   134

        # Dictionary for stocking Classes and Types definitions created from the XML tree

   135

        self.XMLClassDefinitions = {}

   136

   137

        # Dictionaries for stocking Classes and Types generated

   138

        self.ComputedClasses = {}

   139

        self.ComputedTypes = {}

   140

        self.AlreadyComputed = {}

   141

   142

    """

   143

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

   144

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

   145

    """

   146

    def GenerateXSDClasses(self, tree, parent, sequence = False):

   147

        attributes = {}

   148

        inheritance = []

   149

        if sequence:

   150

            order = []

   151

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

   152

        for node in tree.childNodes:

   153

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

   154

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

   155

                recursion = False

   156

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

   157

   158

                # This tags defines an attribute of the class

   159

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

   160

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

   161

                    if "type" in node._attrs:

   162

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

   163

                        if nodetype.startswith("xsd"):

   164

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

   165

                        elif nodetype.startswith("ppx"):

   166

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

   167

                    else:

   168

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

   169

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

   170

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

   171

                        if parent:

   172

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

   173

                        else:

   174

                            classname = nodename

   175

                        self.GenerateXSDClasses(node, classname)

   176

                        nodetype = "cls:%s"%classname

   177

                    if name == "attribute":

   178

                        if "use" in node._attrs:

   179

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

   180

                        else:

   181

                            use = "optional"

   182

                    if name == "element":

   183

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

   184

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

   185

                            nodetype = "%s[]"%nodetype

   186

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

   187

                            use = "optional"

   188

                        else:

   189

                            use = "required"

   190

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

   191

                    if sequence:

   192

                        order.append(nodename)

   193

   194

                # This tag defines a new class

   195

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

   196

                    if "name" in node._attrs:

   197

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

   198

                        super, attrs = self.GenerateXSDClasses(node, classname)

   199

                    else:

   200

                        classname = parent

   201

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

   202

                    # When all attributes and inheritances have been extracted, the

   203

                    # values are added in the list of classes to create

   204

                    if self.XMLClassDefinitions.get(classname, None) == None:

   205

                        self.XMLClassDefinitions[classname] = (super, attrs)

   206

                    elif self.XMLClassDefinitions[classname] != (super, attrs):

   207

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

   208

   209

                # This tag defines an attribute that can have different types

   210

                elif name == "choice":

   211

                    super, attrs = self.GenerateXSDClasses(node, parent)

   212

   213

                    if "ref" in attrs.keys():

   214

                        choices = attrs

   215

                    else:

   216

                        choices = {}

   217

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

   218

                            choices[attr] = attr_type

   219

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

   220

                        attributes["multichoice_content"] = choices

   221

                        if sequence:

   222

                            order.append("multichoice_content")

   223

                    else:

   224

                        attributes["choice_content"] = choices

   225

                        if sequence:

   226

                            order.append("choice_content")

   227

   228

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

   229

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

   230

                elif name in "sequence":

   231

                    super, attrs, order = self.GenerateXSDClasses(node, parent, True)

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

                    inheritance.extend(super)

   239

                    attributes.update(attrs)

   240

                    attributes["order"] = order

   241

   242

                # This tag defines of types

   243

                elif name == "group":

   244

                    if "name" in node._attrs:

   245

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

   246

                        super, attrs = self.GenerateXSDClasses(node, None)

   247

                        self.XMLClassDefinitions[nodename] = (super, {"group":attrs["choice_content"]})

   248

                    elif "ref" in node._attrs:

   249

                        if "ref" not in attributes:

   250

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

   251

                        else:

   252

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

   253

   254

                # This tag define a base class for the node

   255

                elif name == "extension":

   256

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

   257

                    if super.startswith("xsd"):

   258

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

   259

                    elif super.startswith("ppx"):

   260

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

   261

                    inheritance.append(super[4:])

   262

                    recursion = True

   263

   264

                # This tag defines a restriction on the type of attribute

   265

                elif name == "restriction":

   266

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

   267

                    if basetype.startswith("xsd"):

   268

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

   269

                    elif basetype.startswith("ppx"):

   270

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

   271

                    attributes["basetype"] = basetype

   272

                    recursion = True

   273

   274

                # This tag defines an enumerated type

   275

                elif name == "enumeration":

   276

                    if "enum" not in attributes:

   277

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

   278

                    else:

   279

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

   280

   281

                # This tags defines a restriction on a numerical value

   282

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

   283

                    if "limit" not in attributes:

   284

                        attributes["limit"] = {}

   285

                    if name == "minInclusive":

   286

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

   287

                    elif name == "maxInclusive":

   288

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

   289

   290

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

   291

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

   292

                    recursion = True

   293

   294

                # We make fun of xsd documentation

   295

                elif name in ["annotation"]:

   296

                    pass

   297

   298

                else:

   299

                    # Unable this line to print XSD element that is not yet supported 

   300

                    #print name

   301

                    self.GenerateXSDClasses(node, parent)

   302

   303

                # Parse the childrens of node

   304

                if recursion:

   305

                    super, attrs = self.GenerateXSDClasses(node, parent)

   306

                    inheritance.extend(super)

   307

                    attributes.update(attrs)

   308

   309

        # if sequence tag have been found, order is returned

   310

        if sequence:

   311

            return inheritance, attributes, order

   312

        else:

   313

            return inheritance, attributes

   314

   315

    """

   316

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

   317

    """

   318

    def GetTypeInitialValue(self, attr_type):

   319

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

   320

        if attr_type.startswith("bse:"):

   321

            if type_compute == "boolean":

   322

                return BooleanType, "False"

   323

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

   324

                return IntType, "0"

   325

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

   326

                return StringType, "\"\""

   327

            elif type_compute == "time":

   328

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

   329

            elif type_compute == "date":

   330

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

   331

            elif type_compute == "dateTime":

   332

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

   333

            elif type_compute == "language":

   334

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

   335

            else:

   336

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

   337

        elif attr_type.startswith("cls:"):

   338

            if self.XMLClassDefinitions.get(type_compute, None) != None:

   339

                return self.XMLClassDefinitions[type_compute],"%s()"%type_compute

   340

   341

    """

   342

    Methods that generate the classes

   343

    """

   344

    def CreateClasses(self):

   345

        self.GenerateXSDClasses(self.XML_Tree, None)

   346

        for classname in self.XMLClassDefinitions.keys():

   347

            self.CreateClass(classname)

   348

        for classname in self.XMLClassDefinitions.keys():

   349

            self.MarkUsedClasses(classname)

   350

        return self.ComputedClasses, self.ComputedTypes

   351

   352

    def CreateClass(self, classname):

   353

        # Checks that classe haven't been generated yet

   354

        if not self.AlreadyComputed.get(classname, False) and classname in self.XMLClassDefinitions:

   355

            self.AlreadyComputed[classname] = True

   356

            inheritance, attributes = self.XMLClassDefinitions[classname]

   357

            #print classname, inheritance, attributes

   358

            members = {}

   359

            bases = []

   360

   361

            # If inheritance classes haven't been generated

   362

            for base in inheritance:

   363

                self.CreateClass(base)

   364

                bases.append(self.ComputedClasses[base])

   365

   366

            # Checks that all attribute types are available 

   367

            for attribute, type_attribute in attributes.items():

   368

                if attribute == "group":

   369

                    self.ComputedTypes[classname] = type_attribute

   370

                elif attribute in ["choice_content","multichoice_content"]:

   371

                    element_types = {}

   372

                    for attr, value in type_attribute.items():

   373

                        if attr == "ref":

   374

                            for ref in value:

   375

                                self.CreateClass(ref[4:])

   376

                                element_types.update(self.ComputedTypes[ref[4:]])

   377

                        else:

   378

                            element_types[attr] = value

   379

                    members[attribute] = element_types

   380

                else:

   381

                    members[attribute] = type_attribute

   382

                    if attribute == "enum":

   383

                        self.ComputedTypes["%s_enum"%classname] = type_attribute

   384

                    elif attribute not in ["limit", "order"]:

   385

                        if type_attribute[0].startswith("cls:"):

   386

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

   387

                            self.CreateClass(type_compute)

   388

            if "group" not in attributes:

   389

                bases = tuple(bases)

   390

                classmembers = {"IsBaseClass" : True}

   391

                initialValues = {}

   392

                for attr, values in members.items():

   393

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

   394

                        pass

   395

   396

                    # Class is a enumerated type

   397

                    elif attr == "enum":

   398

                        value_type, initial = self.GetTypeInitialValue(members["basetype"])

   399

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

   400

                        classmembers["value"] = values[0]

   401

                        classmembers["setValue"] = generateSetEnumMethod(values, value_type)

   402

                        classmembers["getValue"] = generateGetMethod("value")

   403

   404

                    # Class is a limited type

   405

                    elif attr == "limit":

   406

                        value_type, initial = self.GetTypeInitialValue(members["basetype"])

   407

                        initial = 0

   408

                        if "min" in values:

   409

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

   410

                        if "max" in values:

   411

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

   412

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

   413

                        classmembers["value"] = initial

   414

                        classmembers["setValue"] = generateSetLimitMethod(values, value_type)

   415

                        classmembers["getValue"] = generateGetMethod("value")

   416

   417

                    # Class has an attribute that can have different value types

   418

                    elif attr == "choice_content":

   419

                        classmembers["content"] = None

   420

                        initialValues["content"] = "None"

   421

                        classmembers["deleteContent"] = generateDeleteMethod("content")

   422

                        classmembers["setContent"] = generateSetChoiceMethod(values)

   423

                        classmembers["getContent"] = generateGetMethod("content")

   424

                    elif attr == "multichoice_content":

   425

                        classmembers["content"] = []

   426

                        initialValues["content"] = "[]"

   427

                        classmembers["appendContent"] = generateAppendChoiceMethod(values)

   428

                        classmembers["insertContent"] = generateInsertChoiceMethod(values)

   429

                        classmembers["removeContent"] = generateRemoveMethod("content")

   430

                        classmembers["countContent"] = generateCountMethod("content")

   431

                        classmembers["setContent"] = generateSetMethod("content", ListType)

   432

                        classmembers["getContent"] = generateGetMethod("content")

   433

   434

                    # It's an attribute of the class

   435

                    else:

   436

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

   437

                        attr_type, xml_type, write_type = values

   438

                        value_type, initial = self.GetTypeInitialValue(attr_type)

   439

                        # Value of the attribute is a list

   440

                        if attr_type.endswith("[]"):

   441

                            classmembers[attr] = []

   442

                            initialValues[attr] = "[]"

   443

                            classmembers["append"+attrname] = generateAppendMethod(attr, value_type)

   444

                            classmembers["insert"+attrname] = generateInsertMethod(attr, value_type)

   445

                            classmembers["remove"+attrname] = generateRemoveMethod(attr)

   446

                            classmembers["count"+attrname] = generateCountMethod(attr)

   447

                            classmembers["set"+attrname] = generateSetMethod(attr, ListType)

   448

                        else:

   449

                            if write_type == "optional":

   450

                                classmembers[attr] = None

   451

                                initialValues[attr] = "None"

   452

                                classmembers["add"+attrname] = generateAddMethod(attr, initial, self.ComputedClasses)

   453

                                classmembers["delete"+attrname] = generateDeleteMethod(attr)

   454

                            else:

   455

                                classmembers[attr] = initial

   456

                                initialValues[attr] = initial

   457

                            classmembers["set"+attrname] = generateSetMethod(attr, value_type)

   458

                        classmembers["get"+attrname] = generateGetMethod(attr)

   459

                classmembers["__init__"] = generateInitMethod(bases, initialValues, self.ComputedClasses)

   460

                classmembers["loadXMLTree"] = generateLoadXMLTree(bases, members, self.ComputedClasses)

   461

                classmembers["generateXMLText"] = generateGenerateXMLText(bases, members)

   462

                classmembers["getElementAttributes"] = generategetElementAttributes(bases, members)

   463

                classmembers["singleLineAttributes"] = True

   464

   465

                self.ComputedClasses[classname] = classobj(classname, bases, classmembers)

   466

   467

    def MarkUsedClasses(self, classname):

   468

        # Checks that classe haven't been generated yet

   469

        if classname in self.XMLClassDefinitions:

   470

            inheritance, attributes = self.XMLClassDefinitions[classname]

   471

   472

            # If inheritance classes haven't been generated

   473

            for base in inheritance:

   474

                if base in self.ComputedClasses:

   475

                    self.ComputedClasses[base].IsBaseClass = False

   476

   477

            # Checks that all attribute types are available 

   478

            for attribute, type_attribute in attributes.items():

   479

                if attribute in ["choice_content","multichoice_content"]:

   480

                    element_types = {}

   481

                    for attr, value in type_attribute.items():

   482

                        if attr == "ref":

   483

                            for ref in value:

   484

                                element_types.update(self.ComputedTypes[ref[4:]])

   485

                        else:

   486

                            element_types[attr] = value

   487

                    for type_name in element_types.values():

   488

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

   489

                        if type_compute in self.ComputedClasses:

   490

                            self.ComputedClasses[type_compute].IsBaseClass = False

   491

                elif attribute != "group":

   492

                    if attribute not in ["enum", "limit", "order"]:

   493

                        if type_attribute[0].startswith("cls:"):

   494

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

   495

                            if type_compute in self.ComputedClasses:

   496

                                self.ComputedClasses[type_compute].IsBaseClass = False

   497

   498

    """

   499

    Methods that print the classes generated

   500

    """

   501

    def PrintClasses(self):

   502

        for classname, xmlclass in self.ComputedClasses.items():