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

"""

    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:

   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)])

   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

                        self.GenerateXSDClasses(node, classname)

   216

                        nodetype = "cls:%s"%classname

   217

                    if name == "attribute":

   218

                        if "use" in node._attrs:

   219

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

   220

                        else:

   221

                            use = "optional"

   222

                        if "default" in node._attrs:

   223

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

   224

                    elif name == "element":

   225

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

   226

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

   227

                            nodetype = "%s[]"%nodetype

   228

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

   229

                            use = "optional"

   230

                        else:

   231

                            use = "required"

   232

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

   233

                    if sequence:

   234

                        order.append(nodename)

   235

   236

                # This tag defines a new class

   237

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

   238

                    if "name" in node._attrs:

   239

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

   240

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

   241

                    else:

   242

                        classname = parent

   243

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

   244

                    # When all attributes and inheritances have been extracted, the

   245

                    # values are added in the list of classes to create

   246

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

   247

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

   248

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

   249

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

   250

   251

                # This tag defines an attribute that can have different types

   252

                elif name == "choice":

   253

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

   254

   255

                    choices = {}

   256

                    for attr, values in attrs.items():

   257

                        if attr == "ref":

   258

                            choices[attr] = values

   259

                        else:

   260

                            choices[attr] = values[0]

   261

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

   262

                        attributes["multichoice_content"] = choices

   263

                        if sequence:

   264

                            order.append("multichoice_content")

   265

                    else:

   266

                        attributes["choice_content"] = choices

   267

                        if sequence:

   268

                            order.append("choice_content")

   269

   270

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

   271

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

   272

                elif name in "sequence":

   273

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

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

                    inheritance.extend(super)

   281

                    attributes.update(attrs)

   282

                    attributes["order"] = order

   283

   284

                # This tag defines of types

   285

                elif name == "group":

   286

                    if "name" in node._attrs:

   287

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

   288

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

   289

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

   290

                    elif "ref" in node._attrs:

   291

                        if "ref" not in attributes:

   292

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

   293

                        else:

   294

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

   295

   296

                # This tag define a base class for the node

   297

                elif name == "extension":

   298

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

   299

                    if super.startswith("xsd"):

   300

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

   301

                    elif super.startswith("ppx"):

   302

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

   303

                    inheritance.append(super[4:])

   304

                    recursion = True

   305

   306

                # This tag defines a restriction on the type of attribute

   307

                elif name == "restriction":

   308

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

   309

                    if basetype.startswith("xsd"):

   310

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

   311

                    elif basetype.startswith("ppx"):

   312

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

   313

                    attributes["basetype"] = basetype

   314

                    recursion = True

   315

   316

                # This tag defines an enumerated type

   317

                elif name == "enumeration":

   318

                    if "enum" not in attributes:

   319

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

   320

                    else:

   321

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

   322

   323

                # This tags defines a restriction on a numerical value

   324

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

   325

                    if "limit" not in attributes:

   326

                        attributes["limit"] = {}

   327

                    if name == "minInclusive":

   328

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

   329

                    elif name == "maxInclusive":

   330

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

   331

   332

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

   333

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

   334

                    recursion = True

   335

   336

                # We make fun of xsd documentation

   337

                elif name in ["annotation"]:

   338

                    pass

   339

   340

                else:

   341

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

   342

                    #print name

   343

                    self.GenerateXSDClasses(node, parent)

   344

   345

                # Parse the childrens of node

   346

                if recursion:

   347

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

   348

                    inheritance.extend(super)

   349

                    attributes.update(attrs)

   350

   351

        # if sequence tag have been found, order is returned

   352

        if sequence:

   353

            return inheritance, attributes, order

   354

        else:

   355

            return inheritance, attributes

   356

   357

    """

   358

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

   359

    """

   360

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

   361

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

   362

        if attr_type.startswith("bse:"):

   363

            if type_compute == "boolean":

   364

                if default:

   365

                    def GetBooleanInitialValue():

   366

                        return default == "true"

   367

                    return BooleanType, GetBooleanInitialValue

   368

                else:

   369

                    return BooleanType, lambda:False

   370

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

   371

                if default:

   372

                    def GetIntegerInitialValue():

   373

                        return int(default)

   374

                    return IntType, GetIntegerInitialValue

   375

                else:

   376

                    return IntType, lambda:0

   377

            elif type_compute == "decimal":

   378

                if default:

   379

                    def GetFloatInitialValue():

   380

                        return float(default)

   381

                    return FloatType, GetFloatInitialValue

   382

                else:

   383

                    return FloatType, lambda:0.

   384

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

   385

                if default:

   386

                    def GetStringInitialValue():

   387

                        return default

   388

                    return StringType, GetStringInitialValue

   389

                else:

   390

                    return StringType, lambda:""

   391

            elif type_compute == "time":

   392

                if default:

   393

                    def GetTimeInitialValue():

   394

                        result = time_model.match(value)

   395

                        if result:

   396

                            values = result.groups()

   397

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

   398

                            seconds = float(values[2])

   399

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

   400

                            return time(*time_values)

   401

                        return time(0,0,0,0)

   402

                    return time, GetTimeInitialValue

   403

                else:

   404

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

   405

            elif type_compute == "date":

   406

                if default:

   407

                    def GetDateInitialValue():

   408

                        result = date_model.match(value)

   409

                        if result:

   410

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

   411

                            return date(*date_values)

   412

                        return date(1,1,1)

   413

                    return date, GetDateInitialValue

   414

                else:

   415

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

   416

            elif type_compute == "dateTime":

   417

                if default:

   418

                    def GetDateTimeInitialValue():

   419

                        result = datetime_model.match(value)

   420

                        if result:

   421

                            values = result.groups()

   422

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

   423

                            seconds = float(values[5])

   424

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

   425

                            return datetime(*datetime_values)

   426

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

   427

                    return datetime, GetDateTimeInitialValue

   428

                else:

   429

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

   430

            elif type_compute == "language":

   431

                if default:

   432

                    def GetStringInitialValue():

   433

                        return default

   434

                    return StringType, GetStringInitialValue

   435

                else:

   436

                    return StringType, lambda:"en-US"

   437

            else:

   438

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

   439

        elif attr_type.startswith("cls:"):

   440

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

   441

                def GetClassInitialValue():

   442

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

   443

                        obj = self.ComputedClasses[type_compute]()

   444

                        if default:

   445

                            obj.setValue(default)

   446

                        return obj

   447

                    return None

   448

                return self.XMLClassDefinitions[type_compute], GetClassInitialValue

   449

        return None, lambda:None

   450

   451

    """

   452

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

   453

    """

   454

    def GetInitialValues(self, value_types):

   455

        initial_values = {}

   456

        for name, value_type in value_types.items():

   457

            result = self.GetTypeInitialValue(value_type)

   458

            if result:

   459

                initial_values[name] = result[1]

   460

        return initial_values

   461

   462

    """

   463

    Methods that generate the classes

   464

    """

   465

    def CreateClasses(self):

   466

        self.GenerateXSDClasses(self.XML_Tree, None)

   467

        for classname in self.XMLClassDefinitions.keys():

   468

            self.CreateClass(classname)

   469

        for classname in self.XMLClassDefinitions.keys():

   470

            self.MarkUsedClasses(classname)

   471

        return self.ComputedClasses, self.ComputedTypes

   472

   473

    def CreateClass(self, classname):

   474

        # Checks that classe haven't been generated yet

   475

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

   476

            self.AlreadyComputed[classname] = True

   477

            inheritance, attributes = self.XMLClassDefinitions[classname]

   478

            #print classname, inheritance, attributes

   479

            members = {}

   480

            bases = []

   481

   482

            # If inheritance classes haven't been generated

   483

            for base in inheritance:

   484

                self.CreateClass(base)

   485

                bases.append(self.ComputedClasses[base])

   486

   487

            # Checks that all attribute types are available 

   488

            for attribute, type_attribute in attributes.items():

   489

                if attribute == "group":

   490

                    self.ComputedTypes[classname] = type_attribute

   491

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

   492

                    element_types = {}

   493

                    for attr, value in type_attribute.items():

   494

                        if attr == "ref":

   495

                            for ref in value:

   496

                                self.CreateClass(ref[4:])

   497

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

   498

                        else:

   499

                            element_types[attr] = value