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

import os

    27

import re

    28

import datetime

    29

from functools import reduce

    30

from xml.dom import minidom

    31

from xml.sax.saxutils import unescape

    32

from collections import OrderedDict

    33

    34

from lxml import etree

    35

    36

    37

def CreateNode(name):

    38

    node = minidom.Node()

    39

    node.nodeName = name

    40

    node._attrs = {}

    41

    node.childNodes = []

    42

    return node

    43

    44

    45

def NodeRenameAttr(node, old_name, new_name):

    46

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

    47

    48

    49

def NodeSetAttr(node, name, value):

    50

    attr = minidom.Attr(name)

    51

    txt = minidom.Text()

    52

    txt.data = value

    53

    attr.childNodes[0] = txt

    54

    node._attrs[name] = attr

    55

    56

    57

# Regular expression models for checking all kind of

    58

# string values defined in XML standard

    59

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

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

    67

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

    68

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

    69

    70

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

    71

    72

"""

    73

Regular expression models for extracting dates and times from a string

    74

"""

    75

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

    76

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

    77

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

    78

    79

    80

class xml_timezone(datetime.tzinfo):

    81

    82

    def SetOffset(self, offset):

    83

        if offset == "Z":

    84

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

    85

            self.__name = "UTC"

    86

        else:

    87

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

    88

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

    89

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

    90

            self.__name = ""

    91

    92

    def utcoffset(self, dt):

    93

        return self.__offset

    94

    95

    def tzname(self, dt):

    96

        return self.__name

    97

    98

    def dst(self, dt):

    99

        return datetime.timedelta(0)

   100

   101

   102

[

   103

    SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE,

   104

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

   105

] = list(range(13))

   106

   107

   108

def NotSupportedYet(type):

   109

    """

   110

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

   111

    used is not supported by xmlclass yet

   112

    @param type: data type

   113

    @return: function generated

   114

    """

   115

    def GetUnknownValue(attr):

   116

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

   117

    return GetUnknownValue

   118

   119

   120

def getIndent(indent, balise):

   121

    """

   122

    This function calculates the number of whitespace for indentation

   123

    """

   124

    first = indent * 2

   125

    second = first + len(balise) + 1

   126

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

   127

   128

   129

def GetAttributeValue(attr, extract=True):

   130

    """

   131

    Function that extracts data from a tree node

   132

    @param attr: tree node containing data to extract

   133

    @param extract: attr is a tree node or not

   134

    @return: data extracted as string

   135

    """

   136

    if not extract:

   137

        return attr

   138

    if len(attr.childNodes) == 1:

   139

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

   140

    else:

   141

        # content is a CDATA

   142

        txt = ''

   143

        for node in attr.childNodes:

   144

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

   145

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

   146

        return txt

   147

   148

   149

def GetNormalizedString(attr, extract=True):

   150

    """

   151

    Function that normalizes a string according to XML 1.0. Replace

   152

    tabulations, line feed and carriage return by white space

   153

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

   154

    @param extract: attr is a tree node or not

   155

    @return: data normalized as string

   156

    """

   157

    if extract:

   158

        value = GetAttributeValue(attr)

   159

    else:

   160

        value = attr

   161

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

   162

   163

   164

def GetToken(attr, extract=True):

   165

    """

   166

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

   167

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

   168

    spaces by only one white space

   169

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

   170

    @param extract: attr is a tree node or not

   171

    @return: data tokenized as string

   172

    """

   173

    return " ".join([part for part in

   174

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

   175

                     if part])

   176

   177

   178

def GetHexInteger(attr, extract=True):

   179

    """

   180

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

   181

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

   182

    @param extract: attr is a tree node or not

   183

    @return: data as an integer

   184

    """

   185

    if extract:

   186

        value = GetAttributeValue(attr)

   187

    else:

   188

        value = attr

   189

    if len(value) % 2 != 0:

   190

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

   191

    try:

   192

        return int(value, 16)

   193

    except Exception:

   194

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

   195

   196

   197

