1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library 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 GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

import os, sys

    26

import re

    27

import datetime

    28

from types import *

    29

from xml.dom import minidom

    30

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

    31

from new import classobj

    32

    33

def CreateNode(name):

    34

    node = minidom.Node()

    35

    node.nodeName = name

    36

    node._attrs = {}

    37

    node.childNodes = []

    38

    return node

    39

    40

def NodeRenameAttr(node, old_name, new_name):

    41

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

    42

    43

def NodeSetAttr(node, name, value):

    44

    attr = minidom.Attr(name)

    45

    text = minidom.Text()

    46

    text.data = value

    47

    attr.childNodes[0] = text

    48

    node._attrs[name] = attr

    49

    50

"""

    51

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

    52

standard

    53

"""

    54

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

    55

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

    56

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

    57

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

    58

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

    59

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

    60

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

    61

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

    62

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

    63

    64

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

    65

    66

"""

    67

Regular expression models for extracting dates and times from a string

    68

"""

    69

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

    70

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

    71

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

    72

    73

class xml_timezone(datetime.tzinfo):

    74

    75

    def SetOffset(self, offset):

    76

        if offset == "Z":

    77

            self.__offset = timedelta(minutes = 0)

    78

            self.__name = "UTC"

    79

        else:

    80

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

    81

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

    82

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

    83

            self.__name = ""

    84

    85

    def utcoffset(self, dt):

    86

        return self.__offset

    87

    88

    def tzname(self, dt):

    89

        return self.__name

    90

    91

    def dst(self, dt):

    92

        return ZERO

    93

    94

[SYNTAXELEMENT, SYNTAXATTRIBUTE, SIMPLETYPE, COMPLEXTYPE, COMPILEDCOMPLEXTYPE, 

    95

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

    96

] = range(13)

    97

    98

def NotSupportedYet(type):

    99

    """

   100

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

   101

    used is not supported by xmlclass yet

   102

    @param type: data type

   103

    @return: function generated

   104

    """

   105

    def GetUnknownValue(attr):

   106

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

   107

                         type)

   108

    return GetUnknownValue

   109

   110

"""

   111

This function calculates the number of whitespace for indentation

   112

"""

   113

def getIndent(indent, balise):

   114

    first = indent * 2

   115

    second = first + len(balise) + 1

   116

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

   117

   118

   119

def GetAttributeValue(attr, extract=True):

   120

    """

   121

    Function that extracts data from a tree node

   122

    @param attr: tree node containing data to extract

   123

    @param extract: attr is a tree node or not

   124

    @return: data extracted as string

   125

    """

   126

    if not extract:

   127

        return attr

   128

    if len(attr.childNodes) == 1:

   129

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

   130

    else:

   131

        # content is a CDATA

   132

        text = u''

   133

        for node in attr.childNodes:

   134

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

   135

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

   136

        return text

   137

   138

   139

def GetNormalizedString(attr, extract=True):

   140

    """

   141

    Function that normalizes a string according to XML 1.0. Replace  

   142

    tabulations, line feed and carriage return by white space

   143

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

   144

    @param extract: attr is a tree node or not

   145

    @return: data normalized as string

   146

    """

   147

    if extract:

   148

        value = GetAttributeValue(attr)

   149

    else:

   150

        value = attr

   151

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

   152

   153

   154

def GetToken(attr, extract=True):

   155

    """

   156

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

   157

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

   158

    spaces by only one white space

   159

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

   160

    @param extract: attr is a tree node or not

   161

    @return: data tokenized as string

   162

    """

   163

    return " ".join([part for part in 

   164

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

   165

                     if part])

   166

   167

   168

def GetHexInteger(attr, extract=True):

   169

    """

   170

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

   171

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

   172

    @param extract: attr is a tree node or not

   173

    @return: data as an integer

   174

    """

   175

    if extract:

   176

        value = GetAttributeValue(attr)

   177

    else:

   178

        value = attr

   179

    if len(value) % 2 != 0:

   180

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

   181

    try:

   182

        return int(value, 16)

   183

    except:

   184

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

   185

   186

   187

