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

import os, sys

    26

import re

    27

import datetime

    28

from types import *

    29

from xml.dom import minidom

    30

from xml.sax.saxutils import escape, unescape, quoteattr

    31

from lxml import etree

    32

from new import classobj

    33

from collections import OrderedDict

    34

    35

def CreateNode(name):

    36

    node = minidom.Node()

    37

    node.nodeName = name

    38

    node._attrs = {}

    39

    node.childNodes = []

    40

    return node

    41

    42

def NodeRenameAttr(node, old_name, new_name):

    43

    node._attrs[new_name] = node._attrs.pop(old_name)

    44

    45

def NodeSetAttr(node, name, value):

    46

    attr = minidom.Attr(name)

    47

    text = minidom.Text()

    48

    text.data = value

    49

    attr.childNodes[0] = text

    50

    node._attrs[name] = attr

    51

    52

"""

    53

Regular expression models for checking all kind of string values defined in XML

    54

standard

    55

"""

    56

Name_model = re.compile('([a-zA-Z_\:][\w\.\-\:]*)$')

    57

Names_model = re.compile('([a-zA-Z_\:][\w\.\-\:]*(?: [a-zA-Z_\:][\w\.\-\:]*)*)$')

    58

NMToken_model = re.compile('([\w\.\-\:]*)$')

    59

NMTokens_model = re.compile('([\w\.\-\:]*(?: [\w\.\-\:]*)*)$')

    60

QName_model = re.compile('((?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*)$')

    61

QNames_model = re.compile('((?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*(?: (?:[a-zA-Z_][\w]*:)?[a-zA-Z_][\w]*)*)$')

    62

NCName_model = re.compile('([a-zA-Z_][\w]*)$')

    63

URI_model = re.compile('((?:http://|/)?(?:[\w.-]*/?)*)$')

    64

LANGUAGE_model = re.compile('([a-zA-Z]{1,8}(?:-[a-zA-Z0-9]{1,8})*)$')

    65

    66

ONLY_ANNOTATION = re.compile("((?:annotation )?)")

    67

    68

"""

    69

Regular expression models for extracting dates and times from a string

    70

"""

    71

time_model = re.compile('([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]*)?)(?:Z)?$')

    72

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

    73

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)?$')

    74

    75

class xml_timezone(datetime.tzinfo):

    76

    77

    def SetOffset(self, offset):

    78

        if offset == "Z":

    79

            self.__offset = timedelta(minutes = 0)

    80

            self.__name = "UTC"

    81

        else:

    82

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

    83

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

    84

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

    85

            self.__name = ""

    86

    87

    def utcoffset(self, dt):

    88

        return self.__offset

    89

    90

    def tzname(self, dt):

    91

        return self.__name

    92

    93

    def dst(self, dt):

    94

        return ZERO

    95

    96

[SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE, 

    97

 ATTRIBUTESGROUP, ELEMENTSGROUP, ATTRIBUTE, ELEMENT, CHOICE, ANY, TAG, CONSTRAINT,

    98

] = range(13)

    99

   100

def NotSupportedYet(type):

   101

    """

   102

    Function that generates a function that point out to user that datatype

   103

    used is not supported by xmlclass yet

   104

    @param type: data type

   105

    @return: function generated

   106

    """

   107

    def GetUnknownValue(attr):

   108

        raise ValueError("\"%s\" type isn't supported by \"xmlclass\" yet!" % \

   109

                         type)

   110

    return GetUnknownValue

   111

   112

"""

   113

This function calculates the number of whitespace for indentation

   114

"""

   115

def getIndent(indent, balise):

   116

    first = indent * 2

   117

    second = first + len(balise) + 1

   118

    return u'\t'.expandtabs(first), u'\t'.expandtabs(second)

   119

   120

   121

def GetAttributeValue(attr, extract=True):

   122

    """

   123

    Function that extracts data from a tree node

   124

    @param attr: tree node containing data to extract

   125

    @param extract: attr is a tree node or not

   126

    @return: data extracted as string

   127

    """

   128

    if not extract:

   129

        return attr

   130

    if len(attr.childNodes) == 1:

   131

        return unicode(unescape(attr.childNodes[0].data))

   132

    else:

   133

        # content is a CDATA

   134

        text = u''

   135

        for node in attr.childNodes:

   136

            if not (node.nodeName == "#text" and node.data.strip() == u''):

   137

                text += unicode(unescape(node.data))

   138

        return text

   139

   140

   141

