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

import os

    26

import sys

    27

import re

    28

import datetime

    29

from types import *

    30

from xml.dom import minidom

    31

from xml.sax.saxutils import escape, unescape, quoteattr

    32

from lxml import etree

    33

from new import classobj

    34

from collections import OrderedDict

    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

    text = minidom.Text()

    52

    text.data = value

    53

    attr.childNodes[0] = text

    54

    node._attrs[name] = attr

    55

    56

    57

"""

    58

Regular expression models for checking all kind of string values defined in XML

    59

standard

    60

"""

    61

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

    62

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

    63

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

    64

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

    65

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

    66

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

    67

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

    68

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

    69

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

    70

    71

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

    72

    73

"""

    74

Regular expression models for extracting dates and times from a string

    75

"""

    76

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

    77

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

    78

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

    79

    80

    81

class xml_timezone(datetime.tzinfo):

    82

    83

    def SetOffset(self, offset):

    84

        if offset == "Z":

    85

            self.__offset = timedelta(minutes=0)

    86

            self.__name = "UTC"

    87

        else:

    88

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

    89

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

    90

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

    91

            self.__name = ""

    92

    93

    def utcoffset(self, dt):

    94

        return self.__offset

    95

    96

    def tzname(self, dt):

    97

        return self.__name

    98

    99

    def dst(self, dt):

   100

        return ZERO

   101

   102

   103

[SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE,

   104

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

   105

] = 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 u'\t'.expandtabs(first), u'\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 unicode(unescape(attr.childNodes[0].data))

   140

    else:

   141

        # content is a CDATA

   142

        text = u''

   143

        for node in attr.childNodes:

   144

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

   145

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

   146

        return text

   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:

   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:

   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=[]):

   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

    def GetFloat(attr, extract=True):

   248

        """

   249

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

   250

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

   251

        @param extract: attr is a tree node or not

   252

        @return: data as a float

   253

        """

   254

        if extract:

   255

            value = GetAttributeValue(attr)

   256

        else:

   257

            value = attr

   258

        if value in extra_values:

   259

            return value

   260

        try:

   261

            return float(value)

   262

        except:

   263

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

   264

    return GetFloat

   265

   266

   267

def GetBoolean(attr, extract=True):

   268

    """

   269

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

   270

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

   271

    @param extract: attr is a tree node or not

   272

    @return: data as a boolean

   273

    """

   274

    if extract:

   275

        value = GetAttributeValue(attr)

   276

    else:

   277

        value = attr

   278

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

   279

        return True

   280

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

   281

        return False

   282

    else:

   283

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

   284

   285

   286

def GetTime(attr, extract=True):

   287

    """

   288

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

   289

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

   290

    @param extract: attr is a tree node or not

   291

    @return: data as a time

   292

    """

   293

    if extract:

   294

        value = GetAttributeValue(attr)

   295

    else:

   296

        value = attr

   297

    result = time_model.match(value)

   298

    if result:

   299

        values = result.groups()

   300

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

   301

        seconds = float(values[2])

   302

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

   303

        return datetime.time(*time_values)

   304

    else:

   305

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

   306

   307

   308

def GetDate(attr, extract=True):

   309

    """

   310

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

   311

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

   312

    @param extract: attr is a tree node or not

   313

    @return: data as a date

   314

    """

   315

    if extract:

   316

        value = GetAttributeValue(attr)

   317

    else:

   318

        value = attr

   319

    result = date_model.match(value)

   320

    if result:

   321

        values = result.groups()

   322

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

   323

        if values[3] is not None:

   324

            tz = xml_timezone()

   325

            tz.SetOffset(values[3])

   326

            date_values.append(tz)

   327

        return datetime.date(*date_values)

   328

    else:

   329

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

   330

   331

   332

def GetDateTime(attr, extract=True):

   333

    """

   334

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

   335

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

   336

    @param extract: attr is a tree node or not

   337

    @return: data as date and time

   338

    """

   339

    if extract:

   340

        value = GetAttributeValue(attr)

   341

    else:

   342

        value = attr

   343

    result = datetime_model.match(value)

   344

    if result:

   345

        values = result.groups()

   346

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

   347

        seconds = float(values[5])

   348

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

   349

        if values[6] is not None:

   350

            tz = xml_timezone()

   351

            tz.SetOffset(values[6])

   352

            datetime_values.append(tz)

   353

        return datetime.datetime(*datetime_values)

   354

    else:

   355

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

   356

   357

   358