def GenerateIntegerExtraction(minInclusive=None, maxInclusive=None, 

   188

                              minExclusive=None, maxExclusive=None):

   189

    """

   190

    Function that generates an extraction function for integer defining min and

   191

    max of integer value

   192

    @param minInclusive: inclusive minimum

   193

    @param maxInclusive: inclusive maximum

   194

    @param minExclusive: exclusive minimum

   195

    @param maxExclusive: exclusive maximum

   196

    @return: function generated

   197

    """

   198

    def GetInteger(attr, extract=True):

   199

        """

   200

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

   201

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

   202

        @param extract: attr is a tree node or not

   203

        @return: data as an integer

   204

        """

   205

   206

        if extract:

   207

            value = GetAttributeValue(attr)

   208

        else:

   209

            value = attr

   210

        try:

   211

            # TODO: permit to write value like 1E2

   212

            value = int(value)

   213

        except:

   214

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

   215

        if minInclusive is not None and value < minInclusive:

   216

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

   217

                             (value, minInclusive))

   218

        if maxInclusive is not None and value > maxInclusive:

   219

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

   220

                             (value, maxInclusive))

   221

        if minExclusive is not None and value <= minExclusive:

   222

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

   223

                             (value, minExclusive))

   224

        if maxExclusive is not None and value >= maxExclusive:

   225

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

   226

                             (value, maxExclusive))

   227

        return value

   228

    return GetInteger

   229

   230

   231

def GenerateFloatExtraction(type, extra_values=[]):

   232

    """

   233

    Function that generates an extraction function for float

   234

    @param type: name of the type of float

   235

    @return: function generated

   236

    """

   237

    def GetFloat(attr, extract = True):

   238

        """

   239

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

   240

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

   241

        @param extract: attr is a tree node or not

   242

        @return: data as a float

   243

        """

   244

        if extract:

   245

            value = GetAttributeValue(attr)

   246

        else:

   247

            value = attr

   248

        if value in extra_values:

   249

            return value

   250

        try:

   251

            return float(value)

   252

        except:

   253

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

   254

    return GetFloat

   255

   256

   257

def GetBoolean(attr, extract=True):

   258

    """

   259

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

   260

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

   261

    @param extract: attr is a tree node or not

   262

    @return: data as a boolean

   263

    """

   264

    if extract:

   265

        value = GetAttributeValue(attr)

   266

    else:

   267

        value = attr

   268

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

   269

        return True

   270

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

   271

        return False

   272

    else:

   273

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

   274

   275

   276

def GetTime(attr, extract=True):

   277

    """

   278

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

   279

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

   280

    @param extract: attr is a tree node or not

   281

    @return: data as a time

   282

    """

   283

    if extract:

   284

        value = GetAttributeValue(attr)

   285

    else:

   286

        value = attr

   287

    result = time_model.match(value)

   288

    if result:

   289

        values = result.groups()

   290

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

   291

        seconds = float(values[2])

   292

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

   293

        return datetime.time(*time_values)

   294

    else:

   295

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

   296

   297

   298

def GetDate(attr, extract=True):

   299

    """

   300

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

   301

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

   302

    @param extract: attr is a tree node or not

   303

    @return: data as a date

   304

    """

   305

    if extract:

   306

        value = GetAttributeValue(attr)

   307

    else:

   308

        value = attr

   309

    result = date_model.match(value)

   310

    if result:

   311

        values = result.groups()

   312

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

   313

        if values[3] is not None:

   314

            tz = xml_timezone()

   315

            tz.SetOffset(values[3])

   316

            date_values.append(tz)

   317

        return datetime.date(*date_values)

   318

    else:

   319

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

   320

   321

   322

def GetDateTime(attr, extract=True):

   323

    """

   324

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

   325

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

   326

    @param extract: attr is a tree node or not

   327

    @return: data as date and time

   328

    """

   329

    if extract:

   330

        value = GetAttributeValue(attr)

   331

    else:

   332

        value = attr

   333

    result = datetime_model.match(value)

   334

    if result:

   335

        values = result.groups()

   336

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

   337

        seconds = float(values[5])

   338

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

   339

        if values[6] is not None:

   340

            tz = xml_timezone()

   341

            tz.SetOffset(values[6])

   342

            datetime_values.append(tz)

   343

        return datetime.datetime(*datetime_values)

   344

    else:

   345

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

   346

   347

   348

