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): 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 Lesser 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

#Lesser General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU Lesser 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.parsers import expat

    26

from minixsv import pyxsval

    27

from random import *

    28

    29

from types import *

    30

from datetime import *

    31

    32

import sys,re

    33

    34

classes = {}

    35

TimeType = time(0,0,0).__class__

    36

DateType = date(1,1,1).__class__

    37

DateTimeType = datetime(1,1,1,0,0,0).__class__

    38

    39

"""

    40

Dictionary that makes the relation between var names in plcopen and displayed values

    41

"""

    42

VarTypes = {"Local" : "localVars", "Temp" : "tempVars", "Input" : "inputVars",

    43

            "Output" : "outputVars", "InOut" : "inOutVars", "External" : "externalVars",

    44

            "Global" : "globalVars", "Access" : "accessVars"}

    45

    46

"""

    47

Define in which order var types must be displayed

    48

"""

    49

VarOrder = ["Local","Temp","Input","Output","InOut","External","Global","Access"]

    50

    51

"""

    52

Regular expression models for extracting dates and times from a string

    53

"""

    54

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

    55

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

    56

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

    57

    58

"""

    59

Define which action qualifier must be associated with a duration 

    60

"""

    61

QualifierList = {"N" : False, "R" : False, "S" : False, "L" : True, "D" : True, 

    62

    "P" : False, "P0" : False, "P1" : False, "SD" : True, "DS" : True, "SL" : True}

    63

    64

"""

    65

pyxsval is not complete and the parts that are not supported print some error

    66

reports. This class is used for not displaying them

    67

"""

    68

class HolePseudoFile:

    69

    """ Base class for file like objects to facilitate StdOut for the Shell."""

    70

    def __init__(self, output = None):

    71

        if output is None: output = []

    72

        self.output = output

    73

    74

    def writelines(self, l):

    75

        map(self.write, l)

    76

    77

    def write(self, s):

    78

        pass

    79

    80

    def flush(self):

    81

        pass

    82

    83

    def isatty(self):

    84

        return false

    85

    86

"""

    87

This function calculates the number of whitespace for indentation

    88

"""

    89

def getIndent(indent, balise):

    90

    first = indent * 2

    91

    second = first + len(balise) + 1

    92

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

    93

    94

"""

    95

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

    96

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

    97

"""

    98

def Generate_classes(tree, parent, sequence = False):

    99

    attributes = {}

   100

    inheritance = []

   101

    if sequence:

   102

        order = []

   103

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

   104

    for node in tree.childNodes:

   105

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

   106

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

   107

            recursion = False

   108

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

   109

   110

            # This tags defines an attribute of the class

   111

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

   112

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

   113

                if "type" in node._attrs:

   114

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

   115

                else:

   116

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

   117

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

   118

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

   119

                    if parent:

   120

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

   121

                    else:

   122

                        classname = nodename

   123

                    Generate_classes(node, classname)

   124

                    nodetype = "ppx:%s"%classname

   125

                if name == "attribute":

   126

                    if "use" in node._attrs:

   127

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

   128

                    else:

   129

                        use = "optional"

   130

                if name == "element":

   131

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

   132

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

   133

                        nodetype = "%s[]"%nodetype

   134

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

   135

                        use = "optional"

   136

                    else:

   137

                        use = "required"

   138

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

   139

                if sequence:

   140

                    order.append(nodename)

   141

   142

            # This tag defines a new class

   143

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

   144

                if "name" in node._attrs:

   145

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

   146

                    super, attrs = Generate_classes(node, classname)

   147

                else:

   148

                    classname = parent

   149

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

   150

                # When all attributes and inheritances have been extracted, the

   151

                # values are added in the list of classes to create

   152

                if classname not in classes:

   153

                    classes[classname] = (super, attrs)

   154

                elif classes[classname] != (super, attrs):

   155

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

   156

   157

            # This tag defines an attribute that can have different types

   158

            elif name == "choice":

   159

                super, attrs = Generate_classes(node, parent)

   160

                if "ref" in attrs.keys():

   161

                    choices = attrs

   162

                else:

   163

                    choices = {}

   164

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

   165

                        choices[attr] = attr_type

   166

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

   167

                    attributes["multichoice_content"] = choices

   168

                    if sequence:

   169

                        order.append("multichoice_content")

   170

                else:

   171

                    attributes["choice_content"] = choices

   172

                    if sequence:

   173

                        order.append("choice_content")

   174

   175

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

   176

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

   177

            elif name in "sequence":

   178

                super, attrs, order = Generate_classes(node, parent, True)

   179

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

   180

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

   181

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

   182

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

   183

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

   184

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

   185

                inheritance.extend(super)

   186

                attributes.update(attrs)

   187

                attributes["order"] = order

   188

   189

            # This tag defines of types

   190

            elif name == "group":

   191

                if "name" in node._attrs:

   192

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

   193

                    super, attrs = Generate_classes(node, None)

   194

                    classes[nodename] = (super, {"group":attrs["choice_content"]})

   195

                elif "ref" in node._attrs:

   196

                    if "ref" not in attributes:

   197

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

   198

                    else:

   199

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

   200

   201

            # This tag define a base class for the node

   202

            elif name == "extension":

   203

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

   204

                inheritance.append(super[4:])

   205

                recursion = True

   206

   207

            # This tag defines a restriction on the type of attribute

   208

            elif name == "restriction":

   209

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

   210

                recursion = True

   211

   212

            # This tag defines an enumerated type

   213

            elif name == "enumeration":

   214

                if "enum" not in attributes:

   215

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

   216

                else:

   217

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

   218

   219

            # This tags defines a restriction on a numerical value

   220

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

   221

                if "limit" not in attributes:

   222

                    attributes["limit"] = {}

   223

                if name == "minInclusive":

   224

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

   225

                elif name == "maxInclusive":

   226

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

   227

   228

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

   229

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

   230

                recursion = True

   231

   232

            # We make fun of xsd documentation

   233

            elif name in ["annotation"]:

   234

                pass

   235

   236

            else:

   237

                #print name

   238

                Generate_classes(node, parent)

   239

   240

            # Parse the childrens of node

   241

            if recursion:

   242

                super, attrs = Generate_classes(node, parent)

   243

                inheritance.extend(super)

   244

                attributes.update(attrs)

   245

   246

    # if sequence tag have been found, order is returned

   247

    if sequence:

   248

        return inheritance, attributes, order

   249

    else:

   250

        return inheritance, attributes

   251

