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

Regular expression models for extracting dates and times from a string

    33

"""

    34

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

    35

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

    36

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]*)?)')

    37

    38

XSD_INTEGER_TYPES = ["integer","nonPositiveInteger","negativeInteger","long",

    39

    "int","short","byte","nonNegativeInteger","unsignedLong","unsignedInt",

    40

    "unsignedShort","unsignedByte","positiveInteger"]

    41

    42

XSD_STRING_TYPES = ["string","normalizedString","token","anyURI","NMTOKEN","language"]

    43

    44

"""

    45

This function calculates the number of whitespace for indentation

    46

"""

    47

def getIndent(indent, balise):

    48

    first = indent * 2

    49

    second = first + len(balise) + 1

    50

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

    51

    52

"""

    53

Function that extracts data from a node

    54

"""

    55

def GetAttributeValue(attr):

    56

    if len(attr.childNodes) == 1:

    57

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

    58

    else:

    59

        text = ""

    60

        for node in attr.childNodes:

    61

            if node.nodeName != "#text":

    62

                text += node.data.encode()

    63

        return text

    64

    65

"""

    66

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

    67

there is no uppercase in plcopen)

    68

"""

    69

def ComputeValue(value):

    70

    if type(value) == BooleanType:

    71

        if value:

    72

            return "true"

    73

        else:

    74

            return "false"

    75

    else:

    76

        return str(value)

    77

    78

"""

    79

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

    80

"""

    81

def GetComputedValue(attr_type, value):

    82

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

    83

    if type_compute == "boolean":

    84

         if value == "true":

    85

             return True

    86

         elif value == "false":

    87

             return False

    88

         else:

    89

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

    90

    elif type_compute in XSD_INTEGER_TYPES:

    91

        return int(value)

    92

    elif type_compute in ["decimal", "float", "double"]:

    93

        computed_value = float(value)

    94

        if computed_value % 1 == 0:

    95

            return int(computed_value)

    96

        return computed_value

    97

    elif type_compute in XSD_STRING_TYPES:

    98

        return value

    99

    elif type_compute == "time":

   100

        result = time_model.match(value)

   101

        if result:

   102

            values = result.groups()

   103

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

   104

            seconds = float(values[2])

   105

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

   106

            return time(*time_values)

   107

        else:

   108

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

   109

    elif type_compute == "date":

   110

        result = date_model.match(value)

   111

        if result:

   112

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

   113

            return date(*date_values)

   114

        else:

   115

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

   116

    elif type_compute == "dateTime":

   117

        result = datetime_model.match(value)

   118

        if result:

   119

            values = result.groups()

   120

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

   121

            seconds = float(values[5])

   122

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

   123

            return datetime(*datetime_values)

   124

        else:

   125

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

   126

    else:

   127

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

   128

        return None

   129

   130

def GetInitialValueFunction(value):

   131

    def GetInitialValue():

   132

        return value

   133

    return GetInitialValue

   134

   135

"""

   136

Class that generate class from an XML Tree 

   137