def GetNormalizedString(attr, extract=True):

   142

    """

   143

    Function that normalizes a string according to XML 1.0. Replace  

   144

    tabulations, line feed and carriage return by white space

   145

    @param attr: tree node containing data to extract or data to normalize

   146

    @param extract: attr is a tree node or not

   147

    @return: data normalized as string

   148

    """

   149

    if extract:

   150

        value = GetAttributeValue(attr)

   151

    else:

   152

        value = attr

   153

    return value.replace("\t", " ").replace("\r", " ").replace("\n", " ")

   154

   155

   156

def GetToken(attr, extract=True):

   157

    """

   158

    Function that tokenizes a string according to XML 1.0. Remove any leading  

   159

    and trailing white space and replace internal sequence of two or more 

   160

    spaces by only one white space

   161

    @param attr: tree node containing data to extract or data to tokenize

   162

    @param extract: attr is a tree node or not

   163

    @return: data tokenized as string

   164

    """

   165

    return " ".join([part for part in 

   166

                     GetNormalizedString(attr, extract).split(" ")

   167

                     if part])

   168

   169

   170

def GetHexInteger(attr, extract=True):

   171

    """

   172

    Function that extracts an hexadecimal integer from a tree node or a string

   173

    @param attr: tree node containing data to extract or data as a string

   174

    @param extract: attr is a tree node or not

   175

    @return: data as an integer

   176

    """

   177

    if extract:

   178

        value = GetAttributeValue(attr)

   179

    else:

   180

        value = attr

   181

    if len(value) % 2 != 0:

   182

        raise ValueError("\"%s\" isn't a valid hexadecimal integer!" % value)

   183

    try:

   184

        return int(value, 16)

   185

    except:

   186

        raise ValueError("\"%s\" isn't a valid hexadecimal integer!" % value)

   187

   188

   189

def GenerateIntegerExtraction(minInclusive=None, maxInclusive=None, 

   190

                              minExclusive=None, maxExclusive=None):

   191

    """

   192

    Function that generates an extraction function for integer defining min and

   193

    max of integer value

   194

    @param minInclusive: inclusive minimum

   195

    @param maxInclusive: inclusive maximum

   196

    @param minExclusive: exclusive minimum

   197

    @param maxExclusive: exclusive maximum

   198

    @return: function generated

   199

    """

   200

    def GetInteger(attr, extract=True):

   201

        """

   202

        Function that extracts an integer from a tree node or a string

   203

        @param attr: tree node containing data to extract or data as a string

   204

        @param extract: attr is a tree node or not

   205

        @return: data as an integer

   206

        """

   207

   208

        if extract:

   209

            value = GetAttributeValue(attr)

   210

        else:

   211

            value = attr

   212

        try:

   213

            # TODO: permit to write value like 1E2

   214

            value = int(value)

   215

        except:

   216

            raise ValueError("\"%s\" isn't a valid integer!" % value)

   217

        if minInclusive is not None and value < minInclusive:

   218

            raise ValueError("\"%d\" isn't greater or equal to %d!" % \

   219

                             (value, minInclusive))

   220

        if maxInclusive is not None and value > maxInclusive:

   221

            raise ValueError("\"%d\" isn't lesser or equal to %d!" % \

   222

                             (value, maxInclusive))

   223

        if minExclusive is not None and value <= minExclusive:

   224

            raise ValueError("\"%d\" isn't greater than %d!" % \

   225

                             (value, minExclusive))

   226

        if maxExclusive is not None and value >= maxExclusive:

   227

            raise ValueError("\"%d\" isn't lesser than %d!" % \

   228

                             (value, maxExclusive))

   229

        return value

   230

    return GetInteger

   231

   232

   233

def GenerateFloatExtraction(type, extra_values=[]):

   234

    """

   235

    Function that generates an extraction function for float

   236

    @param type: name of the type of float

   237

    @return: function generated

   238

    """

   239

    def GetFloat(attr, extract = True):

   240

        """

   241

        Function that extracts a float from a tree node or a string

   242

        @param attr: tree node containing data to extract or data as a string

   243

        @param extract: attr is a tree node or not

   244

        @return: data as a float

   245

        """

   246

        if extract:

   247

            value = GetAttributeValue(attr)

   248

        else:

   249

            value = attr

   250

        if value in extra_values:

   251

            return value

   252

        try:

   253

            return float(value)

   254

        except:

   255

            raise ValueError("\"%s\" isn't a valid %s!" % (value, type))

   256

    return GetFloat

   257

   258

   259

