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 re

    29

import datetime

    30

from types import *

    31

from xml.dom import minidom

    32

from xml.sax.saxutils import unescape

    33

from new import classobj

    34

from collections import OrderedDict

    35

    36

from lxml import etree

    37

    38

    39

def CreateNode(name):

    40

    node = minidom.Node()

    41

    node.nodeName = name

    42

    node._attrs = {}

    43

    node.childNodes = []

    44

    return node

    45

    46

    47

def NodeRenameAttr(node, old_name, new_name):

    48

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

    49

    50

    51

def NodeSetAttr(node, name, value):

    52

    attr = minidom.Attr(name)

    53

    text = minidom.Text()

    54

    text.data = value

    55

    attr.childNodes[0] = text

    56

    node._attrs[name] = attr

    57

    58

    59

# Regular expression models for checking all kind of

    60

# string values defined in XML standard

    61

    62

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

    63

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

    64

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

    65

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

    66

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

    67

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

    68

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

    69

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

    70

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

    71

    72

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

    73

    74

"""

    75

Regular expression models for extracting dates and times from a string

    76

"""

    77

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

    78

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

    79

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

    80

    81

    82

class xml_timezone(datetime.tzinfo):

    83

    84

    def SetOffset(self, offset):

    85

        if offset == "Z":

    87

            self.__name = "UTC"

    88

        else:

    89

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

    90

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

    92

            self.__name = ""

    93

    94

    def utcoffset(self, dt):

    95

        return self.__offset

    96

    97

    def tzname(self, dt):

    98

        return self.__name

    99

   100

    def dst(self, dt):

   102

   103

   104

[

   105

    SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE,

   106

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

   107

] = range(13)

   108

   109

   110

def NotSupportedYet(type):

   111

    """

   112

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

   113

    used is not supported by xmlclass yet

   114

    @param type: data type

   115

    @return: function generated

   116

    """

   117

    def GetUnknownValue(attr):

   118

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

   119

    return GetUnknownValue

   120

   121

   122

def getIndent(indent, balise):

   123

    """

   124

    This function calculates the number of whitespace for indentation

   125

    """

   126

    first = indent * 2

   127

    second = first + len(balise) + 1

   128

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

   129

   130

   131

def GetAttributeValue(attr, extract=True):

   132

    """

   133

    Function that extracts data from a tree node

   134

    @param attr: tree node containing data to extract

   135

    @param extract: attr is a tree node or not

   136

    @return: data extracted as string

   137

    """

   138

    if not extract:

   139

        return attr

   140

    if len(attr.childNodes) == 1:

   141

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

   142

    else:

   143

        # content is a CDATA

   144

        text = u''

   145

        for node in attr.childNodes:

   146

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

   147

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

   148

        return text

   149

   150

   151

def GetNormalizedString(attr, extract=True):

   152

    """

   153

    Function that normalizes a string according to XML 1.0. Replace

   154

    tabulations, line feed and carriage return by white space

   155

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

   156

    @param extract: attr is a tree node or not

   157

    @return: data normalized as string

   158

    """

   159

    if extract:

   160

        value = GetAttributeValue(attr)

   161

    else:

   162

        value = attr

   163

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

   164

   165

   166

def GetToken(attr, extract=True):

   167

    """

   168

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

   169

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

   170

    spaces by only one white space

   171

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

   172

    @param extract: attr is a tree node or not

   173

    @return: data tokenized as string

   174

    """

   175

    return " ".join([part for part in

   176

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

   177

                     if part])

   178

   179

   180

def GetHexInteger(attr, extract=True):

   181

    """

   182

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

   183

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

   184

    @param extract: attr is a tree node or not

   185

    @return: data as an integer

   186

    """

   187

    if extract:

   188

        value = GetAttributeValue(attr)

   189

    else:

   190

        value = attr

   191

    if len(value) % 2 != 0:

   192

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

   193

    try:

   194

        return int(value, 16)

   195

    except Exception:

   196

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

   197

   198

   199