def GenerateIntegerExtraction(minInclusive=None, maxInclusive=None,

   198

                              minExclusive=None, maxExclusive=None):

   199

    """

   200

    Function that generates an extraction function for integer defining min and

   201

    max of integer value

   202

    @param minInclusive: inclusive minimum

   203

    @param maxInclusive: inclusive maximum

   204

    @param minExclusive: exclusive minimum

   205

    @param maxExclusive: exclusive maximum

   206

    @return: function generated

   207

    """

   208

    def GetInteger(attr, extract=True):

   209

        """

   210

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

   211

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

   212

        @param extract: attr is a tree node or not

   213

        @return: data as an integer

   214

        """

   215

   216

        if extract:

   217

            value = GetAttributeValue(attr)

   218

        else:

   219

            value = attr

   220

        try:

   221

            # TODO: permit to write value like 1E2

   222

            value = int(value)

   223

        except Exception:

   224

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

   225

        if minInclusive is not None and value < minInclusive:

   226

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

   227

                             (value, minInclusive))

   228

        if maxInclusive is not None and value > maxInclusive:

   229

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

   230

                             (value, maxInclusive))

   231

        if minExclusive is not None and value <= minExclusive:

   232

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

   233

                             (value, minExclusive))

   234

        if maxExclusive is not None and value >= maxExclusive:

   235

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

   236

                             (value, maxExclusive))

   237

        return value

   238

    return GetInteger

   239

   240

   241

def GenerateFloatExtraction(type, extra_values=None):

   242

    """

   243

    Function that generates an extraction function for float

   244

    @param type: name of the type of float

   245

    @return: function generated

   246

    """

   247

    extra_values = [] if extra_values is None else extra_values

   248

   249

    def GetFloat(attr, extract=True):

   250

        """

   251

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

   252

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

   253

        @param extract: attr is a tree node or not

   254

        @return: data as a float

   255

        """

   256

        if extract:

   257

            value = GetAttributeValue(attr)

   258

        else:

   259

            value = attr

   260

        if value in extra_values:

   261

            return value

   262

        try:

   263

            return float(value)

   264

        except Exception:

   265

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

   266

    return GetFloat

   267

   268

   269

def GetBoolean(attr, extract=True):

   270

    """

   271

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

   272

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

   273

    @param extract: attr is a tree node or not

   274

    @return: data as a boolean

   275

    """

   276

    if extract:

   277

        value = GetAttributeValue(attr)

   278

    else:

   279

        value = attr

   280

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

   281

        return True

   282

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

   283

        return False

   284

    else:

   285

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

   286

   287

   288

def GetTime(attr, extract=True):

   289

    """

   290

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

   291

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

   292

    @param extract: attr is a tree node or not

   293

    @return: data as a time

   294

    """

   295

    if extract:

   296

        value = GetAttributeValue(attr)

   297

    else:

   298

        value = attr

   299

    result = time_model.match(value)

   300

    if result:

   301

        values = result.groups()

   302

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

   303

        seconds = float(values[2])

   304

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

   305

        return datetime.time(*time_values)

   306

    else:

   307

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

   308

   309

   310

def GetDate(attr, extract=True):

   311

    """

   312

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

   313

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

   314

    @param extract: attr is a tree node or not

   315

    @return: data as a date

   316

    """

   317

    if extract:

   318

        value = GetAttributeValue(attr)

   319

    else:

   320

        value = attr

   321

    result = date_model.match(value)

   322

    if result:

   323

        values = result.groups()

   324

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

   325

        if values[3] is not None:

   326

            tz = xml_timezone()

   327

            tz.SetOffset(values[3])

   328

            date_values.append(tz)

   329

        return datetime.date(*date_values)

   330

    else:

   331

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

   332

   333

   334

def GetDateTime(attr, extract=True):

   335

    """

   336

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

   337

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

   338

    @param extract: attr is a tree node or not

   339

    @return: data as date and time

   340

    """

   341

    if extract:

   342

        value = GetAttributeValue(attr)

   343

    else:

   344

        value = attr

   345

    result = datetime_model.match(value)

   346

    if result:

   347

        values = result.groups()

   348

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

   349

        seconds = float(values[5])

   350

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

   351

        if values[6] is not None:

   352

            tz = xml_timezone()

   353

            tz.SetOffset(values[6])

   354

            datetime_values.append(tz)

   355

        return datetime.datetime(*datetime_values)

   356

    else:

   357

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

   358

   359

   360