def GetBoolean(attr, extract=True):

   260

    """

   261

    Function that extracts a boolean from a tree node or a string

   262

    @param attr: tree node containing data to extract or data as a string

   263

    @param extract: attr is a tree node or not

   264

    @return: data as a boolean

   265

    """

   266

    if extract:

   267

        value = GetAttributeValue(attr)

   268

    else:

   269

        value = attr

   270

    if value == "true" or value == "1":

   271

        return True

   272

    elif value == "false" or value == "0":

   273

        return False

   274

    else:

   275

        raise ValueError("\"%s\" isn't a valid boolean!" % value)

   276

   277

   278

def GetTime(attr, extract=True):

   279

    """

   280

    Function that extracts a time from a tree node or a string

   281

    @param attr: tree node containing data to extract or data as a string

   282

    @param extract: attr is a tree node or not

   283

    @return: data as a time

   284

    """

   285

    if extract:

   286

        value = GetAttributeValue(attr)

   287

    else:

   288

        value = attr

   289

    result = time_model.match(value)

   290

    if result:

   291

        values = result.groups()

   292

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

   293

        seconds = float(values[2])

   294

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

   295

        return datetime.time(*time_values)

   296

    else:

   297

        raise ValueError("\"%s\" isn't a valid time!" % value)

   298

   299

   300

def GetDate(attr, extract=True):

   301

    """

   302

    Function that extracts a date from a tree node or a string

   303

    @param attr: tree node containing data to extract or data as a string

   304

    @param extract: attr is a tree node or not

   305

    @return: data as a date

   306

    """

   307

    if extract:

   308

        value = GetAttributeValue(attr)

   309

    else:

   310

        value = attr

   311

    result = date_model.match(value)

   312

    if result:

   313

        values = result.groups()

   314

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

   315

        if values[3] is not None:

   316

            tz = xml_timezone()

   317

            tz.SetOffset(values[3])

   318

            date_values.append(tz)

   319

        return datetime.date(*date_values)

   320

    else:

   321

        raise ValueError("\"%s\" isn't a valid date!" % value)

   322

   323

   324

def GetDateTime(attr, extract=True):

   325

    """

   326

    Function that extracts date and time from a tree node or a string

   327

    @param attr: tree node containing data to extract or data as a string

   328

    @param extract: attr is a tree node or not

   329

    @return: data as date and time

   330

    """

   331

    if extract:

   332

        value = GetAttributeValue(attr)

   333

    else:

   334

        value = attr

   335

    result = datetime_model.match(value)

   336

    if result:

   337

        values = result.groups()

   338

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

   339

        seconds = float(values[5])

   340

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

   341

        if values[6] is not None:

   342

            tz = xml_timezone()

   343

            tz.SetOffset(values[6])

   344

            datetime_values.append(tz)

   345

        return datetime.datetime(*datetime_values)

   346

    else:

   347

        raise ValueError("\"%s\" isn't a valid datetime!" % value)

   348

   349

   350

def GenerateModelNameExtraction(type, model):

   351

    """

   352

    Function that generates an extraction function for string matching a model

   353

    @param type: name of the data type

   354

    @param model: model that data must match

   355

    @return: function generated

   356

    """

   357

    def GetModelName(attr, extract=True):

   358

        """

   359

        Function that extracts a string from a tree node or not and check that

   360

        string extracted or given match the model

   361

        @param attr: tree node containing data to extract or data as a string

   362

        @param extract: attr is a tree node or not

   363

        @return: data as a string if matching

   364

        """

   365

        if extract:

   366

            value = GetAttributeValue(attr)

   367

        else:

   368

            value = attr

   369

        result = model.match(value)

   370

        if not result:

   371

            raise ValueError("\"%s\" isn't a valid %s!" % (value, type))

   372

        return value

   373

    return GetModelName

   374

   375

   376

