1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    27

import re

    28

import datetime

    29

from types import *

    30

from xml.dom import minidom

    31

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

    32

from lxml import etree

    33

from new import classobj

    34

from collections import OrderedDict

    35

    36

def CreateNode(name):

    37

    node = minidom.Node()

    38

    node.nodeName = name

    39

    node._attrs = {}

    40

    node.childNodes = []

    41

    return node

    42

    43

def NodeRenameAttr(node, old_name, new_name):

    44

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

    45

    46

def NodeSetAttr(node, name, value):

    47

    attr = minidom.Attr(name)

    48

    text = minidom.Text()

    49

    text.data = value

    50

    attr.childNodes[0] = text

    51

    node._attrs[name] = attr

    52

    53

"""

    54

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

    55

standard

    56

"""

    57

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

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

    67

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

    68

    69

"""

    70

Regular expression models for extracting dates and times from a string

    71

"""

    72

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

    73

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

    74

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

    75

    76

class xml_timezone(datetime.tzinfo):

    77

    78

    def SetOffset(self, offset):

    79

        if offset == "Z":

    80

            self.__offset = timedelta(minutes = 0)

    81

            self.__name = "UTC"

    82

        else:

    83

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

    84

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

    85

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

    86

            self.__name = ""

    87

    88

    def utcoffset(self, dt):

    89

        return self.__offset

    90

    91

    def tzname(self, dt):

    92

        return self.__name

    93

    94

    def dst(self, dt):

    95

        return ZERO

    96

    97

[SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE,

    98

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

    99

] = range(13)

   100

   101

def NotSupportedYet(type):

   102

    """

   103

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

   104

    used is not supported by xmlclass yet

   105

    @param type: data type

   106

    @return: function generated

   107

    """

   108

    def GetUnknownValue(attr):

   109

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

   110

                         type)

   111

    return GetUnknownValue

   112

   113

"""

   114

This function calculates the number of whitespace for indentation

   115

"""

   116

def getIndent(indent, balise):

   117

    first = indent * 2

   118

    second = first + len(balise) + 1

   119

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

   120

   121

   122

def GetAttributeValue(attr, extract=True):

   123

    """

   124

    Function that extracts data from a tree node

   125

    @param attr: tree node containing data to extract

   126

    @param extract: attr is a tree node or not

   127

    @return: data extracted as string

   128

    """

   129

    if not extract:

   130

        return attr

   131

    if len(attr.childNodes) == 1:

   132

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

   133

    else:

   134

        # content is a CDATA

   135

        text = u''

   136

        for node in attr.childNodes:

   137

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

   138

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

   139

        return text

   140

   141

   142

def GetNormalizedString(attr, extract=True):

   143

    """

   144

    Function that normalizes a string according to XML 1.0. Replace

   145

    tabulations, line feed and carriage return by white space

   146

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

   147

    @param extract: attr is a tree node or not

   148

    @return: data normalized as string

   149

    """

   150

    if extract:

   151

        value = GetAttributeValue(attr)

   152

    else:

   153

        value = attr

   154

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

   155

   156

   157

def GetToken(attr, extract=True):

   158

    """

   159

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

   160

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

   161

    spaces by only one white space

   162

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

   163

    @param extract: attr is a tree node or not

   164

    @return: data tokenized as string

   165

    """

   166

    return " ".join([part for part in

   167

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

   168

                     if part])

   169

   170

   171

def GetHexInteger(attr, extract=True):

   172

    """

   173

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

   174

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

   175

    @param extract: attr is a tree node or not

   176

    @return: data as an integer

   177

    """

   178

    if extract:

   179

        value = GetAttributeValue(attr)

   180

    else:

   181

        value = attr

   182

    if len(value) % 2 != 0:

   183

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

   184

    try:

   185

        return int(value, 16)

   186

    except:

   187

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

   188

   189

   190