def GenerateModelNameExtraction(type, model):

   361

    """

   362

    Function that generates an extraction function for string matching a model

   363

    @param type: name of the data type

   364

    @param model: model that data must match

   365

    @return: function generated

   366

    """

   367

    def GetModelName(attr, extract=True):

   368

        """

   369

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

   370

        string extracted or given match the model

   371

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

   372

        @param extract: attr is a tree node or not

   373

        @return: data as a string if matching

   374

        """

   375

        if extract:

   376

            value = GetAttributeValue(attr)

   377

        else:

   378

            value = attr

   379

        result = model.match(value)

   380

        if not result:

   381

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

   382

        return value

   383

    return GetModelName

   384

   385

   386

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

   387

    """

   388

    Function that generates an extraction function for integer defining min and

   389

    max of integer value

   390

    @param min: minimum limit value

   391

    @param max: maximum limit value

   392

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

   393

    @return: function generated

   394

    """

   395

    def GetLimit(attr, extract=True):

   396

        """

   397

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

   398

        string extracted or given is in a list of values

   399

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

   400

        @param extract: attr is a tree node or not

   401

        @return: data as a string

   402

        """

   403

        if extract:

   404

            value = GetAttributeValue(attr)

   405

        else:

   406

            value = attr

   407

        if value == "unbounded":

   408

            if unbounded:

   409

                return value

   410

            else:

   411

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

   412

        try:

   413

            limit = int(value)

   414

        except Exception:

   415

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

   416

        if limit < 0:

   417

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

   418

        elif min is not None and limit < min:

   419

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

   420

        elif max is not None and limit > max:

   421

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

   422

        return limit

   423

    return GetLimit

   424

   425

   426

def GenerateEnumeratedExtraction(type, list):

   427

    """

   428

    Function that generates an extraction function for enumerated values

   429

    @param type: name of the data type

   430

    @param list: list of possible values

   431

    @return: function generated

   432

    """

   433

    def GetEnumerated(attr, extract=True):

   434

        """

   435

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

   436

        string extracted or given is in a list of values

   437

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

   438

        @param extract: attr is a tree node or not

   439

        @return: data as a string

   440

        """

   441

        if extract:

   442

            value = GetAttributeValue(attr)

   443

        else:

   444

            value = attr

   445

        if value in list:

   446

            return value

   447

        else:

   448

            raise ValueError(

   449

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

   450

    return GetEnumerated

   451

   452

   453

def GetNamespaces(attr, extract=True):

   454

    """

   455

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

   456

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

   457

    @param extract: attr is a tree node or not

   458

    @return: list of namespaces

   459

    """

   460

    if extract:

   461

        value = GetAttributeValue(attr)

   462

    else:

   463

        value = attr

   464

    if value == "":

   465

        return []

   466

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

   467

        namespaces = [value]

   468

    else:

   469

        namespaces = []

   470

        for item in value.split(" "):

   471

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

   472

                namespaces.append(item)

   473

            else:

   474

                result = URI_model.match(item)

   475

                if result is not None:

   476

                    namespaces.append(item)

   477

                else:

   478

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

   479

    return namespaces

   480

   481

   482

def GenerateGetList(type, list):

   483

    """

   484

    Function that generates an extraction function for a list of values

   485

    @param type: name of the data type

   486

    @param list: list of possible values

   487

    @return: function generated

   488

    """

   489

    def GetLists(attr, extract=True):

   490

        """

   491

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

   492

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

   493

        @param extract: attr is a tree node or not

   494

        @return: list of values

   495

        """

   496

        if extract:

   497

            value = GetAttributeValue(attr)

   498

        else:

   499

            value = attr

   500

        if value == "":

   501

            return []

   502

        elif value == "#all":

   503

            return [value]

   504

        else:

   505

            values = []

   506

            for item in value.split(" "):

   507

                if item in list:

   508

                    values.append(item)

   509

                else:

   510

                    raise ValueError(

   511

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

   512

            return values

   513

    return GetLists

   514

   515

   516

def GenerateModelNameListExtraction(type, model):

   517

    """