def GenerateLimitExtraction(min=None, max=None, unbounded=True):

   377

    """

   378

    Function that generates an extraction function for integer defining min and

   379

    max of integer value

   380

    @param min: minimum limit value

   381

    @param max: maximum limit value

   382

    @param unbounded: value can be "unbounded" or not

   383

    @return: function generated

   384

    """

   385

    def GetLimit(attr, extract=True):

   386

        """

   387

        Function that extracts a string from a tree node or not and check that

   388

        string extracted or given is in a list of values

   389

        @param attr: tree node containing data to extract or data as a string

   390

        @param extract: attr is a tree node or not

   391

        @return: data as a string

   392

        """

   393

        if extract:

   394

            value = GetAttributeValue(attr)

   395

        else:

   396

            value = attr

   397

        if value == "unbounded":

   398

            if unbounded:

   399

                return value

   400

            else:

   401

                raise ValueError("Member limit can't be defined to \"unbounded\"!")

   402

        try:

   403

            limit = int(value)

   404

        except:

   405

            raise ValueError("\"%s\" isn't a valid value for this member limit!" % value)

   406

        if limit < 0:

   407

            raise ValueError("Member limit can't be negative!")

   408

        elif min is not None and limit < min:

   409

            raise ValueError("Member limit can't be lower than \"%d\"!" % min)

   410

        elif max is not None and limit > max:

   411

            raise ValueError("Member limit can't be upper than \"%d\"!" % max)

   412

        return limit

   413

    return GetLimit

   414

   415

   416

def GenerateEnumeratedExtraction(type, list):

   417

    """

   418

    Function that generates an extraction function for enumerated values

   419

    @param type: name of the data type

   420

    @param list: list of possible values

   421

    @return: function generated

   422

    """

   423

    def GetEnumerated(attr, extract=True):

   424

        """

   425

        Function that extracts a string from a tree node or not and check that

   426

        string extracted or given is in a list of values

   427

        @param attr: tree node containing data to extract or data as a string

   428

        @param extract: attr is a tree node or not

   429

        @return: data as a string

   430

        """

   431

        if extract:

   432

            value = GetAttributeValue(attr)

   433

        else:

   434

            value = attr

   435

        if value in list:

   436

            return value

   437

        else:

   438

            raise ValueError("\"%s\" isn't a valid value for %s!" % \

   439

                             (value, type))

   440

    return GetEnumerated

   441

   442

   443

def GetNamespaces(attr, extract=True):

   444

    """

   445

    Function that extracts a list of namespaces from a tree node or a string

   446

    @param attr: tree node containing data to extract or data as a string

   447

    @param extract: attr is a tree node or not

   448

    @return: list of namespaces

   449

    """

   450

    if extract:

   451

        value = GetAttributeValue(attr)

   452

    else:

   453

        value = attr

   454

    if value == "":

   455

        return []

   456

    elif value == "##any" or value == "##other":

   457

        namespaces = [value]

   458

    else:

   459

        namespaces = []

   460

        for item in value.split(" "):

   461

            if item == "##targetNamespace" or item == "##local":

   462

                namespaces.append(item)

   463

            else:

   464

                result = URI_model.match(item)

   465

                if result is not None:

   466

                    namespaces.append(item)

   467

                else:

   468

                    raise ValueError("\"%s\" isn't a valid value for namespace!" % value)

   469

    return namespaces

   470

   471

   472

def GenerateGetList(type, list):

   473

    """

   474

    Function that generates an extraction function for a list of values

   475

    @param type: name of the data type

   476

    @param list: list of possible values

   477

    @return: function generated

   478

    """

   479

    def GetLists(attr, extract=True):

   480

        """

   481

        Function that extracts a list of values from a tree node or a string

   482

        @param attr: tree node containing data to extract or data as a string

   483

        @param extract: attr is a tree node or not

   484

        @return: list of values

   485

        """

   486

        if extract:

   487

            value = GetAttributeValue(attr)

   488

        else:

   489

            value = attr

   490

        if value == "":

   491

            return []

   492

        elif value == "#all":

   493

            return [value]

   494

        else:

   495

            values = []

   496

            for item in value.split(" "):

   497

                if item in list:

   498

                    values.append(item)

   499

                else:

   500

                    raise ValueError("\"%s\" isn't a valid value for %s!" % \

   501

                                     (value, type))

   502

            return values

   503

    return GetLists

   504

   505

   506

def GenerateModelNameListExtraction(type, model):

   507

    """

   508

    Function that generates an extraction function for list of string matching

   509

    a model

   510

    @param type: name of the data type

   511

    @param model: model that list elements must match

   512

    @return: function generated

   513

    """

   514

    def GetModelNameList(attr, extract=True):

   515

        """

   516

        Function that extracts a list of string from a tree node or not and

   517

        check that all extracted items match the model

   518

        @param attr: tree node containing data to extract or data as a string

   519

        @param extract: attr is a tree node or not

   520

        @return: data as a list of string if matching 

   521

        """

   522

        if extract:

   523

            value = GetAttributeValue(attr)

   524

        else:

   525

            value = attr

   526

        values = []

   527

        for item in value.split(" "):

   528

            result = model.match(item)

   529

            if result is not None: