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 absolute_import

    27

from __future__ import print_function

    28

import os

    29

import re

    30

import datetime

    31

from xml.dom import minidom

    32

from types import *

    33

    34

from xmlclass.xmlclass import *

    35

    36

    37

def GenerateDictFacets(facets):

    38

    return dict([(name, (None, False)) for name in facets])

    39

    40

    41

def GenerateSimpleTypeXMLText(function):

    42

    def generateXMLTextMethod(value, name=None, indent=0):

    43

        text = ""

    44

        if name is not None:

    45

            ind1, _ind2 = getIndent(indent, name)

    46

            text += ind1 + "<%s>" % name

    47

        text += function(value)

    48

        if name is not None:

    49

            text += "</%s>\n" % name

    50

        return text

    51

    return generateXMLTextMethod

    52

    53

    54

def GenerateFloatXMLText(extra_values=None, decimal=None):

    55

    float_format = (lambda x: "{:.{width}f}".format(x, width=decimal).rstrip('0')

    56

                    if decimal is not None else str)

    57

    extra_values = [] if extra_values is None else extra_values

    58

    59

    def generateXMLTextMethod(value, name=None, indent=0):

    60

        text = ""

    61

        if name is not None:

    62

            ind1, _ind2 = getIndent(indent, name)

    63

            text += ind1 + "<%s>" % name

    64

        if isinstance(value, IntType):

    65

            text += str(value)

    66

        elif value in extra_values or value % 1 != 0:

    67

            text += float_format(value)

    68

        else:

    69

            text += "{:.0f}".format(value)

    70

        if name is not None:

    71

            text += "</%s>\n" % name

    72

        return text

    73

    return generateXMLTextMethod

    74

    75

    76

DEFAULT_FACETS = GenerateDictFacets(["pattern", "whiteSpace", "enumeration"])

    77

NUMBER_FACETS = GenerateDictFacets(DEFAULT_FACETS.keys() + ["maxInclusive", "maxExclusive", "minInclusive", "minExclusive"])

    78

DECIMAL_FACETS = GenerateDictFacets(NUMBER_FACETS.keys() + ["totalDigits", "fractionDigits"])

    79

STRING_FACETS = GenerateDictFacets(DEFAULT_FACETS.keys() + ["length", "minLength", "maxLength"])

    80

    81

ALL_FACETS = ["pattern", "whiteSpace", "enumeration", "maxInclusive",

    82

              "maxExclusive", "minInclusive", "minExclusive", "totalDigits",

    83

              "fractionDigits", "length", "minLength", "maxLength"]

    84

    85

    86

# -------------------------------------------------------------------------------

    87

#                           Structure reducing functions

    88

# -------------------------------------------------------------------------------

    89

    90

    91

# Documentation elements

    92

    93

def ReduceAppInfo(factory, attributes, elements):

    94

    return {"type": "appinfo", "source": attributes.get("source", None),

    95

            "content": "\n".join(elements)}

    96

    97

    98

def ReduceDocumentation(factory, attributes, elements):

    99

    return {"type": "documentation", "source": attributes.get("source", None),

   100

            "language": attributes.get("lang", "any"), "content": "\n".join(elements)}

   101

   102

   103

def ReduceAnnotation(factory, attributes, elements):

   104

    _annotations, children = factory.ReduceElements(elements)

   105

    annotation = {"type": "annotation", "appinfo": [], "documentation": {}}

   106

    for child in children:

   107

        if child["type"] == "appinfo":

   108

            annotation["appinfo"].append((child["source"], child["content"]))

   109

        elif child["type"] == "documentation":

   110

            if child["source"] is not None:

   111

                text = "(source: %(source)s):\n%(content)s\n\n" % child

   112

            else:

   113

                text = child["content"] + "\n\n"

   114

            if not child["language"] in annotation["documentation"]:

   115

                annotation["documentation"] = text

   116

            else:

   117

                annotation["documentation"] += text

   118

    return annotation

   119

   120

# Simple type elements

   121

   122

   123

