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

    25

    26

from __future__ import print_function

    27

import os

    28

import sys

    29

import re

    30

import datetime

    31

from types import *

    32

from xml.dom import minidom

    33

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

    34

from new import classobj

    35

from collections import OrderedDict

    36

    37

from lxml import etree

    38

    39

    40

def CreateNode(name):

    41

    node = minidom.Node()

    42

    node.nodeName = name

    43

    node._attrs = {}

    44

    node.childNodes = []

    45

    return node

    46

    47

    48

def NodeRenameAttr(node, old_name, new_name):

    49

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

    50

    51

    52

def NodeSetAttr(node, name, value):

    53

    attr = minidom.Attr(name)

    54

    text = minidom.Text()

    55

    text.data = value

    56

    attr.childNodes[0] = text

    57

    node._attrs[name] = attr

    58

    59

    63

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

    64

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

    65

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

    66

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

    67

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

    68

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

    69

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

    70

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

    71

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

    72

    73

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

    74

    75

"""

    76

Regular expression models for extracting dates and times from a string

    77

"""

    78

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

    79

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

    80

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

    81

    82

    83

class xml_timezone(datetime.tzinfo):

    84

    85

    def SetOffset(self, offset):

    86

        if offset == "Z":

    87

            self.__offset = timedelta(minutes=0)

    88

            self.__name = "UTC"

    89

        else:

    90

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

    91

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

    92

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

    93

            self.__name = ""

    94

    95

    def utcoffset(self, dt):

    96

        return self.__offset

    97

    98

    def tzname(self, dt):

    99

        return self.__name

   100

   101

    def dst(self, dt):

   102

        return ZERO

   103

   104

   105

[

   106

    SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE,

   107

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

   108

] = range(13)

   109

   110

   111

def NotSupportedYet(type):

   112

    """

   113

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

   114

    used is not supported by xmlclass yet

   115

    @param type: data type

   116

    @return: function generated

   117

    """

   118

    def GetUnknownValue(attr):

   119

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

   120

    return GetUnknownValue

   121

   122

   123

def getIndent(indent, balise):

   124

    """

   125

    This function calculates the number of whitespace for indentation

   126

    """

   127

    first = indent * 2

   128

    second = first + len(balise) + 1

   129

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

   130

   131

   132

def GetAttributeValue(attr, extract=True):

   133

    """

   134

    Function that extracts data from a tree node

   135

    @param attr: tree node containing data to extract

   136

    @param extract: attr is a tree node or not

   137

    @return: data extracted as string

   138

    """

   139

    if not extract:

   140

        return attr

   141

    if len(attr.childNodes) == 1:

   142

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

   143

    else:

   144

        # content is a CDATA

   145

        text = u''

   146

        for node in attr.childNodes:

   147

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

   148

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

   149

        return text

   150

   151

   152

def GetNormalizedString(attr, extract=True):

   153

    """

   154

    Function that normalizes a string according to XML 1.0. Replace

   155

    tabulations, line feed and carriage return by white space

   156

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

   157

    @param extract: attr is a tree node or not

   158

    @return: data normalized as string

   159

    """

   160

    if extract:

   161

        value = GetAttributeValue(attr)

   162

    else:

   163

        value = attr

   164

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

   165

   166

   167

def GetToken(attr, extract=True):

   168

    """

   169

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

   170

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

   171

    spaces by only one white space

   172

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

   173

    @param extract: attr is a tree node or not

   174

    @return: data tokenized as string

   175

    """

   176

    return " ".join([part for part in

   177

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

   178

                     if part])

   179

   180

   181

def GetHexInteger(attr, extract=True):

   182

    """

   183

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

   184

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

   185

    @param extract: attr is a tree node or not

   186

    @return: data as an integer

   187

    """

   188

    if extract:

   189

        value = GetAttributeValue(attr)

   190

    else:

   191

        value = attr

   192

    if len(value) % 2 != 0:

   193

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

   194

    try:

   195

        return int(value, 16)

   196

    except Exception:

   197

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

   198

   199

   200

