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 ["unsignedLong","long","integer"]:

    92

        return int(value)

    93

    elif type_compute == "decimal":

    94

        return float(value)

    95

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

    96

        return value

    97

    elif type_compute == "time":

    98

        result = time_model.match(value)

    99

        if result:

   100

            values = result.groups()

   101

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

   102

            seconds = float(values[2])

   103

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

   104

            return time(*time_values)

   105

        else:

   106

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

   107

    elif type_compute == "date":

   108

        result = date_model.match(value)

   109

        if result:

   110

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

   111

            return date(*date_values)

   112

        else:

   113

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

   114

    elif type_compute == "dateTime":

   115

        result = datetime_model.match(value)

   116

        if result:

   117

            values = result.groups()

   118

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

   119

            seconds = float(values[5])

   120

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

   121

            return datetime(*datetime_values)

   122

        else:

   123

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

   124

    else:

   125

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

   126

        return None

   127

   128

def GetInitialValueFunction(value):

   129

    def GetInitialValue():

   130

        return value

   131

    return GetInitialValue

   132

   133

"""

   134

Class that generate class from an XML Tree 

   135

"""

   136

class ClassFactory:

   137

   138

    def __init__(self, xsd_tree):

   139

        self.XML_Tree = xsd_tree

   140

   141

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

   142

        self.XMLClassDefinitions = {}

   143

   144

        # Dictionaries for stocking Classes and Types generated

   145

        self.ComputedClasses = {}

   146

        self.ComputedTypes = {}

   147

        self.AlreadyComputed = {}

   148

   149

    """

   150

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

   151

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

   152

    """

   153

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

   154

        attributes = {}

   155

        inheritance = []

   156

        if sequence:

   157

            order = []

   158

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

   159

        for node in tree.childNodes:

   160

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

   161

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

   162

                recursion = False

   163

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

   164

   165

                # This tags defines an attribute of the class

   166

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

   167

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

   168

                    default = None

   169

                    if "type" in node._attrs:

   170

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

   171

                        if nodetype.startswith("xsd"):

   172

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

   173

                        elif nodetype.startswith("ppx"):

   174

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

   175

                    else:

   176

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

   177

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

   178

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

   179

                        if parent:

   180

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

   181

                        else:

   182

                            classname = nodename

   183

                        self.GenerateXSDClasses(node, classname)

   184

                        nodetype = "cls:%s"%classname

   185

                    if name == "attribute":

   186

                        if "use" in node._attrs:

   187

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

   188

                        else:

   189

                            use = "optional"

   190

                        if "default" in node._attrs:

   191

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

   192

                    elif name == "element":

   193

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

   194

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

   195

                            nodetype = "%s[]"%nodetype

   196

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

   197

                            use = "optional"

   198

                        else:

   199

                            use = "required"

   200

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

   201

                    if sequence:

   202

                        order.append(nodename)

   203

   204

                # This tag defines a new class

   205

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

   206

                    if "name" in node._attrs:

   207

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

   208

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

   209

                    else:

   210

                        classname = parent

   211

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

   212

                    # When all attributes and inheritances have been extracted, the

   213

                    # values are added in the list of classes to create

   214

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

   215

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

   216

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

   217

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

   218

   219

                # This tag defines an attribute that can have different types

   220

                elif name == "choice":

   221

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

   222

   223

                    choices = {}

   224

                    for attr, values in attrs.items():

   225

                        if attr == "ref":

   226

                            choices[attr] = values

   227

                        else:

   228

                            choices[attr] = values[0]

   229

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

   230

                        attributes["multichoice_content"] = choices

   231

                        if sequence:

   232

                            order.append("multichoice_content")

   233

                    else:

   234

                        attributes["choice_content"] = choices

   235

                        if sequence:

   236

                            order.append("choice_content")

   237

   238

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

   239

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

   240

                elif name in "sequence":

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

                    inheritance.extend(super)

   249

                    attributes.update(attrs)

   250

                    attributes["order"] = order

   251

   252

                # This tag defines of types

   253

                elif name == "group":

   254

                    if "name" in node._attrs:

   255

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

   256

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

   257

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

   258

                    elif "ref" in node._attrs:

   259

                        if "ref" not in attributes:

   260

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

   261

                        else:

   262

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

   263

   264

                # This tag define a base class for the node

   265

                elif name == "extension":

   266

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

   267

                    if super.startswith("xsd"):

   268

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

   269

                    elif super.startswith("ppx"):

   270

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

   271

                    inheritance.append(super[4:])

   272

                    recursion = True

   273

   274

                # This tag defines a restriction on the type of attribute

   275

                elif name == "restriction":

   276

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

   277

                    if basetype.startswith("xsd"):

   278

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

   279

                    elif basetype.startswith("ppx"):

   280

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

   281

                    attributes["basetype"] = basetype

   282

                    recursion = True

   283

   284

                # This tag defines an enumerated type

   285

                elif name == "enumeration":

   286

                    if "enum" not in attributes:

   287

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

   288

                    else:

   289

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

   290

   291

                # This tags defines a restriction on a numerical value

   292

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

   293

                    if "limit" not in attributes:

   294

                        attributes["limit"] = {}

   295

                    if name == "minInclusive":

   296

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

   297

                    elif name == "maxInclusive":

   298

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

   299

   300

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

   301

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

   302

                    recursion = True

   303

   304

                # We make fun of xsd documentation

   305

                elif name in ["annotation"]:

   306

                    pass

   307

   308

                else:

   309

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

   310

                    #print name

   311

                    self.GenerateXSDClasses(node, parent)

   312

   313

                # Parse the childrens of node

   314

                if recursion:

   315

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

   316

                    inheritance.extend(super)

   317

                    attributes.update(attrs)

   318

   319

        # if sequence tag have been found, order is returned

   320

        if sequence:

   321

            return inheritance, attributes, order

   322

        else:

   323

            return inheritance, attributes

   324

   325

    """

   326

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

   327

    """

   328

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

   329

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

   330

        if attr_type.startswith("bse:"):

   331

            if type_compute == "boolean":

   332

                if default:

   333

                    def GetBooleanInitialValue():

   334

                        return default == "true"

   335

                    return BooleanType, GetBooleanInitialValue

   336

                else:

   337

                    return BooleanType, lambda:False

   338

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

   339

                if default:

   340

                    def GetIntegerInitialValue():

   341

                        return int(default)

   342

                    return IntType, GetIntegerInitialValue

   343

                else:

   344

                    return IntType, lambda:0

   345

            elif type_compute == "decimal":

   346

                if default:

   347

                    def GetFloatInitialValue():

   348

                        return float(default)

   349

                    return FloatType, GetFloatInitialValue

   350

                else:

   351

                    return FloatType, lambda:0.

   352

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

   353

                if default:

   354

                    def GetStringInitialValue():

   355

                        return default

   356

                    return StringType, GetStringInitialValue

   357

                else:

   358

                    return StringType, lambda:""

   359

            elif type_compute == "time":

   360

                if default:

   361

                    def GetTimeInitialValue():

   362

                        result = time_model.match(value)

   363

                        if result:

   364

                            values = result.groups()

   365

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

   366

                            seconds = float(values[2])

   367

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

   368

                            return time(*time_values)

   369

                        return time(0,0,0,0)

   370

                    return TimeType, GetTimeInitialValue

   371

                else:

   372

                    return TimeType, lambda:time(0,0,0,0)

   373

            elif type_compute == "date":

   374

                if default:

   375

                    def GetDateInitialValue():

   376

                        result = date_model.match(value)

   377

                        if result:

   378

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

   379

                            return date(*date_values)

   380

                        return date(1,1,1)

   381

                    return DateType, GetDateInitialValue

   382

                else:

   383

                    return DateType, lambda:date(1,1,1)

   384

            elif type_compute == "dateTime":

   385

                if default:

   386

                    def GetDateTimeInitialValue():

   387

                        result = datetime_model.match(value)

   388

                        if result:

   389

                            values = result.groups()

   390

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

   391

                            seconds = float(values[5])

   392

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

   393

                            return datetime(*datetime_values)

   394

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

   395

                    return DateTimeType, GetDateTimeInitialValue

   396

                else:

   397

                    return DateTimeType, lambda:datetime(1,1,1,0,0,0,0)

   398

            elif type_compute == "language":

   399

                if default:

   400

                    def GetStringInitialValue():

   401

                        return default

   402

                    return StringType, GetStringInitialValue

   403

                else:

   404

                    return StringType, lambda:"en-US"

   405

            else:

   406

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

   407

        elif attr_type.startswith("cls:"):

   408

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

   409

                def GetClassInitialValue():

   410

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

   411

                        obj = self.ComputedClasses[type_compute]()

   412

                        if default:

   413

                            obj.setValue(default)

   414

                        return obj

   415

                    return None

   416

                return self.XMLClassDefinitions[type_compute], GetClassInitialValue

   417

        return None, lambda:None

   418

   419

    """

   420

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

   421

    """

   422

    def GetInitialValues(self, value_types):

   423

        initial_values = {}

   424

        for name, value_type in value_types.items():

   425

            result = self.GetTypeInitialValue(value_type)

   426

            if result:

   427

                initial_values[name] = result[1]

   428

        return initial_values

   429

   430

    """

   431

    Methods that generate the classes

   432

    """

   433

    def CreateClasses(self):

   434

        self.GenerateXSDClasses(self.XML_Tree, None)

   435

        for classname in self.XMLClassDefinitions.keys():

   436

            self.CreateClass(classname)

   437

        for classname in self.XMLClassDefinitions.keys():

   438

            self.MarkUsedClasses(classname)

   439

        return self.ComputedClasses, self.ComputedTypes

   440

   441

    def CreateClass(self, classname):

   442

        # Checks that classe haven't been generated yet

   443

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

   444

            self.AlreadyComputed[classname] = True

   445

            inheritance, attributes = self.XMLClassDefinitions[classname]

   446

            #print classname, inheritance, attributes

   447

            members = {}

   448

            bases = []

   449

   450

            # If inheritance classes haven't been generated

   451

            for base in inheritance:

   452

                self.CreateClass(base)

   453

                bases.append(self.ComputedClasses[base])

   454

   455

            # Checks that all attribute types are available 

   456

            for attribute, type_attribute in attributes.items():

   457

                if attribute == "group":

   458

                    self.ComputedTypes[classname] = type_attribute

   459

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

   460

                    element_types = {}

   461

                    for attr, value in type_attribute.items():

   462

                        if attr == "ref":

   463

                            for ref in value:

   464

                                self.CreateClass(ref[4:])

   465

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

   466

                        else:

   467

                            element_types[attr] = value

   468

                    members[attribute] = element_types

   469

                else:

   470

                    members[attribute] = type_attribute

   471

                    if attribute == "enum":

   472

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

   473

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

   474

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

   475

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

   476

                            self.CreateClass(type_compute)

   477

            if "group" not in attributes:

   478

                bases = tuple(bases)

   479

                classmembers = {"IsBaseClass" : True}

   480

                initialValues = {}

   481

                for attr, values in members.items():

   482

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

   483

                        pass

   484

   485

                    # Class is a enumerated type

   486

                    elif attr == "enum":

   487

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

   488

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

   489

                        classmembers["value"] = values[0]

   490

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

   491

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

   492

                        classmembers["getValidValues"] = generateGetChoicesMethod(values)

   493

   494

                    # Class is a limited type

   495

                    elif attr == "limit":

   496

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

   497

                        if "min" in values:

   498

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

   499

                        if "max" in values:

   500