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 collections import OrderedDict

    35

from builtins import str as text

    36

    37

from six.moves import xrange

    38

from lxml import etree

    39

    40

    41

def CreateNode(name):

    42

    node = minidom.Node()

    43

    node.nodeName = name

    44

    node._attrs = {}

    45

    node.childNodes = []

    46

    return node

    47

    48

    49

def NodeRenameAttr(node, old_name, new_name):

    50

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

    51

    52

    53

def NodeSetAttr(node, name, value):

    54

    attr = minidom.Attr(name)

    55

    txt = minidom.Text()

    56

    txt.data = value

    57

    attr.childNodes[0] = txt

    58

    node._attrs[name] = attr

    59

    60

    61

# Regular expression models for checking all kind of

    62

# string values defined in XML standard

    63

    75

    76

"""

    77

Regular expression models for extracting dates and times from a string

    78

"""

    82

    83

    84

class xml_timezone(datetime.tzinfo):

    85

    86

    def SetOffset(self, offset):

    87

        if offset == "Z":

    88

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

    89

            self.__name = "UTC"

    90

        else:

    91

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

    92

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

    93

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

    94

            self.__name = ""

    95

    96

    def utcoffset(self, dt):

    97

        return self.__offset

    98

    99

    def tzname(self, dt):

   100

        return self.__name

   101

   102

    def dst(self, dt):

   103

        return datetime.timedelta(0)

   104

   105

   106

[

   107

    SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE,

   108

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

   109

] = range(13)

   110

   111

   112

def NotSupportedYet(type):

   113

    """

   114

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

   115

    used is not supported by xmlclass yet

   116

    @param type: data type

   117

    @return: function generated

   118

    """

   119

    def GetUnknownValue(attr):

   120

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

   121

    return GetUnknownValue

   122

   123

   124

def getIndent(indent, balise):

   125

    """

   126

    This function calculates the number of whitespace for indentation

   127

    """

   128

    first = indent * 2

   129

    second = first + len(balise) + 1

   130

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

   131

   132

   133

def GetAttributeValue(attr, extract=True):

   134

    """

   135

    Function that extracts data from a tree node

   136

    @param attr: tree node containing data to extract

   137

    @param extract: attr is a tree node or not

   138

    @return: data extracted as string

   139

    """

   140

    if not extract:

   141

        return attr

   142

    if len(attr.childNodes) == 1:

   143

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

   144

    else:

   145

        # content is a CDATA

   146

        txt = u''

   147

        for node in attr.childNodes:

   148

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

   149

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

   150

        return text

   151

   152

   153

def GetNormalizedString(attr, extract=True):

   154

    """

   155

    Function that normalizes a string according to XML 1.0. Replace

   156

    tabulations, line feed and carriage return by white space

   157

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

   158

    @param extract: attr is a tree node or not

   159

    @return: data normalized as string

   160

    """

   161

    if extract:

   162

        value = GetAttributeValue(attr)

   163

    else:

   164

        value = attr

   165

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

   166

   167

   168

def GetToken(attr, extract=True):

   169

    """

   170

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

   171

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

   172

    spaces by only one white space

   173

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

   174

    @param extract: attr is a tree node or not

   175

    @return: data tokenized as string

   176

    """

   177

    return " ".join([part for part in

   178

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

   179

                     if part])

   180

   181

   182

def GetHexInteger(attr, extract=True):

   183

    """

   184

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

   185

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

   186

    @param extract: attr is a tree node or not

   187

    @return: data as an integer

   188

    """

   189

    if extract:

   190

        value = GetAttributeValue(attr)

   191

    else:

   192

        value = attr

   193

    if len(value) % 2 != 0:

   194

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

   195

    try:

   196

        return int(value, 16)

   197

    except Exception:

   198

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

   199

   200

   201