def GenerateIntegerExtraction(minInclusive=None, maxInclusive=None,

   191

                              minExclusive=None, maxExclusive=None):

   192

    """

   193

    Function that generates an extraction function for integer defining min and

   194

    max of integer value

   195

    @param minInclusive: inclusive minimum

   196

    @param maxInclusive: inclusive maximum

   197

    @param minExclusive: exclusive minimum

   198

    @param maxExclusive: exclusive maximum

   199

    @return: function generated

   200

    """

   201

    def GetInteger(attr, extract=True):

   202

        """

   203

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

   204

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

   205

        @param extract: attr is a tree node or not

   206

        @return: data as an integer

   207

        """

   208

   209

        if extract:

   210

            value = GetAttributeValue(attr)

   211

        else:

   212

            value = attr

   213

        try:

   214

            # TODO: permit to write value like 1E2

   215

            value = int(value)

   216

        except:

   217

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

   218

        if minInclusive is not None and value < minInclusive:

   219

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

   220

                             (value, minInclusive))

   221

        if maxInclusive is not None and value > maxInclusive:

   222

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

   223

                             (value, maxInclusive))

   224

        if minExclusive is not None and value <= minExclusive:

   225

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

   226

                             (value, minExclusive))

   227

        if maxExclusive is not None and value >= maxExclusive:

   228

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

   229

                             (value, maxExclusive))

   230

        return value

   231

    return GetInteger

   232

   233

   234

def GenerateFloatExtraction(type, extra_values=[]):

   235

    """

   236

    Function that generates an extraction function for float

   237

    @param type: name of the type of float

   238

    @return: function generated

   239

    """

   240

    def GetFloat(attr, extract = True):

   241

        """

   242

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

   243

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

   244

        @param extract: attr is a tree node or not

   245

        @return: data as a float

   246

        """

   247

        if extract:

   248

            value = GetAttributeValue(attr)

   249

        else:

   250

            value = attr

   251

        if value in extra_values:

   252

            return value

   253

        try:

   254

            return float(value)

   255

        except:

   256

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

   257

    return GetFloat

   258

   259

   260

def GetBoolean(attr, extract=True):

   261

    """

   262

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

   263

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

   264

    @param extract: attr is a tree node or not

   265

    @return: data as a boolean

   266

    """

   267

    if extract:

   268

        value = GetAttributeValue(attr)

   269

    else:

   270

        value = attr

   271

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

   272

        return True

   273

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

   274

        return False

   275

    else:

   276

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

   277

   278

   279

def GetTime(attr, extract=True):

   280

    """

   281

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

   282

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

   283

    @param extract: attr is a tree node or not

   284

    @return: data as a time

   285

    """

   286

    if extract:

   287

        value = GetAttributeValue(attr)

   288

    else:

   289

        value = attr

   290

    result = time_model.match(value)

   291

    if result:

   292

        values = result.groups()

   293

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

   294

        seconds = float(values[2])

   295

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

   296

        return datetime.time(*time_values)

   297

    else:

   298

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

   299

   300

   301

def GetDate(attr, extract=True):

   302

    """

   303

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

   304

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

   305

    @param extract: attr is a tree node or not

   306

    @return: data as a date

   307

    """

   308

    if extract:

   309

        value = GetAttributeValue(attr)

   310

    else:

   311

        value = attr

   312

    result = date_model.match(value)

   313

    if result:

   314

        values = result.groups()

   315

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

   316

        if values[3] is not None:

   317

            tz = xml_timezone()

   318

            tz.SetOffset(values[3])

   319

            date_values.append(tz)

   320

        return datetime.date(*date_values)

   321

    else:

   322

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

   323

   324

   325

def GetDateTime(attr, extract=True):

   326

    """

   327

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

   328

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

   329

    @param extract: attr is a tree node or not

   330

    @return: data as date and time

   331

    """

   332

    if extract:

   333

        value = GetAttributeValue(attr)

   334

    else:

   335

        value = attr

   336

    result = datetime_model.match(value)

   337

    if result:

   338

        values = result.groups()

   339

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

   340

        seconds = float(values[5])

   341

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

   342

        if values[6] is not None:

   343

            tz = xml_timezone()

   344

            tz.SetOffset(values[6])

   345

            datetime_values.append(tz)

   346

        return datetime.datetime(*datetime_values)

   347

    else:

   348

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

   349

   350

   351

