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

    35

date_model = re.compile('([0-9]{4})-([0-9]{2})-([0-9]{2})((?:[\-\+][0-9]{2}:[0-9]{2})|Z)?')

    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]*)?)((?:[\-\+][0-9]{2}:[0-9]{2})|Z)?')

    37

    38

class xml_timezone(tzinfo):

    39

    40

    def SetOffset(self, offset):

    41

        if offset == "Z":

    42

            self.__offset = timedelta(minutes = 0)

    43

            self.__name = "UTC"

    44

        else:

    45

            sign = {"-" : -1, "+" : 1}[offset[0]]

    46

            hours, minutes = [int(val) for val in offset[1:].split(":")]

    47

            self.__offset = timedelta(minutes = sign * (hours * 60 + minutes))

    48

            self.__name = ""

    49

    50

    def utcoffset(self, dt):

    51

        return self.__offset

    52

    53

    def tzname(self, dt):

    54

        return self.__name

    55

    56

    def dst(self, dt):

    57

        return ZERO

    58

    59

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

    60

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

    61

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

    62

    63

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

    64

    65

"""

    66

This function calculates the number of whitespace for indentation

    67

"""

    68

def getIndent(indent, balise):

    69

    first = indent * 2

    70

    second = first + len(balise) + 1

    71

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

    72

    73

"""

    74

Function that extracts data from a node

    75

"""

    76

def GetAttributeValue(attr):

    77

    if len(attr.childNodes) == 1:

    78

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

    79

    else:

    80

        text = ""

    81

        for node in attr.childNodes:

    82

            if node.nodeName != "#text":

    83

                text += node.data.encode()

    84

        return text

    85

    86

"""

    87

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

    88

there is no uppercase in plcopen)

    89

"""

    90

def ComputeValue(value):

    91

    if type(value) == BooleanType:

    92

        if value:

    93

            return "true"

    94

        else:

    95

            return "false"

    96

    else:

    97

        return str(value)

    98

    99

"""

   100

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

   101

"""

   102

def GetComputedValue(attr_type, value):

   103

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

   104

    if type_compute == "boolean":

   105

         if value == "true":

   106

             return True

   107

         elif value == "false":

   108

             return False

   109

         else:

   110

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

   111

    elif type_compute in XSD_INTEGER_TYPES:

   112

        return int(value)

   113

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

   114

        computed_value = float(value)

   115

        if computed_value % 1 == 0:

   116

            return int(computed_value)

   117

        return computed_value

   118

    elif type_compute in XSD_STRING_TYPES:

   119

        return value

   120

    elif type_compute == "time":

   121

        result = time_model.match(value)

   122

        if result:

   123

            values = result.groups()

   124

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

   125

            seconds = float(values[2])

   126

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

   127

            return time(*time_values)

   128

        else:

   129

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

   130

    elif type_compute == "date":

   131

        result = date_model.match(value)

   132

        if result:

   133

            values = result.groups()

   134

            date_values = [int(v) for v in values[:3]]

   135

            if values[3] is not None:

   136

                tz = xml_timezone()

   137

                tz.SetOffset(values[3])

   138

                date_values.append(tz)

   139

            return date(*date_values)

   140

        else:

   141

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

   142

    elif type_compute == "dateTime":

   143

        result = datetime_model.match(value)

   144

        if result:

   145

            values = result.groups()

   146

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

   147

            seconds = float(values[5])

   148

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

   149

            if values[6] is not None:

   150

                tz = xml_timezone()

   151

                tz.SetOffset(values[6])

   152

                datetime_values.append(tz)

   153

            return datetime(*datetime_values)

   154

        else:

   155

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

   156

    else:

   157

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

   158

        return None

   159

   160

def GetInitialValueFunction(value):

   161

    def GetInitialValue():

   162

        return value

   163

    return GetInitialValue

   164

   165

"""

   166

Class that generate class from an XML Tree 

   167

"""

   168