def GenerateFacetReducing(facetname, canbefixed):

   124

    def ReduceFacet(factory, attributes, elements):

   125

        annotations, _children = factory.ReduceElements(elements)

   126

        if "value" in attributes:

   127

            facet = {"type": facetname, "value": attributes["value"], "doc": annotations}

   128

            if canbefixed:

   129

                facet["fixed"] = attributes.get("fixed", False)

   130

            return facet

   131

        raise ValueError("A value must be defined for the \"%s\" facet!" % facetname)

   132

    return ReduceFacet

   133

   134

   135

def ReduceList(factory, attributes, elements):

   136

    annotations, children = factory.ReduceElements(elements)

   137

    list = {"type": "list", "itemType": attributes.get("itemType", None), "doc": annotations}

   138

   139

    if len(children) > 0 and children[0]["type"] == SIMPLETYPE:

   140

        if list["itemType"] is None:

   141

            list["itemType"] = children[0]

   142

        else:

   143

            raise ValueError("Only one base type can be defined for restriction!")

   144

    if list["itemType"] is None:

   145

        raise ValueError("No base type has been defined for list!")

   146

    return list

   147

   148

   149

def ReduceUnion(factory, attributes, elements):

   150

    annotations, children = factory.ReduceElements(elements)

   151

    union = {"type": "union", "memberTypes": attributes.get("memberTypes", []), "doc": annotations}

   152

   153

    for child in children:

   154

        if child["type"] == SIMPLETYPE:

   155

            union["memberTypes"].append(child)

   156

    if len(union["memberTypes"]) == 0:

   157

        raise ValueError("No base type has been defined for union!")

   158

    return union

   159

   160

   161