def GenerateModelNameExtraction(type, model):

   352

    """

   353

    Function that generates an extraction function for string matching a model

   354

    @param type: name of the data type

   355

    @param model: model that data must match

   356

    @return: function generated

   357

    """

   358

    def GetModelName(attr, extract=True):

   359

        """

   360

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

   361

        string extracted or given match the model

   362

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

   363

        @param extract: attr is a tree node or not

   364

        @return: data as a string if matching

   365

        """

   366

        if extract:

   367

            value = GetAttributeValue(attr)

   368

        else:

   369

            value = attr

   370

        result = model.match(value)

   371

        if not result:

   372

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

   373

        return value

   374

    return GetModelName

   375

   376

   377

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

   378

    """

   379

    Function that generates an extraction function for integer defining min and

   380

    max of integer value

   381

    @param min: minimum limit value

   382

    @param max: maximum limit value

   383

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

   384

    @return: function generated

   385

    """

   386

    def GetLimit(attr, extract=True):

   387

        """

   388

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

   389

        string extracted or given is in a list of values

   390

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

   391

        @param extract: attr is a tree node or not

   392

        @return: data as a string

   393

        """

   394

        if extract:

   395

            value = GetAttributeValue(attr)

   396

        else:

   397

            value = attr

   398

        if value == "unbounded":

   399

            if unbounded:

   400

                return value

   401

            else:

   402

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

   403

        try:

   404

            limit = int(value)

   405

        except:

   406

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

   407

        if limit < 0:

   408

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

   409

        elif min is not None and limit < min:

   410

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

   411

        elif max is not None and limit > max:

   412

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

   413

        return limit

   414

    return GetLimit

   415

   416

   417

def GenerateEnumeratedExtraction(type, list):

   418

    """

   419

    Function that generates an extraction function for enumerated values

   420

    @param type: name of the data type

   421

    @param list: list of possible values

   422

    @return: function generated

   423

    """

   424

    def GetEnumerated(attr, extract=True):

   425

        """

   426

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

   427

        string extracted or given is in a list of values

   428

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

   429

        @param extract: attr is a tree node or not

   430

        @return: data as a string

   431

        """

   432

        if extract:

   433

            value = GetAttributeValue(attr)

   434

        else:

   435

            value = attr

   436

        if value in list:

   437

            return value

   438

        else:

   439

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

   440

                             (value, type))

   441

    return GetEnumerated

   442

   443

   444

def GetNamespaces(attr, extract=True):

   445

    """

   446

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

   447

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

   448

    @param extract: attr is a tree node or not

   449

    @return: list of namespaces

   450

    """

   451

    if extract:

   452

        value = GetAttributeValue(attr)

   453

    else:

   454

        value = attr

   455

    if value == "":

   456

        return []

   457

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

   458

        namespaces = [value]

   459

    else:

   460

        namespaces = []

   461

        for item in value.split(" "):

   462

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

   463

                namespaces.append(item)

   464

            else:

   465

                result = URI_model.match(item)

   466

                if result is not None:

   467

                    namespaces.append(item)

   468

                else:

   469

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

   470

    return namespaces

   471

   472

   473

def GenerateGetList(type, list):

   474

    """

   475

    Function that generates an extraction function for a list of values

   476

    @param type: name of the data type

   477

    @param list: list of possible values

   478

    @return: function generated

   479

    """

   480

    def GetLists(attr, extract=True):

   481

        """

   482

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

   483

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

   484

        @param extract: attr is a tree node or not

   485

        @return: list of values

   486

        """

   487

        if extract:

   488

            value = GetAttributeValue(attr)

   489

        else:

   490

            value = attr

   491

        if value == "":

   492

            return []

   493

        elif value == "#all":

   494

            return [value]

   495

        else:

   496

            values = []

   497

            for item in value.split(" "):

   498

                if item in list:

   499

                    values.append(item)

   500

                else:

   501

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

   502

                                     (value, type))

   503

            return values

   504

    return GetLists

   505

   506

   507

def GenerateModelNameListExtraction(type, model):

   508

    """

   509

    Function that generates an extraction function for list of string matching

   510

    a model

   511

    @param type: name of the data type

   512

    @param model: model that list elements must match

   513

    @return: function generated

   514

    """

   515

    def GetModelNameList(attr, extract=True):

   516

        """

   517

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

   518

        check that all extracted items match the model

   519

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

   520

        @param extract: attr is a tree node or not

   521

        @return: data as a list of string if matching

   522

        """

   523

        if extract:

   524

            value = GetAttributeValue(attr)

   525

        else:

   526

            value = attr