class ClassFactory:

   169

   170

    def __init__(self, xsd_tree):

   171

        self.XML_Tree = xsd_tree

   172

   173

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

   174

        self.XMLClassDefinitions = {}

   175

   176

        # Dictionaries for stocking Classes and Types generated

   177

        self.ComputedClasses = {}

   178

        self.ComputedTypes = {}

   179

        self.AlreadyComputed = {}

   180

   181

    """

   182

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

   183

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

   184

    """

   185

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

   186

        attributes = {}

   187

        inheritance = []

   188

        if sequence:

   189

            order = []

   190

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

   191

        for node in tree.childNodes:

   192

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

   193

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

   194

                recursion = False

   195

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

   196

   197

                # This tags defines an attribute of the class

   198

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

   199

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

   200

                    default = None

   201

                    if "type" in node._attrs:

   202

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

   203

                        if nodetype.startswith("xsd"):

   204

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

   205

                        elif nodetype.startswith("ppx"):

   206

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

   207

                    else:

   208

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

   209

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

   210

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

   211

                        if parent:

   212

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

   213

                        else:

   214

                            classname = nodename

   215

                        if len(node.childNodes) > 0:

   216

                            self.GenerateXSDClasses(node, classname)

   217

                            nodetype = "cls:%s"%classname

   218

                        else:

   219

                            nodetype = classname

   220

                    if name == "attribute":

   221

                        if "use" in node._attrs:

   222

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

   223

                        else:

   224

                            use = "optional"

   225

                        if "default" in node._attrs:

   226

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

   227

                    elif name == "element":

   228

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

   229

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

   230

                            nodetype = "%s[]"%nodetype

   231

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

   232

                            use = "optional"

   233

                        else:

   234

                            use = "required"

   235

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

   236

                    if sequence:

   237

                        order.append(nodename)

   238

   239

                # This tag defines a new class

   240

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

   241

                    if "name" in node._attrs:

   242

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

   243

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

   244

                    else:

   245

                        classname = parent

   246

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

   247

                    # When all attributes and inheritances have been extracted, the

   248

                    # values are added in the list of classes to create

   249

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

   250

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

   251

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

   252

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

   253

   254

                # This tag defines an attribute that can have different types

   255

                elif name == "choice":

   256

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

   257

   258

                    choices = {}

   259

                    for attr, values in attrs.items():

   260

                        if attr == "ref":

   261

                            choices[attr] = values

   262

                        else:

   263

                            choices[attr] = values[0]

   264

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

   265

                        attributes["multichoice_content"] = choices

   266

                        if sequence:

   267

                            order.append("multichoice_content")

   268

                    else:

   269

                        attributes["choice_content"] = choices

   270

                        if sequence:

   271

                            order.append("choice_content")

   272

   273

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

   274

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

   275

                elif name in "sequence":

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

                    inheritance.extend(super)

   284

                    attributes.update(attrs)

   285

                    attributes["order"] = order

   286

   287

                # This tag defines of types

   288

                elif name == "group":

   289

                    if "name" in node._attrs:

   290

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

   291

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

   292

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

   293

                    elif "ref" in node._attrs:

   294

                        if "ref" not in attributes:

   295

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

   296

                        else:

   297

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

   298

   299

                # This tag define a base class for the node

   300

                elif name == "extension":

   301

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

   302

                    if super.startswith("xsd"):

   303

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

   304

                    elif super.startswith("ppx"):

   305

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

   306

                    inheritance.append(super[4:])

   307

                    recursion = True

   308

   309

                # This tag defines a restriction on the type of attribute

   310

                elif name == "restriction":

   311

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

   312

                    if basetype.startswith("xsd"):

   313

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

   314

                    elif basetype.startswith("ppx"):

   315

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

   316

                    attributes["basetype"] = basetype

   317

                    recursion = True

   318

   319

                # This tag defines an enumerated type

   320

                elif name == "enumeration":

   321

                    if "enum" not in attributes:

   322

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

   323

                    else:

   324

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

   325

   326

                # This tags defines a restriction on a numerical value

   327

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

   328

                    if "limit" not in attributes:

   329

                        attributes["limit"] = {}

   330

                    if name == "minInclusive":

   331

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

   332

                    elif name == "maxInclusive":

   333

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

   334

   335

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

   336

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

   337

                    recursion = True

   338

   339

                # We make fun of xsd documentation

   340

                elif name in ["annotation"]:

   341

                    pass

   342

   343

                else:

   344

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

   345

                    #print name

   346

                    self.GenerateXSDClasses(node, parent)

   347

   348

                # Parse the childrens of node

   349

                if recursion:

   350

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

   351

                    inheritance.extend(super)

   352

                    attributes.update(attrs)

   353

   354

        # if sequence tag have been found, order is returned

   355

        if sequence:

   356

            return inheritance, attributes, order

   357

        else:

   358

            return inheritance, attributes

   359

   360

    """

   361

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

   362

    """

   363

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

   364

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

   365

        if attr_type.startswith("bse:"):

   366

            if type_compute == "boolean":

   367

                if default:

   368

                    def GetBooleanInitialValue():

   369

                        return default == "true"

   370

                    return BooleanType, GetBooleanInitialValue

   371

                else:

   372

                    return BooleanType, lambda:False

   373

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

   374

                if default:

   375

                    def GetIntegerInitialValue():

   376

                        return int(default)

   377

                    return IntType, GetIntegerInitialValue

   378

                else:

   379

                    return IntType, lambda:0

   380

            elif type_compute == "decimal":

   381

                if default:

   382

                    def GetFloatInitialValue():

   383

                        return float(default)

   384

                    return FloatType, GetFloatInitialValue

   385

                else:

   386

                    return FloatType, lambda:0.

   387

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

   388

                if default:

   389

                    def GetStringInitialValue():

   390

                        return default

   391

                    return StringType, GetStringInitialValue

   392

                else:

   393

                    return StringType, lambda:""

   394

            elif type_compute == "time":

   395

                if default:

   396

                    def GetTimeInitialValue():

   397

                        result = time_model.match(value)

   398

                        if result:

   399

                            values = result.groups()

   400

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

   401

                            seconds = float(values[2])

   402

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

   403

                            return time(*time_values)

   404

                        return time(0,0,0,0)

   405

                    return time, GetTimeInitialValue

   406

                else:

   407

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

   408

            elif type_compute == "date":

   409

                if default:

   410

                    def GetDateInitialValue():

   411

                        result = date_model.match(value)

   412

                        if result:

   413

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

   414

                            return date(*date_values)

   415

                        return date(1,1,1)

   416

                    return date, GetDateInitialValue

   417

                else:

   418

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

   419

            elif type_compute == "dateTime":

   420

                if default:

   421

                    def GetDateTimeInitialValue():

   422

                        result = datetime_model.match(value)

   423

                        if result:

   424

                            values = result.groups()

   425

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

   426

                            seconds = float(values[5])

   427

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

   428

                            return datetime(*datetime_values)

   429

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

   430

                    return datetime, GetDateTimeInitialValue

   431

                else:

   432

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

   433

            elif type_compute == "language":

   434

                if default:

   435

                    def GetStringInitialValue():

   436

                        return default

   437

                    return StringType, GetStringInitialValue

   438

                else:

   439

                    return StringType, lambda:"en-US"

   440

            else:

   441

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

   442

        elif attr_type.startswith("cls:"):

   443

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

   444

                def GetClassInitialValue():

   445

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

   446

                        obj = self.ComputedClasses[type_compute]()

   447

                        if default:

   448

                            obj.setValue(default)

   449

                        return obj

   450

                    return None

   451

                return self.XMLClassDefinitions[type_compute], GetClassInitialValue

   452

        return None, lambda:None

   453

   454

    """

   455

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

   456

    """

   457

    def GetInitialValues(self, value_types):

   458

        initial_values = {}

   459

        for name, value_type in value_types.items():

   460

            result = self.GetTypeInitialValue(value_type)

   461

            if result:

   462

                initial_values[name] = result[1]

   463

        return initial_values

   464

   465

    """

   466

    Methods that generate the classes

   467

    """

   468

    def CreateClasses(self):

   469

        self.GenerateXSDClasses(self.XML_Tree, None)

   470

        for classname in self.XMLClassDefinitions.keys():

   471

            self.CreateClass(classname)

   472

        for classname in self.XMLClassDefinitions.keys():

   473

            self.MarkUsedClasses(classname)

   474

        return self.ComputedClasses, self.ComputedTypes

   475

   476

    def CreateClass(self, classname):

   477

        # Checks that classe haven't been generated yet

   478

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

   479

            self.AlreadyComputed[classname] = True

   480

            inheritance, attributes = self.XMLClassDefinitions[classname]

   481

            #print classname, inheritance, attributes

   482

            members = {}

   483

            bases = []

   484

   485

            # If inheritance classes haven't been generated

   486

            for base in inheritance:

   487

                self.CreateClass(base)

   488

                bases.append(self.ComputedClasses[base])

   489

   490

            # Checks that all attribute types are available 

   491

            for attribute, type_attribute in attributes.items():

   492

                if attribute == "group":

   493

                    self.ComputedTypes[classname] = type_attribute

   494

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

   495

                    element_types = {}

   496

                    for attr, value in type_attribute.items():

   497

                        if attr == "ref":

   498

                            for ref in value:

   499