def CreateSimpleType(factory, attributes, typeinfos):

   162

    # Initialize type informations

   163

    facets = {}

   164

    simpleType = {"type": SIMPLETYPE, "final": attributes.get("final", [])}

   165

    if "name" in attributes:

   166

        simpleType["name"] = attributes["name"]

   167

   168

    if typeinfos["type"] in ["restriction", "extension"]:

   169

        # Search for base type definition

   170

        if isinstance(typeinfos["base"], (StringType, UnicodeType)):

   171

            basetypeinfos = factory.FindSchemaElement(typeinfos["base"], SIMPLETYPE)

   172

            if basetypeinfos is None:

   173

                raise "\"%s\" isn't defined!" % typeinfos["base"]

   174

        else:

   175

            basetypeinfos = typeinfos["base"]

   176

   177

        # Check that base type is a simple type

   178

        if basetypeinfos["type"] != SIMPLETYPE:

   179

            raise ValueError("Base type given isn't a simpleType!")

   180

   181

        simpleType["basename"] = basetypeinfos["basename"]

   182

   183

        # Check that derivation is allowed

   184

        if "final" in basetypeinfos:

   185

            if "#all" in basetypeinfos["final"]:

   186

                raise ValueError("Base type can't be derivated!")

   187

            if "restriction" in basetypeinfos["final"] and typeinfos["type"] == "restriction":

   188

                raise ValueError("Base type can't be derivated by restriction!")

   189

   190

        # Extract simple type facets

   191

        for facet in typeinfos.get("facets", []):

   192

            facettype = facet["type"]

   193

            if facettype not in basetypeinfos["facets"]:

   194

                raise ValueError("\"%s\" facet can't be defined for \"%s\" type!" % (facettype, type))

   195

            elif basetypeinfos["facets"][facettype][1]:

   196

                raise ValueError("\"%s\" facet is fixed on base type!" % facettype)

   197

            value = facet["value"]

   198

            basevalue = basetypeinfos["facets"][facettype][0]

   199

            if facettype in ["enumeration", "pattern"]:

   200

                value = basetypeinfos["extract"](value, False)

   201

                if len(facets) == 0:

   202

                    facets[facettype] = ([value], False)

   203

                    continue

   204

                elif facets.keys() == [facettype]:

   205

                    facets[facettype][0].append(value)

   206

                    continue

   207

                else:

   208

                    raise ValueError("\"%s\" facet can't be defined with another facet type!" % facettype)

   209

            elif "enumeration" in facets:

   210

                raise ValueError("\"enumeration\" facet can't be defined with another facet type!")

   211

            elif "pattern" in facets:

   212

                raise ValueError("\"pattern\" facet can't be defined with another facet type!")

   213

            elif facettype in facets:

   214

                raise ValueError("\"%s\" facet can't be defined two times!" % facettype)

   215

            elif facettype == "length":

   216

                if "minLength" in facets:

   217

                    raise ValueError("\"length\" and \"minLength\" facets can't be defined at the same time!")

   218

                if "maxLength" in facets:

   219

                    raise ValueError("\"length\" and \"maxLength\" facets can't be defined at the same time!")

   220

                try:

   221

                    value = int(value)

   222

                except Exception:

   223

                    raise ValueError("\"length\" must be an integer!")

   224

                if value < 0:

   225

                    raise ValueError("\"length\" can't be negative!")

   226

                elif basevalue is not None and basevalue != value:

   227

                    raise ValueError("\"length\" can't be different from \"length\" defined in base type!")

   228

            elif facettype == "minLength":

   229

                if "length" in facets:

   230

                    raise ValueError("\"length\" and \"minLength\" facets can't be defined at the same time!")

   231

                try:

   232

                    value = int(value)

   233

                except Exception:

   234

                    raise ValueError("\"minLength\" must be an integer!")

   235

                if value < 0:

   236

                    raise ValueError("\"minLength\" can't be negative!")

   237

                elif "maxLength" in facets and value > facets["maxLength"]:

   238

                    raise ValueError("\"minLength\" must be lesser than or equal to \"maxLength\"!")

   239

                elif basevalue is not None and basevalue < value:

   240

                    raise ValueError("\"minLength\" can't be lesser than \"minLength\" defined in base type!")

   241

            elif facettype == "maxLength":

   242

                if "length" in facets:

   243

                    raise ValueError("\"length\" and \"maxLength\" facets can't be defined at the same time!")

   244

                try:

   245

                    value = int(value)

   246

                except Exception:

   247

                    raise ValueError("\"maxLength\" must be an integer!")

   248

                if value < 0:

   249

                    raise ValueError("\"maxLength\" can't be negative!")

   250

                elif "minLength" in facets and value < facets["minLength"]:

   251

                    raise ValueError("\"minLength\" must be lesser than or equal to \"maxLength\"!")

   252

                elif basevalue is not None and basevalue > value:

   253

                    raise ValueError("\"maxLength\" can't be greater than \"maxLength\" defined in base type!")

   254

            elif facettype == "minInclusive":

   255

                if "minExclusive" in facets:

   256

                    raise ValueError("\"minExclusive\" and \"minInclusive\" facets can't be defined at the same time!")

   257

                value = basetypeinfos["extract"](facet["value"], False)

   258

                if "maxInclusive" in facets and value > facets["maxInclusive"][0]:

   259

                    raise ValueError("\"minInclusive\" must be lesser than or equal to \"maxInclusive\"!")

   260

                elif "maxExclusive" in facets and value >= facets["maxExclusive"][0]:

   261

                    raise ValueError("\"minInclusive\" must be lesser than \"maxExclusive\"!")

   262

            elif facettype == "minExclusive":

   263

                if "minInclusive" in facets:

   264

                    raise ValueError("\"minExclusive\" and \"minInclusive\" facets can't be defined at the same time!")

   265

                value = basetypeinfos["extract"](facet["value"], False)

   266

                if "maxInclusive" in facets and value >= facets["maxInclusive"][0]:

   267

                    raise ValueError("\"minExclusive\" must be lesser than \"maxInclusive\"!")

   268

                elif "maxExclusive" in facets and value >= facets["maxExclusive"][0]:

   269

                    raise ValueError("\"minExclusive\" must be lesser than \"maxExclusive\"!")

   270

            elif facettype == "maxInclusive":

   271

                if "maxExclusive" in facets:

   272

                    raise ValueError("\"maxExclusive\" and \"maxInclusive\" facets can't be defined at the same time!")

   273

                value = basetypeinfos["extract"](facet["value"], False)

   274

                if "minInclusive" in facets and value < facets["minInclusive"][0]:

   275

                    raise ValueError("\"minInclusive\" must be lesser than or equal to \"maxInclusive\"!")

   276

                elif "minExclusive" in facets and value <= facets["minExclusive"][0]:

   277

                    raise ValueError("\"minExclusive\" must be lesser than \"maxInclusive\"!")

   278

            elif facettype == "maxExclusive":

   279

                if "maxInclusive" in facets:

   280

                    raise ValueError("\"maxExclusive\" and \"maxInclusive\" facets can't be defined at the same time!")

   281

                value = basetypeinfos["extract"](facet["value"], False)

   282

                if "minInclusive" in facets and value <= facets["minInclusive"][0]:

   283

                    raise ValueError("\"minInclusive\" must be lesser than \"maxExclusive\"!")

   284

                elif "minExclusive" in facets and value <= facets["minExclusive"][0]:

   285

                    raise ValueError("\"minExclusive\" must be lesser than \"maxExclusive\"!")

   286

            elif facettype == "whiteSpace":

   287

                if basevalue == "collapse" and value in ["preserve", "replace"] or basevalue == "replace" and value == "preserve":

   288

                    raise ValueError("\"whiteSpace\" is incompatible with \"whiteSpace\" defined in base type!")

   289

            elif facettype == "totalDigits":

   290

                if "fractionDigits" in facets and value <= facets["fractionDigits"][0]:

   291

                    raise ValueError("\"fractionDigits\" must be lesser than or equal to \"totalDigits\"!")

   292

                elif basevalue is not None and value > basevalue:

   293

                    raise ValueError("\"totalDigits\" can't be greater than \"totalDigits\" defined in base type!")

   294

            elif facettype == "fractionDigits":

   295

                if "totalDigits" in facets and value <= facets["totalDigits"][0]:

   296

                    raise ValueError("\"fractionDigits\" must be lesser than or equal to \"totalDigits\"!")

   297

                elif basevalue is not None and value > basevalue:

   298

                    raise ValueError("\"totalDigits\" can't be greater than \"totalDigits\" defined in base type!")

   299

            facets[facettype] = (value, facet.get("fixed", False))

   300

   301

        # Report not redefined facet from base type to new created type

   302

        for facettype, facetvalue in basetypeinfos["facets"].items():

   303

            if facettype not in facets:

   304

                facets[facettype] = facetvalue

   305

   306

        # Generate extract value for new created type

   307

        def ExtractSimpleTypeValue(attr, extract=True):

   308

            value = basetypeinfos["extract"](attr, extract)

   309

            for facetname, (facetvalue, _facetfixed) in facets.items():

   310

                if facetvalue is not None:

   311

                    if facetname == "enumeration" and value not in facetvalue:

   312

                        raise ValueError("\"%s\" not in enumerated values" % value)

   313

                    elif facetname == "length" and len(value) != facetvalue:

   314

                        raise ValueError("value must have a length of %d" % facetvalue)

   315

                    elif facetname == "minLength" and len(value) < facetvalue:

   316

                        raise ValueError("value must have a length of %d at least" % facetvalue)

   317

                    elif facetname == "maxLength" and len(value) > facetvalue:

   318

                        raise ValueError("value must have a length of %d at most" % facetvalue)

   319

                    elif facetname == "minInclusive" and value < facetvalue:

   320

                        raise ValueError("value must be greater than or equal to %s" % str(facetvalue))

   321

                    elif facetname == "minExclusive" and value <= facetvalue:

   322

                        raise ValueError("value must be greater than %s" % str(facetvalue))

   323

                    elif facetname == "maxInclusive" and value > facetvalue:

   324

                        raise ValueError("value must be lesser than or equal to %s" % str(facetvalue))

   325

                    elif facetname == "maxExclusive" and value >= facetvalue:

   326

                        raise ValueError("value must be lesser than %s" % str(facetvalue))

   327

                    elif facetname == "pattern":

   328

                        model = re.compile("(?:%s)?$" % "|".join(map(lambda x: "(?:%s)" % x, facetvalue)))

   329

                        result = model.match(value)

   330

                        if result is None:

   331

                            if len(facetvalue) > 1:

   332

                                raise ValueError("value doesn't follow any of the patterns %s" % ",".join(facetvalue))

   333

                            else:

   334

                                raise ValueError("value doesn't follow the pattern %s" % facetvalue[0])

   335

                    elif facetname == "whiteSpace":

   336

                        if facetvalue == "replace":

   337

                            value = GetNormalizedString(value, False)

   338

                        elif facetvalue == "collapse":

   339

                            value = GetToken(value, False)

   340

            return value

   341

   342

        def CheckSimpleTypeValue(value):

   343

            for facetname, (facetvalue, _facetfixed) in facets.items():

   344

                if facetvalue is not None:

   345

                    if facetname == "enumeration" and value not in facetvalue:

   346

                        return False

   347

                    elif facetname == "length" and len(value) != facetvalue:

   348

                        return False

   349

                    elif facetname == "minLength" and len(value) < facetvalue:

   350

                        return False

   351

                    elif facetname == "maxLength" and len(value) > facetvalue:

   352

                        return False

   353

                    elif facetname == "minInclusive" and value < facetvalue:

   354

                        return False

   355

                    elif facetname == "minExclusive" and value <= facetvalue:

   356

                        return False

   357

                    elif facetname == "maxInclusive" and value > facetvalue:

   358

                        return False

   359

                    elif facetname == "maxExclusive" and value >= facetvalue:

   360

                        return False

   361

                    elif facetname == "pattern":

   362

                        model = re.compile("(?:%s)?$" % "|".join(map(lambda x: "(?:%s)" % x, facetvalue)))

   363

                        result = model.match(value)

   364

                        if result is None:

   365

                            if len(facetvalue) > 1:

   366

                                raise ValueError("value doesn't follow any of the patterns %s" % ",".join(facetvalue))

   367

                            else:

   368

                                raise ValueError("value doesn't follow the pattern %s" % facetvalue[0])

   369

            return True

   370

   371

        def SimpleTypeInitialValue():

   372

            for facetname, (facetvalue, _facetfixed) in facets.items():

   373

                if facetvalue is not None:

   374

                    if facetname == "enumeration":

   375

                        return facetvalue[0]

   376

                    elif facetname == "length":

   377

                        return " "*facetvalue

   378

                    elif facetname == "minLength":

   380

                    elif facetname == "minInclusive" and facetvalue > 0:

   381

                        return facetvalue

   382

                    elif facetname == "minExclusive" and facetvalue >= 0:

   383

                        return facetvalue + 1

   384

                    elif facetname == "maxInclusive" and facetvalue < 0:

   385

                        return facetvalue

   386

                    elif facetname == "maxExclusive" and facetvalue <= 0:

   387

                        return facetvalue - 1

   388

            return basetypeinfos["initial"]()

   389

   390

        GenerateSimpleType = basetypeinfos["generate"]

   391

   392

    elif typeinfos["type"] == "list":

   393

        # Search for item type definition

   394

        if isinstance(typeinfos["itemType"], (StringType, UnicodeType)):

   395

            itemtypeinfos = factory.FindSchemaElement(typeinfos["itemType"], SIMPLETYPE)

   396

            if itemtypeinfos is None:

   397

                raise "\"%s\" isn't defined!" % typeinfos["itemType"]

   398

        else:

   399

            itemtypeinfos = typeinfos["itemType"]

   400

   401

        # Check that item type is a simple type

   402

        if itemtypeinfos["type"] != SIMPLETYPE:

   403

            raise ValueError("Item type given isn't a simpleType!")

   404

   405

        simpleType["basename"] = "list"

   406

   407

        # Check that derivation is allowed

   408

        if "final" in itemtypeinfos:

   409

            if "#all" in itemtypeinfos["final"]:

   410

                raise ValueError("Item type can't be derivated!")

   411

            if "list" in itemtypeinfos["final"]:

   412

                raise ValueError("Item type can't be derivated by list!")

   413

   414

        # Generate extract value for new created type

   415

        def ExtractSimpleTypeValue(attr, extract=True):

   416

            values = []

   417

            for value in GetToken(attr, extract).split(" "):

   418

                values.append(itemtypeinfos["extract"](value, False))

   419

            return values

   420

   421

        def CheckSimpleTypeValue(value):

   422

            for item in value:

   423

                result = itemtypeinfos["check"](item)

   424

                if not result:

   425

                    return result

   426

            return True

   427

   428

        def SimpleTypeInitialValue():

   429

            return []

   430

   431

        GenerateSimpleType = GenerateSimpleTypeXMLText(lambda x: " ".join(map(itemtypeinfos["generate"], x)))

   432

   433

        facets = GenerateDictFacets(["length", "maxLength", "minLength", "enumeration", "pattern"])

   434

        facets["whiteSpace"] = ("collapse", False)

   435

   436

    elif typeinfos["type"] == "union":

   437

        # Search for member types definition

   438

        membertypesinfos = []

   439

        for membertype in typeinfos["memberTypes"]:

   440

            if isinstance(membertype, (StringType, UnicodeType)):

   441

                infos = factory.FindSchemaElement(membertype, SIMPLETYPE)

   442

                if infos is None:

   443

                    raise ValueError("\"%s\" isn't defined!" % membertype)

   444

            else:

   445

                infos = membertype

   446

   447

            # Check that member type is a simple type

   448

            if infos["type"] != SIMPLETYPE:

   449

                raise ValueError("Member type given isn't a simpleType!")

   450

   451

            # Check that derivation is allowed

   452

            if "final" in infos:

   453

                if "#all" in infos["final"]:

   454

                    raise ValueError("Item type can't be derivated!")

   455

                if "union" in infos["final"]:

   456

                    raise ValueError("Member type can't be derivated by union!")

   457

   458

            membertypesinfos.append(infos)

   459

   460

        simpleType["basename"] = "union"

   461

   462

        # Generate extract value for new created type

   463

        def ExtractSimpleTypeValue(attr, extract=True):

   464

            for infos in membertypesinfos:

   465

                try:

   466

                    return infos["extract"](attr, False)

   467

                except Exception:

   468

                    pass

   469

            raise ValueError("\"%s\" isn't valid for type defined for union!")

   470

   471

        def CheckSimpleTypeValue(value):

   472

            for infos in membertypesinfos:

   473

                result = infos["check"](value)

   474

                if result:

   475

                    return result

   476

            return False

   477

   478

        SimpleTypeInitialValue = membertypesinfos[0]["initial"]

   479

   480

        def GenerateSimpleTypeFunction(value):

   481

            if isinstance(value, BooleanType):

   482

                return {True: "true", False: "false"}[value]

   483

            else:

   484

                return str(value)

   485

        GenerateSimpleType = GenerateSimpleTypeXMLText(GenerateSimpleTypeFunction)

   486

   487

        facets = GenerateDictFacets(["pattern", "enumeration"])

   488

   489

    simpleType["facets"] = facets

   490

    simpleType["extract"] = ExtractSimpleTypeValue

   491

    simpleType["initial"] = SimpleTypeInitialValue

   492

    simpleType["check"] = CheckSimpleTypeValue

   493

    simpleType["generate"] = GenerateSimpleType

   494

    return simpleType

   495

   496

   497

def ReduceSimpleType(factory, attributes, elements):

   498

    # Reduce all the simple type children

   499

    annotations, children = factory.ReduceElements(elements)

   500

   501

    simpleType = CreateSimpleType(factory, attributes, children[0])

   502

    simpleType["doc"] = annotations

   503

   504

    return simpleType

   505