def GenerateModelNameExtraction(type, model):

   349

    """

   350

    Function that generates an extraction function for string matching a model

   351

    @param type: name of the data type

   352

    @param model: model that data must match

   353

    @return: function generated

   354

    """

   355

    def GetModelName(attr, extract=True):

   356

        """

   357

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

   358

        string extracted or given match the model

   359

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

   360

        @param extract: attr is a tree node or not

   361

        @return: data as a string if matching

   362

        """

   363

        if extract:

   364

            value = GetAttributeValue(attr)

   365

        else:

   366

            value = attr

   367

        result = model.match(value)

   368

        if not result:

   369

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

   370

        return value

   371

    return GetModelName

   372

   373

   374

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

   375

    """

   376

    Function that generates an extraction function for integer defining min and

   377

    max of integer value

   378

    @param min: minimum limit value

   379

    @param max: maximum limit value

   380

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

   381

    @return: function generated

   382

    """

   383

    def GetLimit(attr, extract=True):

   384

        """

   385

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

   386

        string extracted or given is in a list of values

   387

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

   388

        @param extract: attr is a tree node or not

   389

        @return: data as a string

   390

        """

   391

        if extract:

   392

            value = GetAttributeValue(attr)

   393

        else:

   394

            value = attr

   395

        if value == "unbounded":

   396

            if unbounded:

   397

                return value

   398

            else:

   399

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

   400

        try:

   401

            limit = int(value)

   402

        except:

   403

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

   404

        if limit < 0:

   405

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

   406

        elif min is not None and limit < min:

   407

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

   408

        elif max is not None and limit > max:

   409

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

   410

        return limit

   411

    return GetLimit

   412

   413

   414

def GenerateEnumeratedExtraction(type, list):

   415

    """

   416

    Function that generates an extraction function for enumerated values

   417

    @param type: name of the data type

   418

    @param list: list of possible values

   419

    @return: function generated

   420

    """

   421

    def GetEnumerated(attr, extract=True):

   422

        """

   423

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

   424

        string extracted or given is in a list of values

   425

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

   426

        @param extract: attr is a tree node or not

   427

        @return: data as a string

   428

        """

   429

        if extract:

   430

            value = GetAttributeValue(attr)

   431

        else:

   432

            value = attr

   433

        if value in list:

   434

            return value

   435

        else:

   436

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

   437

                             (value, type))

   438

    return GetEnumerated

   439

   440

   441

def GetNamespaces(attr, extract=True):

   442

    """

   443

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

   444

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

   445

    @param extract: attr is a tree node or not

   446

    @return: list of namespaces

   447

    """

   448

    if extract:

   449

        value = GetAttributeValue(attr)

   450

    else:

   451

        value = attr

   452

    if value == "":

   453

        return []

   454

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

   455

        namespaces = [value]

   456

    else:

   457

        namespaces = []

   458

        for item in value.split(" "):

   459

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

   460

                namespaces.append(item)

   461

            else:

   462

                result = URI_model.match(item)

   463

                if result is not None:

   464

                    namespaces.append(item)

   465

                else:

   466

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

   467

    return namespaces

   468

   469

   470

def GenerateGetList(type, list):

   471

    """

   472

    Function that generates an extraction function for a list of values

   473

    @param type: name of the data type

   474

    @param list: list of possible values

   475

    @return: function generated

   476

    """

   477

    def GetLists(attr, extract=True):

   478

        """

   479

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

   480

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

   481

        @param extract: attr is a tree node or not

   482

        @return: list of values

   483

        """

   484

        if extract:

   485

            value = GetAttributeValue(attr)

   486

        else:

   487

            value = attr

   488

        if value == "":

   489

            return []

   490

        elif value == "#all":

   491

            return [value]

   492

        else:

   493

            values = []

   494

            for item in value.split(" "):

   495

                if item in list:

   496

                    values.append(item)

   497

                else:

   498

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

   499

                                     (value, type))

   500

            return values

   501

    return GetLists

   502

   503

   504

def GenerateModelNameListExtraction(type, model):

   505

    """

   506

    Function that generates an extraction function for list of string matching

   507

    a model

   508

    @param type: name of the data type

   509

    @param model: model that list elements must match

   510

    @return: function generated

   511

    """

   512

    def GetModelNameList(attr, extract=True):

   513

        """

   514

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

   515

        check that all extracted items match the model

   516

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

   517

        @param extract: attr is a tree node or not

   518

        @return: data as a list of string if matching 

   519

        """

   520

        if extract:

   521

            value = GetAttributeValue(attr)

   522

        else:

   523

            value = attr

   524

        values = []

   525

        for item in value.split(" "):

   526

            result = model.match(item)

   527

            if result is not None:

   528

                values.append(item)

   529