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 absolute_import

    27

from __future__ import print_function

    28

import os

    29

import re

    30

import datetime

    31

from types import *

    32

from xml.dom import minidom

    33

from xml.sax.saxutils import unescape

    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

    60

# Regular expression models for checking all kind of

    61

# string values defined in XML standard

    62

    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('((?:htt(p|ps)://|/)?(?:[\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 = datetime.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 = datetime.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 datetime.timedelta(0)

   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=None):

   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

    extra_values = [] if extra_values is None else extra_values

   251

   252

    def GetFloat(attr, extract=True):

   253

        """

   254

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

   255

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

   256

        @param extract: attr is a tree node or not

   257

        @return: data as a float

   258

        """

   259

        if extract:

   260

            value = GetAttributeValue(attr)

   261

        else:

   262

            value = attr

   263

        if value in extra_values:

   264

            return value

   265

        try:

   266

            return float(value)

   267

        except Exception:

   268

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

   269

    return GetFloat

   270

   271

   272

def GetBoolean(attr, extract=True):

   273

    """

   274

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

   275

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

   276

    @param extract: attr is a tree node or not

   277

    @return: data as a boolean

   278

    """

   279

    if extract:

   280

        value = GetAttributeValue(attr)

   281

    else:

   282

        value = attr

   283

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

   284

        return True

   285

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

   286

        return False

   287

    else:

   288

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

   289

   290

   291

def GetTime(attr, extract=True):

   292

    """

   293

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

   294

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

   295

    @param extract: attr is a tree node or not

   296

    @return: data as a time

   297

    """

   298

    if extract:

   299

        value = GetAttributeValue(attr)

   300

    else:

   301

        value = attr

   302

    result = time_model.match(value)

   303

    if result:

   304

        values = result.groups()

   305

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

   306

        seconds = float(values[2])

   307

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

   308

        return datetime.time(*time_values)

   309

    else:

   310

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

   311

   312

   313

def GetDate(attr, extract=True):

   314

    """

   315

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

   316

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

   317

    @param extract: attr is a tree node or not

   318

    @return: data as a date

   319

    """

   320

    if extract:

   321

        value = GetAttributeValue(attr)

   322

    else:

   323

        value = attr

   324

    result = date_model.match(value)

   325

    if result:

   326

        values = result.groups()

   327

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

   328

        if values[3] is not None:

   329

            tz = xml_timezone()

   330

            tz.SetOffset(values[3])

   331

            date_values.append(tz)

   332

        return datetime.date(*date_values)

   333

    else:

   334

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

   335

   336

   337

def GetDateTime(attr, extract=True):

   338

    """

   339

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

   340

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

   341

    @param extract: attr is a tree node or not

   342

    @return: data as date and time

   343

    """

   344

    if extract:

   345

        value = GetAttributeValue(attr)

   346

    else:

   347

        value = attr

   348

    result = datetime_model.match(value)

   349

    if result:

   350

        values = result.groups()

   351

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

   352

        seconds = float(values[5])

   353

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

   354

        if values[6] is not None:

   355

            tz = xml_timezone()

   356

            tz.SetOffset(values[6])

   357

            datetime_values.append(tz)

   358

        return datetime.datetime(*datetime_values)

   359

    else:

   360

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

   361

   362

   363

def GenerateModelNameExtraction(type, model):

   364

    """

   365

    Function that generates an extraction function for string matching a model

   366

    @param type: name of the data type

   367

    @param model: model that data must match

   368

    @return: function generated

   369

    """

   370

    def GetModelName(attr, extract=True):

   371

        """

   372

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

   373

        string extracted or given match the model

   374

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

   375

        @param extract: attr is a tree node or not

   376

        @return: data as a string if matching

   377

        """

   378

        if extract:

   379

            value = GetAttributeValue(attr)

   380

        else:

   381

            value = attr

   382

        result = model.match(value)

   383

        if not result:

   384

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

   385

        return value

   386

    return GetModelName

   387

   388

   389

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

   390

    """

   391

    Function that generates an extraction function for integer defining min and

   392

    max of integer value

   393

    @param min: minimum limit value

   394

    @param max: maximum limit value

   395

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

   396

    @return: function generated

   397

    """

   398

    def GetLimit(attr, extract=True):

   399

        """

   400

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

   401

        string extracted or given is in a list of values

   402

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

   403

        @param extract: attr is a tree node or not

   404

        @return: data as a string

   405

        """

   406

        if extract:

   407

            value = GetAttributeValue(attr)

   408

        else:

   409

            value = attr

   410

        if value == "unbounded":

   411

            if unbounded:

   412

                return value

   413

            else:

   414

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

   415

        try:

   416

            limit = int(value)

   417

        except Exception:

   418

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

   419

        if limit < 0:

   420

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

   421

        elif min is not None and limit < min:

   422

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

   423

        elif max is not None and limit > max:

   424

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

   425

        return limit

   426

    return GetLimit

   427

   428

   429

def GenerateEnumeratedExtraction(type, list):

   430

    """

   431

    Function that generates an extraction function for enumerated values

   432

    @param type: name of the data type

   433

    @param list: list of possible values

   434

    @return: function generated

   435

    """

   436

    def GetEnumerated(attr, extract=True):

   437

        """

   438

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

   439

        string extracted or given is in a list of values

   440

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

   441

        @param extract: attr is a tree node or not

   442

        @return: data as a string

   443

        """

   444

        if extract:

   445

            value = GetAttributeValue(attr)

   446

        else:

   447

            value = attr

   448

        if value in list:

   449

            return value

   450

        else:

   451

            raise ValueError(

   452

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

   453

    return GetEnumerated

   454

   455

   456

def GetNamespaces(attr, extract=True):

   457

    """

   458

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

   459

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

   460

    @param extract: attr is a tree node or not

   461

    @return: list of namespaces

   462

    """

   463

    if extract:

   464

        value = GetAttributeValue(attr)

   465

    else:

   466

        value = attr

   467

    if value == "":

   468

        return []

   469

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

   470

        namespaces = [value]

   471

    else:

   472

        namespaces = []

   473

        for item in value.split(" "):

   474

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

   475

                namespaces.append(item)

   476

            else:

   477

                result = URI_model.match(item)

   478

                if result is not None:

   479

                    namespaces.append(item)

   480

                else:

   481

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

   482

    return namespaces

   483

   484

   485

def GenerateGetList(type, list):

   486

    """

   487

    Function that generates an extraction function for a list of values

   488

    @param type: name of the data type

   489

    @param list: list of possible values

   490

    @return: function generated

   491

    """

   492

    def GetLists(attr, extract=True):

   493

        """

   494

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

   495

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

   496

        @param extract: attr is a tree node or not

   497

        @return: list of values

   498

        """

   499

        if extract:

   500

            value = GetAttributeValue(attr)

   501

        else:

   502

            value = attr

   503

        if value == "":

   504

            return []

   505

        elif value == "#all":

   506

            return [value]

   507

        else:

   508

            values = []

   509

            for item in value.split(" "):

   510

                if item in list:

   511

                    values.append(item)

   512

                else:

   513

                    raise ValueError(

   514

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

   515

            return values

   516

    return GetLists

   517

   518

   519

def GenerateModelNameListExtraction(type, model):