def GenerateIntegerExtraction(minInclusive=None, maxInclusive=None,

   202

                              minExclusive=None, maxExclusive=None):

   203

    """

   204

    Function that generates an extraction function for integer defining min and

   205

    max of integer value

   206

    @param minInclusive: inclusive minimum

   207

    @param maxInclusive: inclusive maximum

   208

    @param minExclusive: exclusive minimum

   209

    @param maxExclusive: exclusive maximum

   210

    @return: function generated

   211

    """

   212

    def GetInteger(attr, extract=True):

   213

        """

   214

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

   215

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

   216

        @param extract: attr is a tree node or not

   217

        @return: data as an integer

   218

        """

   219

   220

        if extract:

   221

            value = GetAttributeValue(attr)

   222

        else:

   223

            value = attr

   224

        try:

   225

            # TODO: permit to write value like 1E2

   226

            value = int(value)

   227

        except Exception:

   228

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

   229

        if minInclusive is not None and value < minInclusive:

   230

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

   231

                             (value, minInclusive))

   232

        if maxInclusive is not None and value > maxInclusive:

   233

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

   234

                             (value, maxInclusive))

   235

        if minExclusive is not None and value <= minExclusive:

   236

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

   237

                             (value, minExclusive))

   238

        if maxExclusive is not None and value >= maxExclusive:

   239

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

   240

                             (value, maxExclusive))

   241

        return value

   242

    return GetInteger

   243

   244

   245

def GenerateFloatExtraction(type, extra_values=None):

   246

    """

   247

    Function that generates an extraction function for float

   248

    @param type: name of the type of float

   249

    @return: function generated

   250

    """

   251

    extra_values = [] if extra_values is None else extra_values

   252

   253

    def GetFloat(attr, extract=True):

   254

        """

   255

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

   256

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

   257

        @param extract: attr is a tree node or not

   258

        @return: data as a float

   259

        """

   260

        if extract:

   261

            value = GetAttributeValue(attr)

   262

        else:

   263

            value = attr

   264

        if value in extra_values:

   265

            return value

   266

        try:

   267

            return float(value)

   268

        except Exception:

   269

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

   270

    return GetFloat

   271

   272

   273

def GetBoolean(attr, extract=True):

   274

    """

   275

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

   276

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

   277

    @param extract: attr is a tree node or not

   278

    @return: data as a boolean

   279

    """

   280

    if extract:

   281

        value = GetAttributeValue(attr)

   282

    else:

   283

        value = attr

   284

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

   285

        return True

   286

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

   287

        return False

   288

    else:

   289

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

   290

   291

   292

def GetTime(attr, extract=True):

   293

    """

   294

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

   295

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

   296

    @param extract: attr is a tree node or not

   297

    @return: data as a time

   298

    """

   299

    if extract:

   300

        value = GetAttributeValue(attr)

   301

    else:

   302

        value = attr

   303

    result = time_model.match(value)

   304

    if result:

   305

        values = result.groups()

   306

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

   307

        seconds = float(values[2])

   308

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

   309

        return datetime.time(*time_values)

   310

    else:

   311

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

   312

   313

   314

def GetDate(attr, extract=True):

   315

    """

   316

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

   317

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

   318

    @param extract: attr is a tree node or not

   319

    @return: data as a date

   320

    """

   321

    if extract:

   322

        value = GetAttributeValue(attr)

   323

    else:

   324

        value = attr

   325

    result = date_model.match(value)

   326

    if result:

   327

        values = result.groups()

   328

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

   329

        if values[3] is not None:

   330

            tz = xml_timezone()

   331

            tz.SetOffset(values[3])

   332

            date_values.append(tz)

   333

        return datetime.date(*date_values)

   334

    else:

   335

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

   336

   337

   338

def GetDateTime(attr, extract=True):

   339

    """

   340

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

   341

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

   342

    @param extract: attr is a tree node or not

   343

    @return: data as date and time

   344

    """

   345

    if extract:

   346

        value = GetAttributeValue(attr)

   347

    else:

   348

        value = attr

   349

    result = datetime_model.match(value)

   350

    if result:

   351

        values = result.groups()

   352

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

   353

        seconds = float(values[5])

   354

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

   355

        if values[6] is not None:

   356

            tz = xml_timezone()

   357

            tz.SetOffset(values[6])

   358

            datetime_values.append(tz)

   359

        return datetime.datetime(*datetime_values)

   360

    else:

   361

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

   362

   363

   364

def GenerateModelNameExtraction(type, model):

   365

    """

   366

    Function that generates an extraction function for string matching a model

   367

    @param type: name of the data type

   368

    @param model: model that data must match

   369

    @return: function generated

   370

    """

   371

    def GetModelName(attr, extract=True):

   372

        """

   373

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

   374

        string extracted or given match the model

   375

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

   376

        @param extract: attr is a tree node or not

   377

        @return: data as a string if matching

   378

        """

   379

        if extract:

   380

            value = GetAttributeValue(attr)

   381

        else:

   382

            value = attr

   383

        result = model.match(value)

   384

        if not result:

   385

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

   386

        return value

   387

    return GetModelName

   388

   389

   390

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

   391

    """

   392

    Function that generates an extraction function for integer defining min and

   393

    max of integer value

   394

    @param min: minimum limit value

   395

    @param max: maximum limit value

   396

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

   397

    @return: function generated

   398

    """

   399

    def GetLimit(attr, extract=True):

   400

        """

   401

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

   402

        string extracted or given is in a list of values

   403

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

   404

        @param extract: attr is a tree node or not

   405

        @return: data as a string

   406

        """

   407

        if extract:

   408

            value = GetAttributeValue(attr)

   409

        else:

   410

            value = attr

   411

        if value == "unbounded":

   412

            if unbounded:

   413

                return value

   414

            else:

   415

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

   416

        try:

   417

            limit = int(value)

   418

        except Exception:

   419

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

   420

        if limit < 0:

   421

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

   422

        elif min is not None and limit < min:

   423

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

   424

        elif max is not None and limit > max:

   425

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

   426

        return limit

   427

    return GetLimit

   428

   429

   430

def GenerateEnumeratedExtraction(type, list):

   431

    """

   432

    Function that generates an extraction function for enumerated values

   433

    @param type: name of the data type

   434

    @param list: list of possible values

   435

    @return: function generated

   436

    """

   437

    def GetEnumerated(attr, extract=True):

   438

        """

   439

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

   440

        string extracted or given is in a list of values

   441

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

   442

        @param extract: attr is a tree node or not

   443

        @return: data as a string

   444

        """

   445

        if extract:

   446

            value = GetAttributeValue(attr)

   447

        else:

   448

            value = attr

   449

        if value in list:

   450

            return value

   451

        else:

   452

            raise ValueError(

   453

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

   454

    return GetEnumerated

   455

   456

   457

def GetNamespaces(attr, extract=True):

   458

    """

   459

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

   460

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

   461

    @param extract: attr is a tree node or not

   462

    @return: list of namespaces

   463

    """

   464

    if extract:

   465

        value = GetAttributeValue(attr)

   466

    else:

   467

        value = attr

   468

    if value == "":

   469

        return []

   470

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

   471

        namespaces = [value]

   472

    else:

   473

        namespaces = []

   474

        for item in value.split(" "):

   475

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

   476

                namespaces.append(item)

   477

            else:

   478

                result = URI_model.match(item)

   479

                if result is not None:

   480

                    namespaces.append(item)

   481

                else:

   482

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

   483

    return namespaces

   484

   485

   486

def GenerateGetList(type, list):

   487

    """

   488

    Function that generates an extraction function for a list of values

   489

    @param type: name of the data type

   490

    @param list: list of possible values

   491

    @return: function generated

   492

    """

   493

    def GetLists(attr, extract=True):

   494

        """

   495

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

   496

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

   497

        @param extract: attr is a tree node or not

   498

        @return: list of values

   499

        """

   500

        if extract:

   501

            value = GetAttributeValue(attr)

   502

        else:

   503

            value = attr

   504

        if value == "":

   505

            return []

   506

        elif value == "#all":

   507

            return [value]

   508

        else:

   509

            values = []

   510

            for item in value.split(" "):

   511

                if item in list:

   512

                    values.append(item)

   513

                else:

   514

                    raise ValueError(

   515

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

   516

            return values

   517

    return GetLists