"""

   252

Function that extracts data from a node

   253

"""

   254

def GetAttributeValue(attr):

   255

    if len(attr.childNodes) == 1:

   256

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

   257

    else:

   258

        return ""

   259

   260

"""

   261

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

   262

"""

   263

def GetTypeInitialValue(attr_type):

   264

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

   265

    if attr_type.startswith("xsd:"):

   266

        if type_compute == "boolean":

   267

            return BooleanType, "False"

   268

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

   269

            return IntType, "0"

   270

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

   271

            return StringType, "\"\""

   272

        elif type_compute == "time":

   273

            return TimeType, "time(0,0,0)"

   274

        elif type_compute == "date":

   275

            return DateType, "date(1,1,1)"

   276

        elif type_compute == "dateTime":

   277

            return DateTimeType, "datetime(1,1,1,0,0,0)"

   278

        elif type_compute == "language":

   279

            return StringType, "\"en-US\""

   280

        else:

   281

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

   282

    elif attr_type.startswith("ppx:"):

   283

        if type_compute in PLCOpenClasses:

   284

            return PLCOpenClasses[type_compute],"%s()"%type_compute

   285

   286

"""

   287

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

   288

there is no uppercase in plcopen)

   289

"""

   290

def ComputeValue(value):

   291

    if type(value) == BooleanType:

   292

        if value:

   293

            return "true"

   294

        else:

   295

            return "false"

   296

    else:

   297

        return str(value)

   298

   299

"""

   300

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

   301

"""

   302

def GetComputedValue(attr_type, value):

   303

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

   304

    if type_compute == "boolean":

   305

         if value == "true":

   306

             return True

   307

         elif value == "false":

   308

             return False

   309

         else:

   310

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

   311

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

   312

        return int(value)

   313

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

   314

        return value

   315

    elif type_compute == "time":

   316

        result = time_model.match(value)

   317

        if result:

   318

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

   319

            return time(*time_values)

   320

        else:

   321

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

   322

    elif type_compute == "date":

   323

        result = date_model.match(value)

   324

        if result:

   325

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

   326

            return date(*date_values)

   327

        else:

   328

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

   329

    elif type_compute == "dateTime":

   330

        result = datetime_model.match(value)

   331

        if result:

   332

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

   333

            return datetime(*datetime_values)

   334

        else:

   335

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

   336

    else:

   337

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

   338

        return None

   339

   340

"""

   341

This is the Metaclass for PLCOpen element classes. It generates automatically

   342

the basic useful methods for manipulate the differents attributes of the classes

   343

"""

   344

