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

        computed_value = float(value)

    95

        if computed_value % 1 == 0:

    96

            return int(computed_value)

    97

        return computed_value

    98

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

    99

        return value

   100

    elif type_compute == "time":

   101

        result = time_model.match(value)

   102

        if result:

   103

            values = result.groups()

   104

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

   105

            seconds = float(values[2])

   106

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

   107

            return time(*time_values)

   108

        else:

   109

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

   110

    elif type_compute == "date":

   111

        result = date_model.match(value)

   112

        if result:

   113

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

   114

            return date(*date_values)

   115

        else:

   116

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

   117

    elif type_compute == "dateTime":

   118

        result = datetime_model.match(value)

   119

        if result:

   120

            values = result.groups()

   121

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

   122

            seconds = float(values[5])

   123

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

   124

            return datetime(*datetime_values)

   125

        else:

   126

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

   127

    else:

   128

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

   129

        return None

   130

   131

def GetInitialValueFunction(value):

   132

    def GetInitialValue():

   133

        return value

   134

    return GetInitialValue

   135

   136

"""

   137

Class that generate class from an XML Tree 

   138

"""

   139

class ClassFactory:

   140

   141

    def __init__(self, xsd_tree):

   142

        self.XML_Tree = xsd_tree

   143

   144

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

   145

        self.XMLClassDefinitions = {}

   146

   147

        # Dictionaries for stocking Classes and Types generated

   148

        self.ComputedClasses = {}

   149

        self.ComputedTypes = {}

   150

        self.AlreadyComputed = {}

   151

   152

    """

   153

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

   154

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

   155

    """

   156

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

   157

        attributes = {}

   158

        inheritance = []

   159

        if sequence:

   160

            order = []

   161

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

   162

        for node in tree.childNodes:

   163

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

   164

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

   165

                recursion = False

   166

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

   167

   168

                # This tags defines an attribute of the class

   169

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

   170

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

   171

                    default = None

   172

                    if "type" in node._attrs:

   173

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

   174

                        if nodetype.startswith("xsd"):

   175

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

   176

                        elif nodetype.startswith("ppx"):

   177

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

   178

                    else:

   179

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

   180

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

   181

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

   182

                        if parent:

   183

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

   184

                        else:

   185

                            classname = nodename

   186

                        self.GenerateXSDClasses(node, classname)

   187

                        nodetype = "cls:%s"%classname

   188

                    if name == "attribute":

   189

                        if "use" in node._attrs:

   190

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

   191

                        else:

   192

                            use = "optional"

   193

                        if "default" in node._attrs:

   194

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

   195

                    elif name == "element":

   196

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

   197

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

   198

                            nodetype = "%s[]"%nodetype

   199

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

   200

                            use = "optional"

   201

                        else:

   202

                            use = "required"

   203

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

   204

                    if sequence:

   205

                        order.append(nodename)

   206

   207

                # This tag defines a new class

   208

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

   209

                    if "name" in node._attrs:

   210

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

   211

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

   212

                    else:

   213

                        classname = parent

   214

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

   215

                    # When all attributes and inheritances have been extracted, the

   216

                    # values are added in the list of classes to create

   217

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

   218

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

   219

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

   220

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

   221

   222

                # This tag defines an attribute that can have different types

   223

                elif name == "choice":

   224

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

   225

   226

                    choices = {}

   227

                    for attr, values in attrs.items():

   228

                        if attr == "ref":

   229

                            choices[attr] = values

   230

                        else:

   231

                            choices[attr] = values[0]

   232

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

   233

                        attributes["multichoice_content"] = choices

   234

                        if sequence:

   235

                            order.append("multichoice_content")

   236

                    else:

   237

                        attributes["choice_content"] = choices

   238

                        if sequence:

   239

                            order.append("choice_content")

   240

   241

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

   242

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

   243

                elif name in "sequence":

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

                    inheritance.extend(super)

   252

                    attributes.update(attrs)

   253

                    attributes["order"] = order

   254

   255

                # This tag defines of types

   256

                elif name == "group":

   257

                    if "name" in node._attrs:

   258

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

   259

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

   260

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

   261

                    elif "ref" in node._attrs:

   262

                        if "ref" not in attributes:

   263

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

   264

                        else:

   265

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

   266

   267

                # This tag define a base class for the node

   268

                elif name == "extension":

   269

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

   270

                    if super.startswith("xsd"):

   271

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

   272

                    elif super.startswith("ppx"):

   273

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

   274

                    inheritance.append(super[4:])

   275

                    recursion = True

   276

   277

                # This tag defines a restriction on the type of attribute

   278

                elif name == "restriction":

   279

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

   280

                    if basetype.startswith("xsd"):

   281

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

   282

                    elif basetype.startswith("ppx"):

   283

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

   284

                    attributes["basetype"] = basetype

   285

                    recursion = True

   286

   287

                # This tag defines an enumerated type

   288

                elif name == "enumeration":

   289

                    if "enum" not in attributes:

   290

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

   291

                    else:

   292

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

   293

   294

                # This tags defines a restriction on a numerical value

   295

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

   296

                    if "limit" not in attributes:

   297

                        attributes["limit"] = {}

   298

                    if name == "minInclusive":

   299

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

   300

                    elif name == "maxInclusive":

   301

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

   302

   303

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

   304

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

   305

                    recursion = True

   306

   307

                # We make fun of xsd documentation

   308

                elif name in ["annotation"]:

   309

                    pass

   310

   311

                else:

   312

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

   313

                    #print name

   314

                    self.GenerateXSDClasses(node, parent)

   315

   316

                # Parse the childrens of node

   317

                if recursion:

   318

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

   319

                    inheritance.extend(super)

   320

                    attributes.update(attrs)

   321

   322

        # if sequence tag have been found, order is returned

   323

        if sequence:

   324

            return inheritance, attributes, order

   325

        else:

   326

            return inheritance, attributes

   327

   328

    """

   329

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

   330

    """

   331

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

   332

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

   333

        if attr_type.startswith("bse:"):

   334

            if type_compute == "boolean":

   335

                if default:

   336

                    def GetBooleanInitialValue():

   337

                        return default == "true"

   338

                    return BooleanType, GetBooleanInitialValue

   339

                else:

   340

                    return BooleanType, lambda:False

   341

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

   342

                if default:

   343

                    def GetIntegerInitialValue():

   344

                        return int(default)

   345

                    return IntType, GetIntegerInitialValue

   346

                else:

   347

                    return IntType, lambda:0

   348

            elif type_compute == "decimal":

   349

                if default:

   350

                    def GetFloatInitialValue():

   351

                        return float(default)

   352

                    return FloatType, GetFloatInitialValue

   353

                else:

   354

                    return FloatType, lambda:0.

   355

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

   356

                if default:

   357

                    def GetStringInitialValue():

   358

                        return default

   359

                    return StringType, GetStringInitialValue

   360

                else:

   361

                    return StringType, lambda:""

   362

            elif type_compute == "time":

   363

                if default:

   364

                    def GetTimeInitialValue():

   365

                        result = time_model.match(value)

   366

                        if result:

   367

                            values = result.groups()

   368

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

   369

                            seconds = float(values[2])

   370

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

   371

                            return time(*time_values)

   372

                        return time(0,0,0,0)

   373

                    return TimeType, GetTimeInitialValue

   374

                else:

   375

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

   376

            elif type_compute == "date":

   377

                if default:

   378

                    def GetDateInitialValue():

   379

                        result = date_model.match(value)

   380

                        if result:

   381

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

   382

                            return date(*date_values)

   383

                        return date(1,1,1)

   384

                    return DateType, GetDateInitialValue

   385

                else:

   386

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

   387

            elif type_compute == "dateTime":

   388

                if default:

   389

                    def GetDateTimeInitialValue():

   390

                        result = datetime_model.match(value)

   391

                        if result:

   392

                            values = result.groups()

   393

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

   394

                            seconds = float(values[5])

   395

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

   396

                            return datetime(*datetime_values)

   397

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

   398

                    return DateTimeType, GetDateTimeInitialValue

   399

                else:

   400

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

   401

            elif type_compute == "language":

   402

                if default:

   403

                    def GetStringInitialValue():

   404

                        return default

   405

                    return StringType, GetStringInitialValue

   406

                else:

   407

                    return StringType, lambda:"en-US"

   408

            else:

   409

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

   410

        elif attr_type.startswith("cls:"):

   411

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

   412

                def GetClassInitialValue():

   413

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

   414

                        obj = self.ComputedClasses[type_compute]()

   415

                        if default:

   416

                            obj.setValue(default)

   417

                        return obj

   418

                    return None

   419

                return self.XMLClassDefinitions[type_compute], GetClassInitialValue

   420

        return None, lambda:None

   421

   422

    """

   423

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

   424

    """

   425

    def GetInitialValues(self, value_types):

   426

        initial_values = {}

   427

        for name, value_type in value_types.items():

   428

            result = self.GetTypeInitialValue(value_type)

   429

            if result:

   430

                initial_values[name] = result[1]

   431

        return initial_values

   432

   433

    """

   434

    Methods that generate the classes

   435

    """

   436

    def CreateClasses(self):

   437

        self.GenerateXSDClasses(self.XML_Tree, None)

   438

        for classname in self.XMLClassDefinitions.keys():

   439

            self.CreateClass(classname)

   440

        for classname in self.XMLClassDefinitions.keys():

   441

            self.MarkUsedClasses(classname)

   442

        return self.ComputedClasses, self.ComputedTypes

   443

   444

    def CreateClass(self, classname):

   445

        # Checks that classe haven't been generated yet

   446

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

   447

            self.AlreadyComputed[classname] = True

   448

            inheritance, attributes = self.XMLClassDefinitions[classname]

   449

            #print classname, inheritance, attributes

   450

            members = {}

   451

            bases = []

   452

   453

            # If inheritance classes haven't been generated

   454

            for base in inheritance:

   455

                self.CreateClass(base)

   456

                bases.append(self.ComputedClasses[base])

   457

   458

            # Checks that all attribute types are available 

   459

            for attribute, type_attribute in attributes.items():

   460

                if attribute == "group":

   461

                    self.ComputedTypes[classname] = type_attribute

   462

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

   463

                    element_types = {}

   464

                    for attr, value in type_attribute.items():

   465

                        if attr == "ref":

   466

                            for ref in value:

   467

                                self.CreateClass(ref[4:])

   468

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

   469

                        else:

   470

                            element_types[attr] = value

   471

                    members[attribute] = element_types

   472

                else:

   473

                    members[attribute] = type_attribute

   474

                    if attribute == "enum":

   475

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

   476

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

   477

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

   478

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

   479

                            self.CreateClass(type_compute)

   480

            if "group" not in attributes:

   481

                bases = tuple(bases)

   482

                classmembers = {"IsBaseClass" : True}

   483

                initialValues = {}

   484

                for attr, values in members.items():

   485

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

   486

                        pass

   487

   488

                    # Class is a enumerated type

   489

                    elif attr == "enum":

   490

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

   491

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

   492

                        classmembers["value"] = values[0]

   493

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

   494

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

   495

                        classmembers["getValidValues"] = generateGetChoicesMethod(values)

   496

   497

                    # Class is a limited type

   498

                    elif attr == "limit":

   499

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

   500