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 *

    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

Dictionaries for stocking Classes and Types created from XML

    47

"""

    48

XMLClasses = {}

    49

    50

"""

    51

This function calculates the number of whitespace for indentation

    52

"""

    53

def getIndent(indent, balise):

    54

    first = indent * 2

    55

    second = first + len(balise) + 1

    56

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

    57

    58

"""

    59

This function opens the xsd file and generate the classes from the xml tree

    60

"""

    61

def GenerateClassesFromXSD(filename):

    62

    xsdfile = open(filename, 'r')

    63

    Generate_xsd_classes(minidom.parse(xsdfile), None)

    64

    xsdfile.close()

    65

    66

"""

    73

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

    74

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

    75

"""

    76

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

    77

    attributes = {}

    78

    inheritance = []

    79

    if sequence:

    80

        order = []

    81

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

    82

    for node in tree.childNodes:

    83

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

    84

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

    85

            recursion = False

    86

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

    87

    88

            # This tags defines an attribute of the class

    89

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

    90

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

    91

                if "type" in node._attrs:

    92

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

    93

                    if nodetype.startswith("xsd"):

    94

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

    95

                    elif nodetype.startswith("ppx"):

    96

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

    97

                else:

    98

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

    99

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

   100

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

   101

                    if parent:

   102

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

   103

                    else:

   104

                        classname = nodename

   105

                    Generate_xsd_classes(node, classname)

   106

                    nodetype = "cls:%s"%classname

   107

                if name == "attribute":

   108

                    if "use" in node._attrs:

   109

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

   110

                    else:

   111

                        use = "optional"

   112

                if name == "element":

   113

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

   114

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

   115

                        nodetype = "%s[]"%nodetype

   116

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

   117

                        use = "optional"

   118

                    else:

   119

                        use = "required"

   120

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

   121

                if sequence:

   122

                    order.append(nodename)

   123

   124

            # This tag defines a new class

   125

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

   126

                if "name" in node._attrs:

   127

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

   128

                    super, attrs = Generate_xsd_classes(node, classname)

   129

                else:

   130

                    classname = parent

   131

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

   132

                # When all attributes and inheritances have been extracted, the

   133

                # values are added in the list of classes to create

   134

                if classname not in XMLClasses:

   135

                    XMLClasses[classname] = (super, attrs)

   136

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

   137

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

   138

   139

            # This tag defines an attribute that can have different types

   140

            elif name == "choice":

   141

                super, attrs = Generate_xsd_classes(node, parent)

   142

                if "ref" in attrs.keys():

   143

                    choices = attrs

   144

                else:

   145

                    choices = {}

   146

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

   147

                        choices[attr] = attr_type

   148

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

   149

                    attributes["multichoice_content"] = choices

   150

                    if sequence:

   151

                        order.append("multichoice_content")

   152

                else:

   153

                    attributes["choice_content"] = choices

   154

                    if sequence:

   155

                        order.append("choice_content")

   156

   157

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

   158

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

   159

            elif name in "sequence":

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

                inheritance.extend(super)

   168

                attributes.update(attrs)

   169

                attributes["order"] = order

   170

   171

            # This tag defines of types

   172

            elif name == "group":

   173

                if "name" in node._attrs:

   174

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

   175

                    super, attrs = Generate_xsd_classes(node, None)

   176

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

   177

                elif "ref" in node._attrs:

   178

                    if "ref" not in attributes:

   179

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

   180

                    else:

   181

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

   182

   183

            # This tag define a base class for the node

   184

            elif name == "extension":

   185

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

   186

                if super.startswith("xsd"):

   187

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

   188

                elif super.startswith("ppx"):

   189

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

   190

                inheritance.append(super[4:])

   191

                recursion = True

   192

   193

            # This tag defines a restriction on the type of attribute

   194

            elif name == "restriction":

   195

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

   196

                if basetype.startswith("xsd"):

   197

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

   198

                elif basetype.startswith("ppx"):

   199

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

   200

                attributes["basetype"] = basetype

   201

                recursion = True

   202

   203

            # This tag defines an enumerated type

   204

            elif name == "enumeration":

   205

                if "enum" not in attributes:

   206

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

   207

                else:

   208

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

   209

   210

            # This tags defines a restriction on a numerical value

   211

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

   212

                if "limit" not in attributes:

   213

                    attributes["limit"] = {}

   214

                if name == "minInclusive":

   215

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

   216

                elif name == "maxInclusive":

   217

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

   218

   219

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

   220

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

   221

                recursion = True

   222

   223

            # We make fun of xsd documentation

   224

            elif name in ["annotation"]:

   225

                pass

   226

   227

            else:

   228

                #print name

   229

                Generate_xsd_classes(node, parent)

   230

   231

            # Parse the childrens of node

   232

            if recursion:

   233

                super, attrs = Generate_xsd_classes(node, parent)

   234

                inheritance.extend(super)

   235

                attributes.update(attrs)

   236

   237

    # if sequence tag have been found, order is returned

   238

    if sequence:

   239

        return inheritance, attributes, order

   240

    else:

   241

        return inheritance, attributes

   242

"""

   243

Function that extracts data from a node

   244

"""

   245

def GetAttributeValue(attr):

   246

    if len(attr.childNodes) == 1:

   247

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

   248

    else:

   249

        text = ""

   250

        for node in attr.childNodes:

   251

            if node.nodeName != "#text":

   252

                text += node.data.encode()

   253

        return text

   254

   255

"""

   256

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

   257

"""

   258

def GetTypeInitialValue(attr_type):

   259

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

   260

    if attr_type.startswith("bse:"):

   261

        if type_compute == "boolean":

   262

            return BooleanType, "False"

   263

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

   264

            return IntType, "0"

   265

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

   266

            return StringType, "\"\""

   267

        elif type_compute == "time":

   268

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

   269

        elif type_compute == "date":

   270

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

   271

        elif type_compute == "dateTime":

   272

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

   273

        elif type_compute == "language":

   274

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

   275

        else:

   276

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

   277

    elif attr_type.startswith("cls:"):

   278

        if type_compute in XMLClasses:

   279

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

   280

   281

"""

   282

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

   283

there is no uppercase in plcopen)

   284

"""

   285

def ComputeValue(value):

   286

    if type(value) == BooleanType:

   287

        if value:

   288

            return "true"

   289

        else:

   290

            return "false"

   291

    else:

   292

        return str(value)

   293

   294

"""

   295

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

   296

"""

   297

def GetComputedValue(attr_type, value):

   298

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

   299

    if type_compute == "boolean":

   300

         if value == "true":

   301

             return True

   302

         elif value == "false":

   303

             return False

   304

         else:

   305

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

   306

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

   307

        return int(value)

   308

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

   309

        return value

   310

    elif type_compute == "time":

   311

        result = time_model.match(value)

   312

        if result:

   313

            values = result.groups()

   314

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

   315

            seconds = float(values[2])

   316

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

   317

            return time(*time_values)

   318

        else:

   319

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

   320

    elif type_compute == "date":

   321

        result = date_model.match(value)

   322

        if result:

   323

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

   324

            return date(*date_values)

   325

        else:

   326

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

   327

    elif type_compute == "dateTime":

   328

        result = datetime_model.match(value)

   329

        if result:

   330

            values = result.groups()

   331

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

   332

            seconds = float(values[5])

   333

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

   334

            return datetime(*datetime_values)

   335

        else:

   336

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

   337

    else:

   338

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

   339

        return None

   340

   341

"""

   469

                pass