def GenerateIntegerExtraction(minInclusive=None, maxInclusive=None,

   201

                              minExclusive=None, maxExclusive=None):

   202

    """

   203

    Function that generates an extraction function for integer defining min and

   204

    max of integer value

   205

    @param minInclusive: inclusive minimum

   206

    @param maxInclusive: inclusive maximum

   207

    @param minExclusive: exclusive minimum

   208

    @param maxExclusive: exclusive maximum

   209

    @return: function generated

   210

    """

   211

    def GetInteger(attr, extract=True):

   212

        """

   213

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

   214

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

   215

        @param extract: attr is a tree node or not

   216

        @return: data as an integer

   217

        """

   218

   219

        if extract:

   220

            value = GetAttributeValue(attr)

   221

        else:

   222

            value = attr

   223

        try:

   224

            # TODO: permit to write value like 1E2

   225

            value = int(value)

   226

        except Exception:

   227

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

   228

        if minInclusive is not None and value < minInclusive:

   229

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

   230

                             (value, minInclusive))

   231

        if maxInclusive is not None and value > maxInclusive:

   232

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

   233

                             (value, maxInclusive))

   234

        if minExclusive is not None and value <= minExclusive:

   235

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

   236

                             (value, minExclusive))

   237

        if maxExclusive is not None and value >= maxExclusive:

   238

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

   239

                             (value, maxExclusive))

   240

        return value

   241

    return GetInteger

   242

   243

   244

def GenerateFloatExtraction(type, extra_values=[]):

   245

    """

   246

    Function that generates an extraction function for float

   247

    @param type: name of the type of float

   248

    @return: function generated

   249

    """

   250

    def GetFloat(attr, extract=True):

   251

        """

   252

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

   253

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

   254

        @param extract: attr is a tree node or not

   255

        @return: data as a float

   256

        """

   257

        if extract:

   258

            value = GetAttributeValue(attr)

   259

        else:

   260

            value = attr

   261

        if value in extra_values:

   262

            return value

   263

        try:

   264

            return float(value)

   265

        except Exception:

   266

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

   267

    return GetFloat

   268

   269

   270

def GetBoolean(attr, extract=True):

   271

    """

   272

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

   273

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

   274

    @param extract: attr is a tree node or not

   275

    @return: data as a boolean

   276

    """

   277

    if extract:

   278

        value = GetAttributeValue(attr)

   279

    else:

   280

        value = attr

   281

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

   282

        return True

   283

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

   284

        return False

   285

    else:

   286

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

   287

   288

   289

def GetTime(attr, extract=True):

   290

    """

   291

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

   292

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

   293

    @param extract: attr is a tree node or not

   294

    @return: data as a time

   295

    """

   296

    if extract:

   297

        value = GetAttributeValue(attr)

   298

    else:

   299

        value = attr

   300

    result = time_model.match(value)

   301

    if result:

   302

        values = result.groups()

   303

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

   304

        seconds = float(values[2])

   305

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

   306

        return datetime.time(*time_values)

   307

    else:

   308

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

   309

   310

   311

def GetDate(attr, extract=True):

   312

    """

   313

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

   314

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

   315

    @param extract: attr is a tree node or not

   316

    @return: data as a date

   317

    """

   318

    if extract:

   319

        value = GetAttributeValue(attr)

   320

    else:

   321

        value = attr

   322

    result = date_model.match(value)

   323

    if result:

   324

        values = result.groups()

   325

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

   326

        if values[3] is not None:

   327

            tz = xml_timezone()

   328

            tz.SetOffset(values[3])

   329

            date_values.append(tz)

   330

        return datetime.date(*date_values)

   331

    else:

   332

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

   333

   334

   335

def GetDateTime(attr, extract=True):

   336

    """

   337

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

   338

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

   339

    @param extract: attr is a tree node or not

   340

    @return: data as date and time

   341

    """

   342

    if extract:

   343

        value = GetAttributeValue(attr)

   344

    else:

   345

        value = attr

   346

    result = datetime_model.match(value)

   347

    if result:

   348

        values = result.groups()

   349

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

   350

        seconds = float(values[5])

   351

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

   352

        if values[6] is not None:

   353

            tz = xml_timezone()

   354

            tz.SetOffset(values[6])

   355

            datetime_values.append(tz)

   356

        return datetime.datetime(*datetime_values)

   357

    else:

   358

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

   359

   360

   361