def GenerateIntegerExtraction(minInclusive=None, maxInclusive=None,

   200

                              minExclusive=None, maxExclusive=None):

   201

    """

   202

    Function that generates an extraction function for integer defining min and

   203

    max of integer value

   204

    @param minInclusive: inclusive minimum

   205

    @param maxInclusive: inclusive maximum

   206

    @param minExclusive: exclusive minimum

   207

    @param maxExclusive: exclusive maximum

   208

    @return: function generated

   209

    """

   210

    def GetInteger(attr, extract=True):

   211

        """

   212

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

   213

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

   214

        @param extract: attr is a tree node or not

   215

        @return: data as an integer

   216

        """

   217

   218

        if extract:

   219

            value = GetAttributeValue(attr)

   220

        else:

   221

            value = attr

   222

        try:

   223

            # TODO: permit to write value like 1E2

   224

            value = int(value)

   225

        except Exception:

   226

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

   227

        if minInclusive is not None and value < minInclusive:

   228

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

   229

                             (value, minInclusive))

   230

        if maxInclusive is not None and value > maxInclusive:

   231

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

   232

                             (value, maxInclusive))

   233

        if minExclusive is not None and value <= minExclusive:

   234

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

   235

                             (value, minExclusive))

   236

        if maxExclusive is not None and value >= maxExclusive:

   237

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

   238

                             (value, maxExclusive))

   239

        return value

   240

    return GetInteger

   241

   242

   243

def GenerateFloatExtraction(type, extra_values=None):

   244

    """

   245

    Function that generates an extraction function for float

   246

    @param type: name of the type of float

   247

    @return: function generated

   248

    """

   249

    extra_values = [] if extra_values is None else extra_values

   250

   251

    def GetFloat(attr, extract=True):

   252

        """

   253

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

   254

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

   255

        @param extract: attr is a tree node or not

   256

        @return: data as a float

   257

        """

   258

        if extract:

   259

            value = GetAttributeValue(attr)

   260

        else:

   261

            value = attr

   262

        if value in extra_values:

   263

            return value

   264

        try:

   265

            return float(value)

   266

        except Exception:

   267

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

   268

    return GetFloat

   269

   270

   271

def GetBoolean(attr, extract=True):

   272

    """

   273

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

   274

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

   275

    @param extract: attr is a tree node or not

   276

    @return: data as a boolean

   277

    """

   278

    if extract:

   279

        value = GetAttributeValue(attr)

   280

    else:

   281

        value = attr

   282

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

   283

        return True

   284

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

   285

        return False

   286

    else:

   287

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

   288

   289

   290

def GetTime(attr, extract=True):

   291

    """

   292

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

   293

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

   294

    @param extract: attr is a tree node or not

   295

    @return: data as a time

   296

    """

   297

    if extract:

   298

        value = GetAttributeValue(attr)

   299

    else:

   300

        value = attr

   301

    result = time_model.match(value)

   302

    if result:

   303

        values = result.groups()

   304

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

   305

        seconds = float(values[2])

   306

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

   307

        return datetime.time(*time_values)

   308

    else:

   309

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

   310

   311

   312

def GetDate(attr, extract=True):

   313

    """

   314

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

   315

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

   316

    @param extract: attr is a tree node or not

   317

    @return: data as a date

   318

    """

   319

    if extract:

   320

        value = GetAttributeValue(attr)

   321

    else:

   322

        value = attr

   323

    result = date_model.match(value)

   324

    if result:

   325

        values = result.groups()

   326

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

   327

        if values[3] is not None:

   328

            tz = xml_timezone()

   329

            tz.SetOffset(values[3])

   330

            date_values.append(tz)

   331

        return datetime.date(*date_values)

   332

    else:

   333

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

   334

   335

   336

def GetDateTime(attr, extract=True):

   337

    """

   338

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

   339

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

   340

    @param extract: attr is a tree node or not

   341

    @return: data as date and time

   342

    """

   343

    if extract:

   344

        value = GetAttributeValue(attr)

   345

    else:

   346

        value = attr

   347

    result = datetime_model.match(value)

   348

    if result:

   349

        values = result.groups()

   350

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

   351

        seconds = float(values[5])

   352

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

   353

        if values[6] is not None:

   354

            tz = xml_timezone()

   355

            tz.SetOffset(values[6])

   356

            datetime_values.append(tz)

   357

        return datetime.datetime(*datetime_values)

   358

    else:

   359

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

   360

   361

   362