class MetaClass(type):

   345

   346

    def __init__(cls, name, bases, dict):

   347

        super(MetaClass, cls).__init__(name, bases, {})

   348

        #print name, bases, dict, "\n"

   349

        initialValues = {}

   350

        for attr, values in dict.items():

   351

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

   352

                pass

   353

   354

            # Class is a enumerated type

   355

            elif attr == "enum":

   356

                value_type, initial = GetTypeInitialValue(dict["basetype"])

   357

                initialValues["value"] = "\"%s\""%values[0]

   358

                setattr(cls, "value", values[0])

   359

                setattr(cls, "setValue", MetaClass.generateSetEnumMethod(cls, values, value_type))

   360

                setattr(cls, "getValue", MetaClass.generateGetMethod(cls, "value"))

   361

   362

            # Class is a limited type

   363

            elif attr == "limit":

   364

                value_type, initial = GetTypeInitialValue(dict["basetype"])

   365

                initial = 0

   366

                if "min" in values:

   367

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

   368

                if "max" in values:

   369

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

   370

                initialValues["value"] = "%d"%initial

   371

                setattr(cls, "value", initial)

   372

                setattr(cls, "setValue", MetaClass.generateSetLimitMethod(cls, values, value_type))

   373

                setattr(cls, "getValue", MetaClass.generateGetMethod(cls, "value"))

   374

   375

            # Class has an attribute that can have different value types

   376

            elif attr == "choice_content":

   377

                setattr(cls, "content", None)

   378

                initialValues["content"] = "None"

   379

                setattr(cls, "deleteContent", MetaClass.generateDeleteMethod(cls, "content"))

   380

                setattr(cls, "setContent", MetaClass.generateSetChoiceMethod(cls, values))

   381

                setattr(cls, "getContent", MetaClass.generateGetMethod(cls, "content"))

   382

            elif attr == "multichoice_content":

   383

                setattr(cls, "content", [])

   384

                initialValues["content"] = "[]"

   385

                setattr(cls, "appendContent", MetaClass.generateAppendChoiceMethod(cls, values))

   386

                setattr(cls, "insertContent", MetaClass.generateInsertChoiceMethod(cls, values))

   387

                setattr(cls, "removeContent", MetaClass.generateRemoveMethod(cls, "content"))

   388

                setattr(cls, "countContent", MetaClass.generateCountMethod(cls, "content"))

   389

                setattr(cls, "setContent", MetaClass.generateSetMethod(cls, "content", ListType))

   390

                setattr(cls, "getContent", MetaClass.generateGetMethod(cls, "content"))

   391

   392

            # It's an attribute of the class

   393

            else:

   394

                attrname = attr[0].upper()+attr[1:]

   395

                attr_type, xml_type, write_type = values

   396

                value_type, initial = GetTypeInitialValue(attr_type)

   397

                # Value of the attribute is a list

   398

                if attr_type.endswith("[]"):

   399

                    setattr(cls, attr, [])

   400

                    initialValues[attr] = "[]"

   401

                    setattr(cls, "append"+attrname, MetaClass.generateAppendMethod(cls, attr, value_type))

   402

                    setattr(cls, "insert"+attrname, MetaClass.generateInsertMethod(cls, attr, value_type))

   403

                    setattr(cls, "remove"+attrname, MetaClass.generateRemoveMethod(cls, attr))

   404

                    setattr(cls, "count"+attrname, MetaClass.generateCountMethod(cls, attr))

   405

                    setattr(cls, "set"+attrname, MetaClass.generateSetMethod(cls, attr, ListType))

   406

                else:

   407

                    if write_type == "optional":

   408

                        setattr(cls, attr, None)

   409

                        initialValues[attr] = "None"

   410

                        setattr(cls, "add"+attrname, MetaClass.generateAddMethod(cls, attr, initial))

   411

                        setattr(cls, "delete"+attrname, MetaClass.generateDeleteMethod(cls, attr))

   412

                    else:

   413

                        setattr(cls, attr, initial)

   414

                        initialValues[attr] = initial

   415

                    setattr(cls, "set"+attrname, MetaClass.generateSetMethod(cls, attr, value_type))

   416

                setattr(cls, "get"+attrname, MetaClass.generateGetMethod(cls, attr))

   417

        setattr(cls, "__init__", MetaClass.generateInitMethod(cls, bases, initialValues))

   418

        setattr(cls, "loadXMLTree", MetaClass.generateLoadXMLTree(cls, bases, dict))

   419

        setattr(cls, "generateXMLText", MetaClass.generateGenerateXMLText(cls, bases, dict))

   420

        setattr(cls, "singleLineAttributes", True)

   421

   422

    """

   423

    Method that generate the method for loading an xml tree by following the

   424

    attributes list defined

   425

    """

   426

    def generateLoadXMLTree(cls, bases, dict):

   427

        def loadXMLTreeMethod(self, tree):

   428

            # If class is derived, values of inheritance classes are loaded

   429

            for base in bases:

   430

                base.loadXMLTree(self, tree)

   431

            # Class is a enumerated or limited value

   432

            if "enum" in dict.keys() or "limit" in dict.keys():

   433

                attr_value = GetAttributeValue(tree)

   434

                attr_type = dict["basetype"]

   435

                val = GetComputedValue(attr_type, attr_value)

   436

                self.setValue(val)

   437

            else:

   438

   439

                # Load the node attributes if they are defined in the list

   440

                for attrname, attr in tree._attrs.items():

   441

                    if attrname in dict.keys():

   442

                        attr_type, xml_type, write_type = dict[attrname]

   443

                        attr_value = GetAttributeValue(attr)

   444

                        if write_type != "optional" or attr_value != "":

   445

                            # Extracts the value

   446

                            if attr_type.startswith("xsd:"):

   447

                                val = GetComputedValue(attr_type, attr_value)

   448

                            elif attr_type.startswith("ppx:"):

   449

                                val = eval("%s()"%attr_type[4:], globals().update(PLCOpenClasses))

   450

                                val.loadXMLTree(attr)

   451

                            setattr(self, attrname, val)

   452

   453

                # Load the node childs if they are defined in the list

   454

                for node in tree.childNodes:

   455

                    name = node.nodeName

   456

                    # We make fun of #text elements

   457

                    if name != "#text":

   458

   459

                        # Class has an attribute that can have different value types

   460

                        if "choice_content" in dict.keys() and name in dict["choice_content"].keys():

   461

                            attr_type = dict["choice_content"][name]

   462

                            # Extracts the value

   463

                            if attr_type.startswith("xsd:"):

   464

                                attr_value = GetAttributeValue(node)

   465

                                if write_type != "optional" or attr_value != "":

   466

                                    val = GetComputedValue(attr_type.replace("[]",""), attr_value)

   467

                                else:

   468

                                    val = None

   469

                            elif attr_type.startswith("ppx:"):

   470

                                val = eval("%s()"%attr_type[4:].replace("[]",""), globals().update(PLCOpenClasses))

   471

                                val.loadXMLTree(node)

   472

                            # Stock value in content attribute

   473

                            if val:

   474

                                if attr_type.endswith("[]"):

   475

                                    if self.content:

   476

                                        self.content["value"].append(val)

   477

                                    else:

   478

                                        self.content = {"name":name,"value":[val]}

   479

                                else:

   480

                                    self.content = {"name":name,"value":val}

   481

   482

                        # Class has a list of attributes that can have different value types

   483

                        elif "multichoice_content" in dict.keys() and name in dict["multichoice_content"].keys():

   484

                            attr_type = dict["multichoice_content"][name]

   485

                            # Extracts the value

   486

                            if attr_type.startswith("xsd:"):

   487

                                attr_value = GetAttributeValue(node)

   488

                                if write_type != "optional" or attr_value != "":

   489

                                    val = GetComputedValue(attr_type, attr_value)

   490

                                else:

   491

                                    val = None

   492

                            elif attr_type.startswith("ppx:"):

   493

                                val = eval("%s()"%attr_type[4:], globals().update(PLCOpenClasses))

   494

                                val.loadXMLTree(node)

   495

                            # Add to content attribute list

   496

                            if val:

   497

                                self.content.append({"name":name,"value":val})

   498

   499

                        # The node child is defined in the list

   500

                        elif name in dict.keys():

   501

                            attr_type, xml_type, write_type = dict[name]

   502

                            # Extracts the value

   503

                            if attr_type.startswith("xsd:"):

   504

                                attr_value = GetAttributeValue(node)

   505

                                if write_type != "optional" or attr_value != "":

   506

                                    val = GetComputedValue(attr_type.replace("[]",""), attr_value)

   507

                                else:

   508

                                    val = None

   509

                            elif attr_type.startswith("ppx:"):

   510

                                val = eval("%s()"%attr_type[4:].replace("[]",""), globals().update(PLCOpenClasses))

   511

                                val.loadXMLTree(node)

   512

                            # Stock value in attribute

   513

                            if val:

   514

                                if attr_type.endswith("[]"):

   515

                                    getattr(self, name).append(val)

   516

                                else:

   517

                                    setattr(self, name, val)

   518

        return loadXMLTreeMethod

   519

   520

    """

   521

    Method that generates the method for generating an xml text by following the

   522

    attributes list defined

   523

    """

   524

    def generateGenerateXMLText(cls, bases, dict):

   525

        def generateXMLTextMethod(self, name, indent, extras = {}, derived = False):

   526

            ind1, ind2 = getIndent(indent, name)

   527

            if not derived:

   528

                text = ind1 + "<%s"%name

   529

            else:

   530

                text = ""