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!" % \

   117

                         type)

   118

    return GetUnknownValue

   119

   120

   121

def getIndent(indent, balise):

   122

    """

   123

    This function calculates the number of whitespace for indentation

   124

    """

   125

    first = indent * 2

   126

    second = first + len(balise) + 1

   127

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

   128

   129

   130

def GetAttributeValue(attr, extract=True):

   131

    """

   132

    Function that extracts data from a tree node

   133

    @param attr: tree node containing data to extract

   134

    @param extract: attr is a tree node or not

   135

    @return: data extracted as string

   136

    """

   137

    if not extract:

   138

        return attr

   139

    if len(attr.childNodes) == 1:

   140

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

   141

    else:

   142

        # content is a CDATA

   143

        text = u''

   144

        for node in attr.childNodes:

   145

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

   146

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

   147

        return text

   148

   149

   150

def GetNormalizedString(attr, extract=True):

   151

    """

   152

    Function that normalizes a string according to XML 1.0. Replace

   153

    tabulations, line feed and carriage return by white space

   154

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

   155

    @param extract: attr is a tree node or not

   156

    @return: data normalized as string

   157

    """

   158

    if extract:

   159

        value = GetAttributeValue(attr)

   160

    else:

   161

        value = attr

   162

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

   163

   164

   165

def GetToken(attr, extract=True):

   166

    """

   167

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

   168

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

   169

    spaces by only one white space

   170

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

   171

    @param extract: attr is a tree node or not

   172

    @return: data tokenized as string

   173

    """

   174

    return " ".join([part for part in

   175

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

   176

                     if part])

   177

   178

   179

def GetHexInteger(attr, extract=True):

   180

    """

   181

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

   182

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

   183

    @param extract: attr is a tree node or not

   184

    @return: data as an integer

   185

    """

   186

    if extract:

   187

        value = GetAttributeValue(attr)

   188

    else:

   189

        value = attr

   190

    if len(value) % 2 != 0:

   191

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

   192

    try:

   193

        return int(value, 16)

   194

    except:

   195

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

   196

   197

   198

def GenerateIntegerExtraction(minInclusive=None, maxInclusive=None,

   199

                              minExclusive=None, maxExclusive=None):

   200

    """

   201

    Function that generates an extraction function for integer defining min and

   202

    max of integer value

   203

    @param minInclusive: inclusive minimum

   204

    @param maxInclusive: inclusive maximum

   205

    @param minExclusive: exclusive minimum

   206

    @param maxExclusive: exclusive maximum

   207

    @return: function generated

   208

    """

   209

    def GetInteger(attr, extract=True):

   210

        """

   211

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

   212

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

   213

        @param extract: attr is a tree node or not

   214

        @return: data as an integer

   215

        """

   216

   217

        if extract:

   218

            value = GetAttributeValue(attr)

   219

        else:

   220

            value = attr

   221

        try:

   222

            # TODO: permit to write value like 1E2

   223

            value = int(value)

   224

        except:

   225

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

   226

        if minInclusive is not None and value < minInclusive:

   227

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

   228

                             (value, minInclusive))

   229

        if maxInclusive is not None and value > maxInclusive:

   230

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

   231

                             (value, maxInclusive))

   232

        if minExclusive is not None and value <= minExclusive:

   233

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

   234

                             (value, minExclusive))

   235

        if maxExclusive is not None and value >= maxExclusive:

   236

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

   237

                             (value, maxExclusive))

   238

        return value

   239

    return GetInteger

   240

   241

   242

def GenerateFloatExtraction(type, extra_values=[]):

   243

    """

   244

    Function that generates an extraction function for float

   245

    @param type: name of the type of float

   246

    @return: function generated

   247

    """

   248

    def GetFloat(attr, extract=True):

   249

        """

   250

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

   251

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

   252

        @param extract: attr is a tree node or not

   253

        @return: data as a float

   254

        """

   255

        if extract:

   256

            value = GetAttributeValue(attr)

   257

        else:

   258

            value = attr

   259

        if value in extra_values:

   260

            return value

   261

        try:

   262

            return float(value)

   263

        except:

   264

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

   265

    return GetFloat

   266

   267

   268

def GetBoolean(attr, extract=True):

   269

    """

   270

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

   271

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

   272

    @param extract: attr is a tree node or not

   273

    @return: data as a boolean

   274

    """

   275

    if extract:

   276

        value = GetAttributeValue(attr)

   277

    else:

   278

        value = attr

   279

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

   280

        return True

   281

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

   282

        return False

   283

    else:

   284

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

   285

   286

   287

def GetTime(attr, extract=True):

   288

    """

   289

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

   290

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

   291

    @param extract: attr is a tree node or not

   292

    @return: data as a time

   293

    """

   294

    if extract:

   295

        value = GetAttributeValue(attr)

   296

    else:

   297

        value = attr

   298

    result = time_model.match(value)

   299

    if result:

   300

        values = result.groups()

   301

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

   302

        seconds = float(values[2])

   303

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

   304

        return datetime.time(*time_values)

   305

    else:

   306

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

   307

   308

   309