def GenerateModelNameExtraction(type, model):

   363

    """

   364

    Function that generates an extraction function for string matching a model

   365

    @param type: name of the data type

   366

    @param model: model that data must match

   367

    @return: function generated

   368

    """

   369

    def GetModelName(attr, extract=True):

   370

        """

   371

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

   372

        string extracted or given match the model

   373

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

   374

        @param extract: attr is a tree node or not

   375

        @return: data as a string if matching

   376

        """

   377

        if extract:

   378

            value = GetAttributeValue(attr)

   379

        else:

   380

            value = attr

   381

        result = model.match(value)

   382

        if not result:

   383

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

   384

        return value

   385

    return GetModelName

   386

   387

   388

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

   389

    """

   390

    Function that generates an extraction function for integer defining min and

   391

    max of integer value

   392

    @param min: minimum limit value

   393

    @param max: maximum limit value

   394

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

   395

    @return: function generated

   396

    """

   397

    def GetLimit(attr, extract=True):

   398

        """

   399

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

   400

        string extracted or given is in a list of values

   401

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

   402

        @param extract: attr is a tree node or not

   403

        @return: data as a string

   404

        """

   405

        if extract:

   406

            value = GetAttributeValue(attr)

   407

        else:

   408

            value = attr

   409

        if value == "unbounded":

   410

            if unbounded:

   411

                return value

   412

            else:

   413

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

   414

        try:

   415

            limit = int(value)

   416

        except Exception:

   417

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

   418

        if limit < 0:

   419

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

   420

        elif min is not None and limit < min:

   421

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

   422

        elif max is not None and limit > max:

   423

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

   424

        return limit

   425

    return GetLimit

   426

   427

   428

def GenerateEnumeratedExtraction(type, list):

   429

    """

   430

    Function that generates an extraction function for enumerated values

   431

    @param type: name of the data type

   432

    @param list: list of possible values

   433

    @return: function generated

   434

    """

   435

    def GetEnumerated(attr, extract=True):

   436

        """

   437

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

   438

        string extracted or given is in a list of values

   439

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

   440

        @param extract: attr is a tree node or not

   441

        @return: data as a string

   442

        """

   443

        if extract:

   444

            value = GetAttributeValue(attr)

   445

        else:

   446

            value = attr

   447

        if value in list:

   448

            return value

   449

        else:

   450

            raise ValueError(

   451

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

   452

    return GetEnumerated

   453

   454

   455

def GetNamespaces(attr, extract=True):

   456

    """

   457

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

   458

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

   459

    @param extract: attr is a tree node or not

   460

    @return: list of namespaces

   461

    """

   462

    if extract:

   463

        value = GetAttributeValue(attr)

   464

    else:

   465

        value = attr

   466

    if value == "":

   467

        return []

   468

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

   469

        namespaces = [value]

   470

    else:

   471

        namespaces = []

   472

        for item in value.split(" "):

   473

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

   474

                namespaces.append(item)

   475

            else:

   476

                result = URI_model.match(item)

   477

                if result is not None:

   478

                    namespaces.append(item)

   479

                else:

   480

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

   481

    return namespaces

   482

   483

   484

def GenerateGetList(type, list):

   485

    """

   486

    Function that generates an extraction function for a list of values

   487

    @param type: name of the data type

   488

    @param list: list of possible values

   489

    @return: function generated

   490

    """

   491

    def GetLists(attr, extract=True):

   492

        """

   493

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

   494

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

   495

        @param extract: attr is a tree node or not

   496

        @return: list of values

   497

        """

   498

        if extract:

   499

            value = GetAttributeValue(attr)

   500

        else:

   501

            value = attr

   502

        if value == "":

   503

            return []

   504

        elif value == "#all":

   505

            return [value]

   506

        else:

   507

            values = []

   508

            for item in value.split(" "):

   509

                if item in list:

   510

                    values.append(item)

   511

                else:

   512

                    raise ValueError(

   513

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

   514

            return values

   515

    return GetLists

   516

   517

   518

def GenerateModelNameListExtraction(type, model):

   519

    """

   520