def GenerateModelNameExtraction(type, model):

   362

    """

   363

    Function that generates an extraction function for string matching a model

   364

    @param type: name of the data type

   365

    @param model: model that data must match

   366

    @return: function generated

   367

    """

   368

    def GetModelName(attr, extract=True):

   369

        """

   370

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

   371

        string extracted or given match the model

   372

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

   373

        @param extract: attr is a tree node or not

   374

        @return: data as a string if matching

   375

        """

   376

        if extract:

   377

            value = GetAttributeValue(attr)

   378

        else:

   379

            value = attr

   380

        result = model.match(value)

   381

        if not result:

   382

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

   383

        return value

   384

    return GetModelName

   385

   386

   387

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

   388

    """

   389

    Function that generates an extraction function for integer defining min and

   390

    max of integer value

   391

    @param min: minimum limit value

   392

    @param max: maximum limit value

   393

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

   394

    @return: function generated

   395

    """

   396

    def GetLimit(attr, extract=True):

   397

        """

   398

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

   399

        string extracted or given is in a list of values

   400

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

   401

        @param extract: attr is a tree node or not

   402

        @return: data as a string

   403

        """

   404

        if extract:

   405

            value = GetAttributeValue(attr)

   406

        else:

   407

            value = attr

   408

        if value == "unbounded":

   409

            if unbounded:

   410

                return value

   411

            else:

   412

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

   413

        try:

   414

            limit = int(value)

   415

        except Exception:

   416

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

   417

        if limit < 0:

   418

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

   419

        elif min is not None and limit < min:

   420

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

   421

        elif max is not None and limit > max:

   422

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

   423

        return limit

   424

    return GetLimit

   425

   426

   427

def GenerateEnumeratedExtraction(type, list):

   428

    """

   429

    Function that generates an extraction function for enumerated values

   430

    @param type: name of the data type

   431

    @param list: list of possible values

   432

    @return: function generated

   433

    """

   434

    def GetEnumerated(attr, extract=True):

   435

        """

   436

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

   437

        string extracted or given is in a list of values

   438

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

   439

        @param extract: attr is a tree node or not

   440

        @return: data as a string

   441

        """

   442

        if extract:

   443

            value = GetAttributeValue(attr)

   444

        else:

   445

            value = attr

   446

        if value in list:

   447

            return value

   448

        else:

   449

            raise ValueError(

   450

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

   451

    return GetEnumerated

   452

   453

   454

def GetNamespaces(attr, extract=True):

   455

    """

   456

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

   457

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

   458

    @param extract: attr is a tree node or not

   459

    @return: list of namespaces

   460

    """

   461

    if extract:

   462

        value = GetAttributeValue(attr)

   463

    else:

   464

        value = attr

   465

    if value == "":

   466

        return []

   467

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

   468

        namespaces = [value]

   469

    else:

   470

        namespaces = []

   471

        for item in value.split(" "):

   472

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

   473

                namespaces.append(item)

   474

            else:

   475

                result = URI_model.match(item)

   476

                if result is not None:

   477

                    namespaces.append(item)

   478

                else:

   479

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

   480

    return namespaces

   481

   482

   483

def GenerateGetList(type, list):

   484

    """

   485

    Function that generates an extraction function for a list of values

   486

    @param type: name of the data type

   487

    @param list: list of possible values

   488

    @return: function generated

   489

    """

   490

    def GetLists(attr, extract=True):

   491

        """

   492

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

   493

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

   494

        @param extract: attr is a tree node or not

   495

        @return: list of values

   496

        """

   497

        if extract:

   498

            value = GetAttributeValue(attr)

   499

        else:

   500

            value = attr

   501

        if value == "":

   502

            return []

   503

        elif value == "#all":

   504

            return [value]

   505

        else:

   506

            values = []

   507

            for item in value.split(" "):

   508

                if item in list:

   509

                    values.append(item)

   510

                else:

   511

                    raise ValueError(

   512

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

   513

            return values

   514

    return GetLists

   515

   516

   517

def GenerateModelNameListExtraction(type, model):

   518

    """

   519

    Function that generates an extraction function for list of string matching

   520

    a model