"""

   138

class ClassFactory:

   139

   140

    def __init__(self, xsd_tree):

   141

        self.XML_Tree = xsd_tree

   142

   143

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

   144

        self.XMLClassDefinitions = {}

   145

   146

        # Dictionaries for stocking Classes and Types generated

   147

        self.ComputedClasses = {}

   148

        self.ComputedTypes = {}

   149

        self.AlreadyComputed = {}

   150

   151

    """

   152

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

   153

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

   154

    """

   155

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

   156

        attributes = {}

   157

        inheritance = []

   158

        if sequence:

   159

            order = []

   160

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

   161

        for node in tree.childNodes:

   162

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

   163

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

   164

                recursion = False

   165

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

   166

   167

                # This tags defines an attribute of the class

   168

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

   169

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

   170

                    default = None

   171

                    if "type" in node._attrs:

   172

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

   173

                        if nodetype.startswith("xsd"):

   174

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

   175

                        elif nodetype.startswith("ppx"):

   176

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

   177

                    else:

   178

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

   179

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

   180

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

   181

                        if parent:

   182

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

   183

                        else:

   184

                            classname = nodename

   185

                        self.GenerateXSDClasses(node, classname)

   186

                        nodetype = "cls:%s"%classname

   187

                    if name == "attribute":

   188

                        if "use" in node._attrs:

   189

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

   190

                        else:

   191

                            use = "optional"

   192

                        if "default" in node._attrs:

   193

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

   194

                    elif name == "element":

   195

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

   196

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

   197

                            nodetype = "%s[]"%nodetype

   198

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

   199

                            use = "optional"

   200

                        else:

   201

                            use = "required"

   202

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

   203

                    if sequence:

   204

                        order.append(nodename)

   205

   206

                # This tag defines a new class

   207

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

   208

                    if "name" in node._attrs:

   209

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

   210

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

   211

                    else:

   212

                        classname = parent

   213

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

   214

                    # When all attributes and inheritances have been extracted, the

   215

                    # values are added in the list of classes to create

   216

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

   217

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

   218

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

   219

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

   220

   221

                # This tag defines an attribute that can have different types

   222

                elif name == "choice":

   223

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

   224

   225

                    choices = {}

   226

                    for attr, values in attrs.items():

   227

                        if attr == "ref":

   228

                            choices[attr] = values

   229

                        else:

   230

                            choices[attr] = values[0]

   231

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

   232

                        attributes["multichoice_content"] = choices

   233

                        if sequence:

   234

                            order.append("multichoice_content")

   235

                    else:

   236

                        attributes["choice_content"] = choices

   237

                        if sequence:

   238

                            order.append("choice_content")

   239

   240

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

   241

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

   242

                elif name in "sequence":

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

                    inheritance.extend(super)

   251

                    attributes.update(attrs)

   252

                    attributes["order"] = order

   253

   254

                # This tag defines of types

   255

                elif name == "group":

   256

                    if "name" in node._attrs:

   257

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

   258

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

   259

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

   260

                    elif "ref" in node._attrs:

   261

                        if "ref" not in attributes:

   262

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

   263

                        else:

   264

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

   265

   266

                # This tag define a base class for the node

   267

                elif name == "extension":

   268

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

   269

                    if super.startswith("xsd"):

   270

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

   271

                    elif super.startswith("ppx"):

   272

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

   273

                    inheritance.append(super[4:])

   274

                    recursion = True

   275

   276

                # This tag defines a restriction on the type of attribute

   277

                elif name == "restriction":

   278

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

   279

                    if basetype.startswith("xsd"):

   280

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

   281

                    elif basetype.startswith("ppx"):

   282

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

   283

                    attributes["basetype"] = basetype

   284

                    recursion = True

   285

   286

                # This tag defines an enumerated type

   287

                elif name == "enumeration":

   288

                    if "enum" not in attributes:

   289

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

   290

                    else:

   291

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

   292

   293

                # This tags defines a restriction on a numerical value

   294

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

   295

                    if "limit" not in attributes:

   296

                        attributes["limit"] = {}

   297

                    if name == "minInclusive":

   298

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

   299

                    elif name == "maxInclusive":

   300

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

   301

   302

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

   303

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

   304

                    recursion = True

   305

   306

                # We make fun of xsd documentation

   307

                elif name in ["annotation"]:

   308

                    pass

   309

   310

                else:

   311

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

   312

                    #print name

   313

                    self.GenerateXSDClasses(node, parent)

   314

   315

                # Parse the childrens of node

   316

                if recursion:

   317

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

   318

                    inheritance.extend(super)

   319

                    attributes.update(attrs)

   320

   321

        # if sequence tag have been found, order is returned

   322

        if sequence:

   323

            return inheritance, attributes, order

   324

        else:

   325

            return inheritance, attributes

   326

   327

    """

   328

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

   329

    """

   330

    def GetTypeInitialValue(self, attr_type, default = None):

   331

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

   332

        if attr_type.startswith("bse:"):

   333

            if type_compute == "boolean":

   334

                if default:

   335

                    def GetBooleanInitialValue():

   336

                        return default == "true"

   337

                    return BooleanType, GetBooleanInitialValue

   338

                else:

   339

                    return BooleanType, lambda:False

   340

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

   341

                if default:

   342

                    def GetIntegerInitialValue():

   343

                        return int(default)

   344

                    return IntType, GetIntegerInitialValue

   345

                else:

   346

                    return IntType, lambda:0

   347

            elif type_compute == "decimal":

   348

                if default:

   349

                    def GetFloatInitialValue():

   350

                        return float(default)

   351

                    return FloatType, GetFloatInitialValue

   352

                else:

   353

                    return FloatType, lambda:0.

   354

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

   355

                if default:

   356

                    def GetStringInitialValue():

   357

                        return default

   358

                    return StringType, GetStringInitialValue

   359

                else:

   360

                    return StringType, lambda:""

   361

            elif type_compute == "time":

   362

                if default:

   363

                    def GetTimeInitialValue():

   364

                        result = time_model.match(value)

   365

                        if result:

   366

                            values = result.groups()

   367

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

   368

                            seconds = float(values[2])

   369

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

   370

                            return time(*time_values)

   371

                        return time(0,0,0,0)

   375

            elif type_compute == "date":

   376

                if default:

   377

                    def GetDateInitialValue():

   378

                        result = date_model.match(value)

   379

                        if result:

   380

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

   381

                            return date(*date_values)

   382

                        return date(1,1,1)

   386

            elif type_compute == "dateTime":

   387

                if default:

   388

                    def GetDateTimeInitialValue():

   389

                        result = datetime_model.match(value)

   390

                        if result:

   391

                            values = result.groups()

   392

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

   393

                            seconds = float(values[5])

   394

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

   395

                            return datetime(*datetime_values)

   396

                        return datetime(1,1,1,0,0,0,0)

   400

            elif type_compute == "language":

   401

                if default:

   402

                    def GetStringInitialValue():

   403

                        return default

   404

                    return StringType, GetStringInitialValue

   405

                else:

   406

                    return StringType, lambda:"en-US"

   407

            else:

   408

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

   409

        elif attr_type.startswith("cls:"):

   410

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

   411

                def GetClassInitialValue():

   412

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

   413

                        obj = self.ComputedClasses[type_compute]()

   414

                        if default:

   415

                            obj.setValue(default)

   416

                        return obj

   417

                    return None

   418

                return self.XMLClassDefinitions[type_compute], GetClassInitialValue

   419

        return None, lambda:None

   420

   421

    """

   422

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

   423

    """

   424

    def GetInitialValues(self, value_types):

   425

        initial_values = {}

   426

        for name, value_type in value_types.items():

   427

            result = self.GetTypeInitialValue(value_type)

   428

            if result:

   429

                initial_values[name] = result[1]

   430

        return initial_values

   431

   432

    """

   433

    Methods that generate the classes

   434

    """

   435

    def CreateClasses(self):

   436

        self.GenerateXSDClasses(self.XML_Tree, None)

   437

        for classname in self.XMLClassDefinitions.keys():

   438

            self.CreateClass(classname)

   439

        for classname in self.XMLClassDefinitions.keys():

   440

            self.MarkUsedClasses(classname)

   441

        return self.ComputedClasses, self.ComputedTypes

   442

   443

    def CreateClass(self, classname):

   444

        # Checks that classe haven't been generated yet

   445

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

   446

            self.AlreadyComputed[classname] = True

   447

            inheritance, attributes = self.XMLClassDefinitions[classname]

   448

            #print classname, inheritance, attributes

   449

            members = {}

   450

            bases = []

   451

   452

            # If inheritance classes haven't been generated

   453

            for base in inheritance:

   454

                self.CreateClass(base)

   455

                bases.append(self.ComputedClasses[base])

   456

   457

            # Checks that all attribute types are available 

   458

            for attribute, type_attribute in attributes.items():

   459

                if attribute == "group":

   460

                    self.ComputedTypes[classname] = type_attribute

   461

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

   462

                    element_types = {}

   463

                    for attr, value in type_attribute.items():

   464

                        if attr == "ref":

   465

                            for ref in value:

   466

                                self.CreateClass(ref[4:])

   467

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

   468

                        else:

   469

                            element_types[attr] = value

   470

                    members[attribute] = element_types

   471

                else:

   472

                    members[attribute] = type_attribute

   473

                    if attribute == "enum":

   474

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

   475

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

   476

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

   477

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

   478

                            self.CreateClass(type_compute)

   479

            if "group" not in attributes:

   480

                bases = tuple(bases)

   481

                classmembers = {"IsBaseClass" : True}

   482

                initialValues = {}

   483

                for attr, values in members.items():

   484

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

   485

                        pass

   486

   487

                    # Class is a enumerated type

   488

                    elif attr == "enum":

   489

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

   490

                        initialValues["value"] = GetInitialValueFunction(values[0])

   491

                        classmembers["value"] = values[0]

   492

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

   493

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

   494

                        classmembers["getValidValues"] = generateGetChoicesMethod(values)

   495

   496

                    # Class is a limited type

   497

                    elif attr == "limit":

   498

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

   499

                        if "min" in values: