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 xml.dom import minidom

    32

from xml.sax.saxutils import unescape

    33

from collections import OrderedDict

    34

from builtins import str as text

    35

from functools import reduce

    36

    37

from six import string_types

    38

from six.moves import xrange

    39

from lxml import etree

    40

    41

    42

def CreateNode(name):

    43

    node = minidom.Node()

    44

    node.nodeName = name

    45

    node._attrs = {}

    46

    node.childNodes = []

    47

    return node

    48

    49

    50

def NodeRenameAttr(node, old_name, new_name):

    51

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

    52

    53

    54

def NodeSetAttr(node, name, value):

    55

    attr = minidom.Attr(name)

    56

    txt = minidom.Text()

    57

    txt.data = value

    58

    attr.childNodes[0] = txt

    59

    node._attrs[name] = attr

    60

    61

    62

# Regular expression models for checking all kind of

    63

# string values defined in XML standard

    64

    65

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

    66

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

    67

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

    68

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

    69

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

    70

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

    71

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

    72

URI_model = re.compile(r'((?:htt(p|ps)://|/)?(?:[\w.-]*/?)*)$')

    73

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

    74

    75

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

    76

    77

"""

    78

Regular expression models for extracting dates and times from a string

    79

"""

    80

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

    81

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

    82

datetime_model = re.compile(r'([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)?$')

    83

    84

    85

class xml_timezone(datetime.tzinfo):

    86

    87

    def SetOffset(self, offset):

    88

        if offset == "Z":

    89

            self.__offset = datetime.timedelta(minutes=0)

    90

            self.__name = "UTC"

    91

        else:

    92

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

    93

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

    94

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

    95

            self.__name = ""

    96

    97

    def utcoffset(self, dt):

    98

        return self.__offset

    99

   100

    def tzname(self, dt):

   101

        return self.__name

   102

   103

    def dst(self, dt):

   104

        return datetime.timedelta(0)

   105

   106

   107

[

   108

    SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE,

   109

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

   110

] = range(13)

   111

   112

   113

def NotSupportedYet(type):

   114

    """

   115

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

   116

    used is not supported by xmlclass yet

   117

    @param type: data type

   118

    @return: function generated

   119

    """

   120

    def GetUnknownValue(attr):

   121

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

   122

    return GetUnknownValue

   123

   124

   125

def getIndent(indent, balise):

   126

    """

   127

    This function calculates the number of whitespace for indentation

   128

    """

   129

    first = indent * 2

   130

    second = first + len(balise) + 1

   131

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

   132

   133

   134

def GetAttributeValue(attr, extract=True):

   135

    """

   136

    Function that extracts data from a tree node

   137

    @param attr: tree node containing data to extract

   138

    @param extract: attr is a tree node or not

   139

    @return: data extracted as string

   140

    """

   141

    if not extract:

   142

        return attr

   143

    if len(attr.childNodes) == 1:

   144

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

   145

    else:

   146

        # content is a CDATA

   147

        txt = u''

   148

        for node in attr.childNodes:

   149

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

   150

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

   151

        return text

   152

   153

   154

def GetNormalizedString(attr, extract=True):

   155

    """

   156

    Function that normalizes a string according to XML 1.0. Replace

   157

    tabulations, line feed and carriage return by white space

   158

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

   159

    @param extract: attr is a tree node or not

   160

    @return: data normalized as string

   161

    """

   162

    if extract:

   163

        value = GetAttributeValue(attr)

   164

    else:

   165

        value = attr

   166

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

   167

   168

   169

def GetToken(attr, extract=True):

   170

    """

   171

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

   172

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

   173

    spaces by only one white space

   174

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

   175

    @param extract: attr is a tree node or not

   176

    @return: data tokenized as string

   177

    """

   178

    return " ".join([part for part in

   179

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

   180

                     if part])

   181

   182

   183

def GetHexInteger(attr, extract=True):

   184

    """

   185

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

   186

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

   187

    @param extract: attr is a tree node or not

   188

    @return: data as an integer

   189

    """

   190

    if extract:

   191

        value = GetAttributeValue(attr)

   192

    else:

   193

        value = attr

   194

    if len(value) % 2 != 0:

   195

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

   196

    try:

   197

        return int(value, 16)

   198

    except Exception:

   199

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

   200

   201

   202

def GenerateIntegerExtraction(minInclusive=None, maxInclusive=None,

   203

                              minExclusive=None, maxExclusive=None):

   204

    """

   205

    Function that generates an extraction function for integer defining min and

   206

    max of integer value

   207

    @param minInclusive: inclusive minimum

   208

    @param maxInclusive: inclusive maximum

   209

    @param minExclusive: exclusive minimum

   210

    @param maxExclusive: exclusive maximum

   211

    @return: function generated

   212

    """

   213

    def GetInteger(attr, extract=True):

   214

        """

   215

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

   216

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

   217

        @param extract: attr is a tree node or not

   218

        @return: data as an integer

   219

        """

   220

   221

        if extract:

   222

            value = GetAttributeValue(attr)

   223

        else:

   224

            value = attr

   225

        try:

   226

            # TODO: permit to write value like 1E2

   227

            value = int(value)

   228

        except Exception:

   229

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

   230

        if minInclusive is not None and value < minInclusive:

   231

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

   232

                             (value, minInclusive))

   233

        if maxInclusive is not None and value > maxInclusive:

   234

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

   235

                             (value, maxInclusive))

   236

        if minExclusive is not None and value <= minExclusive:

   237

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

   238

                             (value, minExclusive))

   239

        if maxExclusive is not None and value >= maxExclusive:

   240

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

   241

                             (value, maxExclusive))

   242

        return value

   243

    return GetInteger

   244

   245

   246

def GenerateFloatExtraction(type, extra_values=None):

   247

    """

   248

    Function that generates an extraction function for float

   249

    @param type: name of the type of float

   250

    @return: function generated

   251

    """

   252

    extra_values = [] if extra_values is None else extra_values

   253

   254

    def GetFloat(attr, extract=True):

   255

        """

   256

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

   257

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

   258

        @param extract: attr is a tree node or not

   259

        @return: data as a float

   260

        """

   261

        if extract:

   262

            value = GetAttributeValue(attr)

   263

        else:

   264

            value = attr

   265

        if value in extra_values:

   266

            return value

   267

        try:

   268

            return float(value)

   269

        except Exception:

   270

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

   271

    return GetFloat

   272

   273

   274

def GetBoolean(attr, extract=True):

   275

    """

   276

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

   277

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

   278

    @param extract: attr is a tree node or not

   279

    @return: data as a boolean

   280

    """

   281

    if extract:

   282

        value = GetAttributeValue(attr)

   283

    else:

   284

        value = attr

   285

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

   286

        return True

   287

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

   288

        return False

   289

    else:

   290

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

   291

   292

   293

def GetTime(attr, extract=True):

   294

    """

   295

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

   296

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

   297

    @param extract: attr is a tree node or not

   298

    @return: data as a time

   299

    """

   300

    if extract:

   301

        value = GetAttributeValue(attr)

   302

    else:

   303

        value = attr

   304

    result = time_model.match(value)

   305

    if result:

   306

        values = result.groups()

   307

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

   308

        seconds = float(values[2])

   309

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

   310

        return datetime.time(*time_values)

   311

    else:

   312

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

   313

   314

   315

def GetDate(attr, extract=True):

   316

    """

   317

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

   318

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

   319

    @param extract: attr is a tree node or not

   320

    @return: data as a date

   321

    """

   322

    if extract:

   323

        value = GetAttributeValue(attr)

   324

    else:

   325

        value = attr

   326

    result = date_model.match(value)

   327

    if result:

   328

        values = result.groups()

   329

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

   330

        if values[3] is not None:

   331

            tz = xml_timezone()

   332

            tz.SetOffset(values[3])

   333

            date_values.append(tz)

   334

        return datetime.date(*date_values)

   335

    else:

   336

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

   337

   338

   339

def GetDateTime(attr, extract=True):

   340

    """

   341

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

   342

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

   343

    @param extract: attr is a tree node or not

   344

    @return: data as date and time

   345

    """

   346

    if extract:

   347

        value = GetAttributeValue(attr)

   348

    else:

   349

        value = attr

   350

    result = datetime_model.match(value)

   351

    if result:

   352

        values = result.groups()

   353

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

   354

        seconds = float(values[5])

   355

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

   356

        if values[6] is not None:

   357

            tz = xml_timezone()

   358

            tz.SetOffset(values[6])

   359

            datetime_values.append(tz)

   360

        return datetime.datetime(*datetime_values)

   361

    else:

   362

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

   363

   364

   365

def GenerateModelNameExtraction(type, model):

   366

    """

   367

    Function that generates an extraction function for string matching a model

   368

    @param type: name of the data type

   369

    @param model: model that data must match

   370

    @return: function generated

   371

    """

   372

    def GetModelName(attr, extract=True):

   373

        """

   374

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

   375

        string extracted or given match the model

   376

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

   377

        @param extract: attr is a tree node or not

   378

        @return: data as a string if matching

   379

        """

   380

        if extract:

   381

            value = GetAttributeValue(attr)

   382

        else:

   383

            value = attr

   384

        result = model.match(value)

   385

        if not result:

   386

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

   387

        return value

   388

    return GetModelName

   389

   390

   391

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

   392

    """

   393

    Function that generates an extraction function for integer defining min and

   394

    max of integer value

   395

    @param min: minimum limit value

   396

    @param max: maximum limit value

   397

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

   398

    @return: function generated

   399

    """

   400

    def GetLimit(attr, extract=True):

   401

        """

   402

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

   403

        string extracted or given is in a list of values

   404

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

   405

        @param extract: attr is a tree node or not

   406

        @return: data as a string

   407

        """

   408

        if extract:

   409

            value = GetAttributeValue(attr)

   410

        else:

   411

            value = attr

   412

        if value == "unbounded":

   413

            if unbounded:

   414

                return value

   415

            else:

   416

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

   417

        try:

   418

            limit = int(value)

   419

        except Exception:

   420

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

   421

        if limit < 0:

   422

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

   423

        elif min is not None and limit < min:

   424

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

   425

        elif max is not None and limit > max:

   426

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

   427

        return limit

   428

    return GetLimit

   429

   430

   431

def GenerateEnumeratedExtraction(type, list):

   432

    """

   433

    Function that generates an extraction function for enumerated values

   434

    @param type: name of the data type

   435

    @param list: list of possible values

   436

    @return: function generated

   437

    """

   438

    def GetEnumerated(attr, extract=True):

   439

        """

   440

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

   441

        string extracted or given is in a list of values

   442

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

   443

        @param extract: attr is a tree node or not

   444

        @return: data as a string

   445

        """

   446

        if extract:

   447

            value = GetAttributeValue(attr)

   448

        else:

   449

            value = attr

   450

        if value in list:

   451

            return value

   452

        else:

   453

            raise ValueError(

   454

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

   455

    return GetEnumerated

   456

   457

   458

def GetNamespaces(attr, extract=True):

   459

    """

   460

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

   461

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

   462

    @param extract: attr is a tree node or not

   463

    @return: list of namespaces

   464

    """

   465

    if extract:

   466

        value = GetAttributeValue(attr)

   467

    else:

   468

        value = attr

   469

    if value == "":

   470

        return []

   471

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

   472

        namespaces = [value]

   473

    else:

   474

        namespaces = []

   475

        for item in value.split(" "):

   476

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

   477

                namespaces.append(item)

   478

            else:

   479

                result = URI_model.match(item)

   480

                if result is not None:

   481

                    namespaces.append(item)

   482

                else:

   483

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

   484

    return namespaces

   485

   486

   487

def GenerateGetList(type, list):

   488

    """

   489

    Function that generates an extraction function for a list of values

   490

    @param type: name of the data type

   491

    @param list: list of possible values

   492

    @return: function generated

   493

    """

   494

    def GetLists(attr, extract=True):

   495

        """

   496

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

   497

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

   498

        @param extract: attr is a tree node or not

   499

        @return: list of values

   500

        """

   501

        if extract:

   502

            value = GetAttributeValue(attr)

   503

        else:

   504

            value = attr

   505

        if value == "":

   506

            return []

   507

        elif value == "#all":

   508

            return [value]

   509

        else:

   510

            values = []

   511

            for item in value.split(" "):

   512

                if item in list:

   513

                    values.append(item)

   514

                else:

   515

                    raise ValueError(

   516

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

   517

            return values