def GenerateModelNameExtraction(type, model):

   359

    """

   360

    Function that generates an extraction function for string matching a model

   361

    @param type: name of the data type

   362

    @param model: model that data must match

   363

    @return: function generated

   364

    """

   365

    def GetModelName(attr, extract=True):

   366

        """

   367

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

   368

        string extracted or given match the model

   369

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

   370

        @param extract: attr is a tree node or not

   371

        @return: data as a string if matching

   372

        """

   373

        if extract:

   374

            value = GetAttributeValue(attr)

   375

        else:

   376

            value = attr

   377

        result = model.match(value)

   378

        if not result:

   379

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

   380

        return value

   381

    return GetModelName

   382

   383

   384

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

   385

    """

   386

    Function that generates an extraction function for integer defining min and

   387

    max of integer value

   388

    @param min: minimum limit value

   389

    @param max: maximum limit value

   390

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

   391

    @return: function generated

   392

    """

   393

    def GetLimit(attr, extract=True):

   394

        """

   395

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

   396

        string extracted or given is in a list of values

   397

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

   398

        @param extract: attr is a tree node or not

   399

        @return: data as a string

   400

        """

   401

        if extract:

   402

            value = GetAttributeValue(attr)

   403

        else:

   404

            value = attr

   405

        if value == "unbounded":

   406

            if unbounded:

   407

                return value

   408

            else:

   409

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

   410

        try:

   411

            limit = int(value)

   412

        except:

   413

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

   414

        if limit < 0:

   415

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

   416

        elif min is not None and limit < min:

   417

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

   418

        elif max is not None and limit > max:

   419

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

   420

        return limit

   421

    return GetLimit

   422

   423

   424

def GenerateEnumeratedExtraction(type, list):

   425

    """

   426

    Function that generates an extraction function for enumerated values

   427

    @param type: name of the data type

   428

    @param list: list of possible values

   429

    @return: function generated

   430

    """

   431

    def GetEnumerated(attr, extract=True):

   432

        """

   433

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

   434

        string extracted or given is in a list of values

   435

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

   436

        @param extract: attr is a tree node or not

   437

        @return: data as a string

   438

        """

   439

        if extract:

   440

            value = GetAttributeValue(attr)

   441

        else:

   442

            value = attr

   443

        if value in list:

   444

            return value

   445

        else:

   446

            raise ValueError(

   447

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

   448

    return GetEnumerated

   449

   450

   451

def GetNamespaces(attr, extract=True):

   452

    """

   453

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

   454

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

   455

    @param extract: attr is a tree node or not

   456

    @return: list of namespaces

   457

    """

   458

    if extract:

   459

        value = GetAttributeValue(attr)

   460

    else:

   461

        value = attr

   462

    if value == "":

   463

        return []

   464

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

   465

        namespaces = [value]

   466

    else:

   467

        namespaces = []

   468

        for item in value.split(" "):

   469

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

   470

                namespaces.append(item)

   471

            else:

   472

                result = URI_model.match(item)

   473

                if result is not None:

   474

                    namespaces.append(item)

   475

                else:

   476

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

   477

    return namespaces

   478

   479

   480

def GenerateGetList(type, list):

   481

    """

   482

    Function that generates an extraction function for a list of values

   483

    @param type: name of the data type

   484

    @param list: list of possible values

   485

    @return: function generated

   486

    """

   487

    def GetLists(attr, extract=True):

   488

        """

   489

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

   490

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

   491

        @param extract: attr is a tree node or not

   492

        @return: list of values

   493

        """

   494

        if extract:

   495

            value = GetAttributeValue(attr)

   496

        else:

   497

            value = attr

   498

        if value == "":

   499

            return []

   500

        elif value == "#all":

   501

            return [value]

   502

        else:

   503

            values = []

   504

            for item in value.split(" "):

   505

                if item in list:

   506

                    values.append(item)

   507

                else:

   508

                    raise ValueError(

   509

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

   510

            return values

   511

    return GetLists

   512

   513

   514

def GenerateModelNameListExtraction(type, model):

   515

    """

   516

    Function that generates an extraction function for list of string matching

   517

    a model

   518

    @param type: name of the data type

   519

    @param model: model that list elements must match

   520

    @return: function generated

   521

    """

   522

    def GetModelNameList(attr, extract=True):