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

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

    58

standard

    59

"""

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

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

    67

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

    68

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

    69

    70

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

    71

    72

"""

    73

Regular expression models for extracting dates and times from a string

    74

"""

    75

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

    76

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

    77

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

    78

    79

    80

class xml_timezone(datetime.tzinfo):

    81

    82

    def SetOffset(self, offset):

    83

        if offset == "Z":

    84

            self.__offset = timedelta(minutes = 0)

    85

            self.__name = "UTC"

    86

        else:

    88

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

    89

            self.__offset = 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 ZERO

   100

   101

[SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE,

   102

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

   103

] = range(13)

   104

   105

   106

def NotSupportedYet(type):

   107

    """

   108

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

   109

    used is not supported by xmlclass yet

   110

    @param type: data type

   111

    @return: function generated

   112

    """

   113

    def GetUnknownValue(attr):

   114

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

   115

                         type)

   116

    return GetUnknownValue

   117

   118

   119

def getIndent(indent, balise):

   120

    """

   121

    This function calculates the number of whitespace for indentation

   122

    """

   123

    first = indent * 2

   124

    second = first + len(balise) + 1

   125

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

   126

   127

   128

def GetAttributeValue(attr, extract=True):

   129

    """

   130

    Function that extracts data from a tree node

   131

    @param attr: tree node containing data to extract

   132

    @param extract: attr is a tree node or not

   133

    @return: data extracted as string

   134

    """

   135

    if not extract:

   136

        return attr

   137

    if len(attr.childNodes) == 1:

   138

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

   139

    else:

   140

        # content is a CDATA

   141

        text = u''

   142

        for node in attr.childNodes:

   143

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

   144

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

   145

        return text

   146

   147

   148

def GetNormalizedString(attr, extract=True):

   149

    """

   150

    Function that normalizes a string according to XML 1.0. Replace

   151

    tabulations, line feed and carriage return by white space

   152

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

   153

    @param extract: attr is a tree node or not

   154

    @return: data normalized as string

   155

    """

   156

    if extract:

   157

        value = GetAttributeValue(attr)

   158

    else:

   159

        value = attr

   160

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

   161

   162

   163

def GetToken(attr, extract=True):

   164

    """

   165

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

   166

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

   167

    spaces by only one white space

   168

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

   169

    @param extract: attr is a tree node or not

   170

    @return: data tokenized as string

   171

    """

   172

    return " ".join([part for part in

   173

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

   174

                     if part])

   175

   176

   177

def GetHexInteger(attr, extract=True):

   178

    """

   179

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

   180

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

   181

    @param extract: attr is a tree node or not

   182

    @return: data as an integer

   183

    """

   184

    if extract:

   185

        value = GetAttributeValue(attr)

   186

    else:

   187

        value = attr

   188

    if len(value) % 2 != 0:

   189

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

   190

    try:

   191

        return int(value, 16)

   192

    except:

   193

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

   194

   195

   196

def GenerateIntegerExtraction(minInclusive=None, maxInclusive=None,

   197

                              minExclusive=None, maxExclusive=None):

   198

    """

   199

    Function that generates an extraction function for integer defining min and

   200

    max of integer value

   201

    @param minInclusive: inclusive minimum

   202

    @param maxInclusive: inclusive maximum

   203

    @param minExclusive: exclusive minimum

   204

    @param maxExclusive: exclusive maximum

   205

    @return: function generated

   206

    """

   207

    def GetInteger(attr, extract=True):

   208

        """

   209

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

   210

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

   211

        @param extract: attr is a tree node or not

   212

        @return: data as an integer

   213

        """

   214

   215

        if extract:

   216

            value = GetAttributeValue(attr)

   217

        else:

   218

            value = attr

   219

        try:

   220

            # TODO: permit to write value like 1E2

   221

            value = int(value)

   222

        except:

   223

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

   224

        if minInclusive is not None and value < minInclusive:

   225

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

   226

                             (value, minInclusive))

   227

        if maxInclusive is not None and value > maxInclusive:

   228

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

   229

                             (value, maxInclusive))

   230

        if minExclusive is not None and value <= minExclusive:

   231

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

   232

                             (value, minExclusive))

   233

        if maxExclusive is not None and value >= maxExclusive:

   234

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

   235

                             (value, maxExclusive))

   236

        return value

   237

    return GetInteger

   238

   239

   240

def GenerateFloatExtraction(type, extra_values=[]):

   241

    """

   242

    Function that generates an extraction function for float

   243

    @param type: name of the type of float

   244

    @return: function generated

   245

    """

   246

    def GetFloat(attr, extract = True):

   247

        """

   248

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

   249

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

   250

        @param extract: attr is a tree node or not

   251

        @return: data as a float

   252

        """

   253

        if extract:

   254

            value = GetAttributeValue(attr)

   255

        else:

   256

            value = attr

   257

        if value in extra_values:

   258

            return value

   259

        try:

   260

            return float(value)

   261

        except:

   262

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

   263

    return GetFloat

   264

   265

   266

def GetBoolean(attr, extract=True):

   267

    """

   268

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

   269

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

   270

    @param extract: attr is a tree node or not

   271

    @return: data as a boolean

   272

    """

   273

    if extract:

   274

        value = GetAttributeValue(attr)

   275

    else:

   276

        value = attr

   277

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

   278

        return True

   279

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

   280

        return False

   281

    else:

   282

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

   283

   284

   285

def GetTime(attr, extract=True):

   286

    """

   287

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

   288

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

   289

    @param extract: attr is a tree node or not

   290

    @return: data as a time

   291

    """

   292

    if extract:

   293

        value = GetAttributeValue(attr)

   294

    else:

   295

        value = attr

   296

    result = time_model.match(value)

   297

    if result:

   298

        values = result.groups()

   299

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

   300

        seconds = float(values[2])

   301

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

   302

        return datetime.time(*time_values)

   303

    else:

   304

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

   305

   306

   307

def GetDate(attr, extract=True):

   308

    """

   309

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

   310

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

   311

    @param extract: attr is a tree node or not

   312

    @return: data as a date

   313

    """

   314

    if extract:

   315

        value = GetAttributeValue(attr)

   316

    else:

   317

        value = attr

   318

    result = date_model.match(value)

   319

    if result:

   320

        values = result.groups()

   321

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

   322

        if values[3] is not None:

   323

            tz = xml_timezone()

   324

            tz.SetOffset(values[3])

   325

            date_values.append(tz)

   326

        return datetime.date(*date_values)

   327

    else:

   328

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

   329

   330

   331

def GetDateTime(attr, extract=True):

   332

    """

   333

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

   334

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

   335

    @param extract: attr is a tree node or not

   336

    @return: data as date and time

   337

    """

   338

    if extract:

   339

        value = GetAttributeValue(attr)

   340

    else:

   341

        value = attr

   342

    result = datetime_model.match(value)

   343

    if result:

   344

        values = result.groups()

   345

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

   346

        seconds = float(values[5])

   347

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

   348

        if values[6] is not None:

   349

            tz = xml_timezone()

   350

            tz.SetOffset(values[6])

   351

            datetime_values.append(tz)

   352

        return datetime.datetime(*datetime_values)

   353

    else:

   354

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

   355

   356

   357

def GenerateModelNameExtraction(type, model):

   358

    """

   359

    Function that generates an extraction function for string matching a model

   360

    @param type: name of the data type

   361

    @param model: model that data must match

   362

    @return: function generated

   363

    """

   364

    def GetModelName(attr, extract=True):

   365

        """

   366

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

   367

        string extracted or given match the model

   368

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

   369

        @param extract: attr is a tree node or not

   370

        @return: data as a string if matching

   371

        """

   372

        if extract:

   373

            value = GetAttributeValue(attr)

   374

        else:

   375

            value = attr

   376

        result = model.match(value)

   377

        if not result:

   378

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

   379

        return value

   380

    return GetModelName

   381

   382

   383

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

   384

    """

   385

    Function that generates an extraction function for integer defining min and

   386

    max of integer value

   387

    @param min: minimum limit value

   388

    @param max: maximum limit value

   389

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

   390

    @return: function generated

   391

    """

   392

    def GetLimit(attr, extract=True):

   393

        """

   394

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

   395

        string extracted or given is in a list of values

   396

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

   397

        @param extract: attr is a tree node or not

   398

        @return: data as a string

   399

        """

   400

        if extract:

   401

            value = GetAttributeValue(attr)

   402

        else:

   403

            value = attr

   404

        if value == "unbounded":

   405

            if unbounded:

   406

                return value

   407

            else:

   408

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

   409

        try:

   410

            limit = int(value)

   411

        except:

   412

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

   413

        if limit < 0:

   414

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

   415

        elif min is not None and limit < min:

   416

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

   417

        elif max is not None and limit > max:

   418

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

   419

        return limit

   420

    return GetLimit

   421

   422

   423

def GenerateEnumeratedExtraction(type, list):

   424

    """

   425

    Function that generates an extraction function for enumerated values

   426

    @param type: name of the data type

   427

    @param list: list of possible values

   428

    @return: function generated

   429

    """

   430

    def GetEnumerated(attr, extract=True):

   431

        """

   432

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

   433

        string extracted or given is in a list of values

   434

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

   435

        @param extract: attr is a tree node or not

   436

        @return: data as a string

   437

        """

   438

        if extract:

   439

            value = GetAttributeValue(attr)

   440

        else:

   441

            value = attr

   442

        if value in list:

   443

            return value

   444

        else:

   445

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

   446

                             (value, type))

   447

    return GetEnumerated

   448

   449

   450

def GetNamespaces(attr, extract=True):

   451

    """

   452

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

   453

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

   454

    @param extract: attr is a tree node or not

   455

    @return: list of namespaces

   456

    """

   457

    if extract:

   458

        value = GetAttributeValue(attr)

   459

    else:

   460

        value = attr

   461

    if value == "":

   462

        return []

   463

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

   464

        namespaces = [value]

   465

    else:

   466

        namespaces = []

   467

        for item in value.split(" "):

   468

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

   469

                namespaces.append(item)

   470

            else:

   471

                result = URI_model.match(item)

   472

                if result is not None:

   473

                    namespaces.append(item)

   474

                else:

   475

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

   476

    return namespaces

   477

   478

   479

def GenerateGetList(type, list):

   480

    """

   481

    Function that generates an extraction function for a list of values

   482

    @param type: name of the data type

   483

    @param list: list of possible values

   484

    @return: function generated

   485

    """

   486

    def GetLists(attr, extract=True):

   487

        """

   488

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

   489

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

   490

        @param extract: attr is a tree node or not

   491

        @return: list of values

   492

        """

   493

        if extract:

   494

            value = GetAttributeValue(attr)

   495

        else:

   496

            value = attr

   497

        if value == "":

   498

            return []

   499

        elif value == "#all":

   500

            return [value]

   501

        else:

   502

            values = []

   503

            for item in value.split(" "):

   504

                if item in list:

   505

                    values.append(item)

   506

                else:

   507

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

   508

                                     (value, type))

   509

            return values

   510

    return GetLists

   511

   512

   513

def GenerateModelNameListExtraction(type, model):

   514

    """

   515

    Function that generates an extraction function for list of string matching

   516

    a model

   517

    @param type: name of the data type

   518

    @param model: model that list elements must match

   519

    @return: function generated

   520

    """

   521

    def GetModelNameList(attr, extract=True):

   522

        """

   523

        Function that extracts a list of string from a tree node or not and

   524

        check that all extracted items match the model