def GetDate(attr, extract=True):

   310

    """

   311

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

   312

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

   313

    @param extract: attr is a tree node or not

   314

    @return: data as a date

   315

    """

   316

    if extract:

   317

        value = GetAttributeValue(attr)

   318

    else:

   319

        value = attr

   320

    result = date_model.match(value)

   321

    if result:

   322

        values = result.groups()

   323

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

   324

        if values[3] is not None:

   325

            tz = xml_timezone()

   326

            tz.SetOffset(values[3])

   327

            date_values.append(tz)

   328

        return datetime.date(*date_values)

   329

    else:

   330

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

   331

   332

   333

def GetDateTime(attr, extract=True):

   334

    """

   335

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

   336

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

   337

    @param extract: attr is a tree node or not

   338

    @return: data as date and time

   339

    """

   340

    if extract:

   341

        value = GetAttributeValue(attr)

   342

    else:

   343

        value = attr

   344

    result = datetime_model.match(value)

   345

    if result:

   346

        values = result.groups()

   347

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

   348

        seconds = float(values[5])

   349

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

   350

        if values[6] is not None:

   351

            tz = xml_timezone()

   352

            tz.SetOffset(values[6])

   353

            datetime_values.append(tz)

   354

        return datetime.datetime(*datetime_values)

   355

    else:

   356

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

   357

   358

   359

def GenerateModelNameExtraction(type, model):

   360

    """

   361

    Function that generates an extraction function for string matching a model

   362

    @param type: name of the data type

   363

    @param model: model that data must match

   364

    @return: function generated

   365

    """

   366

    def GetModelName(attr, extract=True):

   367

        """

   368

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

   369

        string extracted or given match the model

   370

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

   371

        @param extract: attr is a tree node or not

   372

        @return: data as a string if matching

   373

        """

   374

        if extract:

   375

            value = GetAttributeValue(attr)

   376

        else:

   377

            value = attr

   378

        result = model.match(value)

   379

        if not result:

   380

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

   381

        return value

   382

    return GetModelName

   383

   384

   385

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

   386

    """

   387

    Function that generates an extraction function for integer defining min and

   388

    max of integer value

   389

    @param min: minimum limit value

   390

    @param max: maximum limit value

   391

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

   392

    @return: function generated

   393

    """

   394

    def GetLimit(attr, extract=True):

   395

        """

   396

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

   397

        string extracted or given is in a list of values

   398

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

   399

        @param extract: attr is a tree node or not

   400

        @return: data as a string

   401

        """

   402

        if extract:

   403

            value = GetAttributeValue(attr)

   404

        else:

   405

            value = attr

   406

        if value == "unbounded":

   407

            if unbounded:

   408

                return value

   409

            else:

   410

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

   411

        try:

   412

            limit = int(value)

   413

        except:

   414

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

   415

        if limit < 0:

   416

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

   417

        elif min is not None and limit < min:

   418

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

   419

        elif max is not None and limit > max:

   420

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

   421

        return limit

   422

    return GetLimit

   423

   424

   425

def GenerateEnumeratedExtraction(type, list):

   426

    """

   427

    Function that generates an extraction function for enumerated values

   428

    @param type: name of the data type

   429

    @param list: list of possible values

   430

    @return: function generated

   431

    """

   432

    def GetEnumerated(attr, extract=True):

   433

        """

   434

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

   435

        string extracted or given is in a list of values

   436

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

   437

        @param extract: attr is a tree node or not

   438

        @return: data as a string

   439

        """

   440

        if extract:

   441

            value = GetAttributeValue(attr)

   442

        else:

   443

            value = attr

   444

        if value in list:

   445

            return value

   446

        else:

   447

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

   448

                             (value, type))

   449

    return GetEnumerated

   450

   451

   452

def GetNamespaces(attr, extract=True):

   453

    """

   454

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

   455

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

   456

    @param extract: attr is a tree node or not

   457

    @return: list of namespaces

   458

    """

   459

    if extract:

   460

        value = GetAttributeValue(attr)

   461

    else:

   462

        value = attr

   463

    if value == "":

   464

        return []

   465

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

   466

        namespaces = [value]

   467

    else:

   468

        namespaces = []

   469

        for item in value.split(" "):

   470

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

   471

                namespaces.append(item)

   472

            else:

   473

                result = URI_model.match(item)

   474

                if result is not None:

   475

                    namespaces.append(item)

   476

                else:

   477

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

   478

    return namespaces

   479

   480

   481

def GenerateGetList(type, list):

   482

    """

   483

    Function that generates an extraction function for a list of values

   484

    @param type: name of the data type

   485

    @param list: list of possible values

   486

    @return: function generated

   487

    """

   488

    def GetLists(attr, extract=True):

   489

        """

   490

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

   491

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

   492

        @param extract: attr is a tree node or not

   493

        @return: list of values

   494

        """

   495

        if extract:

   496

            value = GetAttributeValue(attr)

   497

        else:

   498

            value = attr

   499

        if value == "":

   500

            return []

   501

        elif value == "#all":

   502

            return [value]

   503

        else:

   504

            values = []

   505

            for item in value.split(" "):

   506

                if item in list:

   507

                    values.append(item)

   508

                else:

   509

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

   510

                                     (value, type))

   511

            return values

   512

    return GetLists

   513

   514

   515

def GenerateModelNameListExtraction(type, model):

   516

    """

   517

    Function that generates an extraction function for list of string matching

   518

    a model

   519

    @param type: name of the data type

   520

    @param model: model that list elements must match

   521

    @return: function generated

   522

    """

   523

    def GetModelNameList(attr, extract=True):

   524