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

# Copyright (C) 2017: Andrey Skvortsov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

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

    13

# modify it under the terms of the GNU General Public License

    14

# as published by the Free Software Foundation; either version 2

    15

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

    16

#

    17

# This program is distributed in the hope that it will be useful,

    18

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

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

    23

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

    24

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    25

    26

    27

from __future__ import absolute_import

    28

from __future__ import division

    29

import re

    30

from collections import OrderedDict

    31

    32

from six.moves import xrange

    33

from lxml import etree

    34

    35

from xmlclass import *

    36

import util.paths as paths

    37

    38

    39

#: Dictionary that makes the relation between var names

    40

#: in plcopen and displayed values

    41

    42

VarTypes = {

    43

    "Local":    "localVars",

    44

    "Temp":     "tempVars",

    45

    "Input":    "inputVars",

    46

    "Output":   "outputVars",

    47

    "InOut":    "inOutVars",

    48

    "External": "externalVars",

    49

    "Global":   "globalVars",

    50

    "Access":   "accessVars"

    51

}

    52

    53

searchResultVarTypes = {

    54

    "inputVars":  "var_input",

    55

    "outputVars": "var_output",

    56

    "inOutVars":  "var_inout"

    57

}

    58

    59

    60

#: Define in which order var types must be displayed

    61

    62

VarOrder = ["Local", "Temp", "Input", "Output", "InOut", "External", "Global", "Access"]

    63

    64

    65

#:  Define which action qualifier must be associated with a duration

    66

    67

QualifierList = OrderedDict([

    68

    ("N", False),

    69

    ("R", False),

    70

    ("S", False),

    71

    ("L", True),

    72

    ("D", True),

    73

    ("P", False),

    74

    ("P0", False),

    75

    ("P1", False),

    76

    ("SD", True),

    77

    ("DS", True),

    78

    ("SL", True)])

    79

    80

    81

FILTER_ADDRESS_MODEL = r"(%%[IQM](?:[XBWDL])?)(%s)((?:\.[0-9]+)*)"

    82

    83

    84

def update_address(address, address_model, new_leading):

    85

    result = address_model.match(address)

    86

    if result is None:

    87

        return address

    88

    groups = result.groups()

    89

    return groups[0] + new_leading + groups[2]

    90

    91

    92

def _init_and_compare(function, v1, v2):

    93

    if v1 is None:

    94

        return v2

    95

    if v2 is not None:

    96

        return function(v1, v2)

    97

    return v1

    98

    99

   100

class rect(object):

   101

    """

   102

    Helper class for bounding_box calculation

   103

    """

   104

   105

    def __init__(self, x=None, y=None, width=None, height=None):

   106

        self.x_min = x

   107

        self.x_max = None

   108

        self.y_min = y

   109

        self.y_max = None

   110

        if width is not None and x is not None:

   111

            self.x_max = x + width

   112

        if height is not None and y is not None:

   113

            self.y_max = y + height

   114

   115

    def update(self, x, y):

   116

        self.x_min = _init_and_compare(min, self.x_min, x)

   117

        self.x_max = _init_and_compare(max, self.x_max, x)

   118

        self.y_min = _init_and_compare(min, self.y_min, y)

   119

        self.y_max = _init_and_compare(max, self.y_max, y)

   120

   121

    def union(self, rect):

   122

        self.x_min = _init_and_compare(min, self.x_min, rect.x_min)

   123

        self.x_max = _init_and_compare(max, self.x_max, rect.x_max)

   124

        self.y_min = _init_and_compare(min, self.y_min, rect.y_min)

   125

        self.y_max = _init_and_compare(max, self.y_max, rect.y_max)

   126

   127

    def bounding_box(self):

   128

        width = height = None

   129

        if self.x_min is not None and self.x_max is not None:

   130

            width = self.x_max - self.x_min

   131

        if self.y_min is not None and self.y_max is not None:

   132

            height = self.y_max - self.y_min

   133

        return self.x_min, self.y_min, width, height

   134

   135

   136

def TextLenInRowColumn(text):

   137

    if text == "":

   138

        return (0, 0)

   139

    lines = text.split("\n")

   140

    return len(lines) - 1, len(lines[-1])

   141

   142

   143

def CompilePattern(criteria):

   144

    flag = 0 if criteria["case_sensitive"] else re.IGNORECASE

   145

    find_pattern = criteria["find_pattern"]

   146

    if not criteria["regular_expression"]:

   147

        find_pattern = re.escape(find_pattern)

   148

    criteria["pattern"] = re.compile(find_pattern, flag)

   149

   150

   151

def TestTextElement(text, criteria):

   152

    lines = text.splitlines()

   153

    test_result = []

   154

    result = criteria["pattern"].search(text)

   155

    while result is not None:

   156

        prev_pos = result.span()[1]

   157

        start = TextLenInRowColumn(text[:result.start()])

   158

        end = TextLenInRowColumn(text[:result.end() - 1])

   159

        test_result.append((start, end, "\n".join(lines[start[0]:end[0] + 1])))

   160

        result = criteria["pattern"].search(text, result.end())

   161

        if result is not None and prev_pos == result.end():

   162

            break

   163

    return test_result

   164

   165

   166

def TextMatched(str1, str2):

   167

    return str1 and str2 and (str1.upper() == str2.upper())

   168

   169

   170

PLCOpenParser = GenerateParserFromXSD(paths.AbsNeighbourFile(__file__, "tc6_xml_v201.xsd"))

   171

   172

   173

def PLCOpen_XPath(xpath):

   174

    return etree.XPath(xpath, namespaces=PLCOpenParser.NSMAP)

   175

   176

   177

LOAD_POU_PROJECT_TEMPLATE = """

   178

<project xmlns:ns1="http://www.plcopen.org/xml/tc6_0201"

   179

         xmlns:xhtml="http://www.w3.org/1999/xhtml"

   180

         xmlns:xsd="http://www.w3.org/2001/XMLSchema"

   181

         xmlns="http://www.plcopen.org/xml/tc6_0201">

   182

  <fileHeader companyName="" productName="" productVersion=""

   183

              creationDateTime="1970-01-01T00:00:00"/>

   184

  <contentHeader name="paste_project">

   185

    <coordinateInfo>

   186

      <fbd><scaling x="0" y="0"/></fbd>

   187

      <ld><scaling x="0" y="0"/></ld>

   188

      <sfc><scaling x="0" y="0"/></sfc>

   189

    </coordinateInfo>

   190

  </contentHeader>

   191

  <types>

   192

    <dataTypes/>

   193

    <pous>%s</pous>

   194

  </types>

   195

  <instances>

   196

    <configurations/>

   197

  </instances>

   198

</project>

   199

"""

   200

   201

   202

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   203

    return LOAD_POU_PROJECT_TEMPLATE % """

   204

<pou name="paste_pou" pouType="program">

   205

  <body>

   206

    <%(body_type)s>%%s</%(body_type)s>

   207

  </body>

   208

</pou>""" % locals()

   209

   210

   211

PLCOpen_v1_file = open(paths.AbsNeighbourFile(__file__, "TC6_XML_V10_B.xsd"))

   212

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   213

PLCOpen_v1_file.close()

   214

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   215

    "http://www.plcopen.org/xml/tc6.xsd",

   216

    "http://www.plcopen.org/xml/tc6_0201")

   217

PLCOpen_v1_xsd = etree.XMLSchema(etree.fromstring(PLCOpen_v1_xml))

   218

   219

# XPath for file compatibility process

   220

ProjectResourcesXPath = PLCOpen_XPath("ppx:instances/ppx:configurations/ppx:configuration/ppx:resource")

   221

ResourceInstancesXpath = PLCOpen_XPath("ppx:pouInstance | ppx:task/ppx:pouInstance")

   222

TransitionsConditionXPath = PLCOpen_XPath("ppx:types/ppx:pous/ppx:pou/ppx:body/*/ppx:transition/ppx:condition")

   223

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   224

ActionBlocksXPath = PLCOpen_XPath("ppx:types/ppx:pous/ppx:pou/ppx:body/*/ppx:actionBlock")

   225

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   226

   227

   228

def LoadProjectXML(project_xml):

   229

    project_xml = project_xml.replace(

   230

        "http://www.plcopen.org/xml/tc6.xsd",

   231

        "http://www.plcopen.org/xml/tc6_0201")

   232

    for cre, repl in [

   233

            (re.compile(r"(?<!<xhtml:p>)(?:<!\[CDATA\[)"), "<xhtml:p><![CDATA["),

   234

            (re.compile(r"(?:]]>)(?!</xhtml:p>)"), "]]></xhtml:p>")]:

   235

        project_xml = cre.sub(repl, project_xml)

   236

   237

    try:

   238

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   239

        if error is None:

   240

            return tree, None

   241

   242

        if PLCOpen_v1_xsd.validate(tree):

   243

            # Make file compatible with PLCOpen v2

   244

   245

            # Update resource interval value

   246

            for resource in ProjectResourcesXPath(tree):

   247

                for task in resource.gettask():

   248

                    interval = task.get("interval")

   249

                    if interval is not None:

   250

                        result = time_model.match(interval)

   251

                        if result is not None:

   252

                            values = result.groups()

   253

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

   254

                            seconds = float(values[2])

   255

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

   256

                            text = "T#"

   257

                            if time_values[0] != 0:

   258

                                text += "%dh" % time_values[0]

   259

                            if time_values[1] != 0:

   260

                                text += "%dm" % time_values[1]

   261

                            if time_values[2] != 0:

   262

                                text += "%ds" % time_values[2]

   263

                            if time_values[3] != 0:

   264

                                if time_values[3] % 1000 != 0:

   265

                                    text += "%.3fms" % (time_values[3] / 1000)

   266

                                else:

   267

                                    text += "%dms" % (time_values[3] // 1000)

   268

                            task.set("interval", text)

   269

   270

                # Update resources pou instance attributes

   271

                for pouInstance in ResourceInstancesXpath(resource):

   272

                    type_name = pouInstance.attrib.pop("type")

   273

                    if type_name is not None:

   274

                        pouInstance.set("typeName", type_name)

   275

   276

            # Update transitions condition

   277

            for transition_condition in TransitionsConditionXPath(tree):

   278

                connections = ConditionConnectionsXPath(transition_condition)

   279

                if len(connections) > 0:

   280

                    connectionPointIn = PLCOpenParser.CreateElement("connectionPointIn", "condition")

   281

                    transition_condition.setcontent(connectionPointIn)

   282

                    connectionPointIn.setrelPositionXY(0, 0)

   283

                    for connection in connections:

   284

                        connectionPointIn.append(connection)

   285

   286

            # Update actionBlocks

   287

            for actionBlock in ActionBlocksXPath(tree):

   288

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   289

                    actionBlock.remove(connectionPointOut)

   290

   291

                for action in actionBlock.getaction():

   292

                    action.set("localId", "0")

   293

                    relPosition = PLCOpenParser.CreateElement("relPosition", "action")

   294

                    relPosition.set("x", "0")

   295

                    relPosition.set("y", "0")

   296

                    action.setrelPosition(relPosition)

   297

   298

            return tree, None

   299

   300

        return tree, error

   301

   302

    except Exception as e:

   303

        return None, str(e)

   304

   305

   306

def LoadProject(filepath):

   307

    project_file = open(filepath)

   308

    project_xml = project_file.read()

   309

    project_file.close()

   310

    return LoadProjectXML(project_xml)

   311

   312

   313

project_pou_xpath = PLCOpen_XPath("/ppx:project/ppx:types/ppx:pous/ppx:pou")

   314

   315

   316

def LoadPou(xml_string):

   317

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   318

    return project_pou_xpath(root)[0], error

   319

   320

   321

project_pou_instances_xpath = {

   322

    body_type: PLCOpen_XPath(

   323

        "/ppx:project/ppx:types/ppx:pous/ppx:pou[@name='paste_pou']/ppx:body/ppx:%s/*" % body_type)

   324

    for body_type in ["FBD", "LD", "SFC"]}

   325

   326

   327

def LoadPouInstances(xml_string, body_type):

   328

    root, error = LoadProjectXML(

   329

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   330

    return project_pou_instances_xpath[body_type](root), error

   331

   332

   333

def SaveProject(project, filepath):

   334

    content = etree.tostring(

   335

        project,

   336

        pretty_print=True,

   337

        xml_declaration=True,

   338

        encoding='utf-8')

   339

   340

    assert len(content) != 0

   341

   342

    project_file = open(filepath, 'w')

   343

    project_file.write(content)

   344

    project_file.close()

   345

   346

   347

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

   348

   349

   350

def _updateFormattedTextClass(cls):

   351

    def updateElementName(self, old_name, new_name):

   352

        text = self.getanyText()

   353

        pattern = re.compile('\\b' + old_name + '\\b', re.IGNORECASE)

   354

        text = pattern.sub(new_name, text)

   355

        self.setanyText(text)

   356

    setattr(cls, "updateElementName", updateElementName)

   357

   358

    def updateElementAddress(self, address_model, new_leading):

   359

        text = self.getanyText()

   360

        startpos = 0

   361

        result = address_model.search(text, startpos)

   362

        while result is not None:

   363

            groups = result.groups()

   364

            new_address = groups[0] + new_leading + groups[2]

   365

            text = text[:result.start()] + new_address + text[result.end():]

   366

            startpos = result.start() + len(new_address)

   367

            result = address_model.search(text, startpos)

   368

        self.setanyText(text)

   369

    setattr(cls, "updateElementAddress", updateElementAddress)

   370

   371

    def hasblock(self, block_type):

   372

        text = self.getanyText()

   373

        pattern = re.compile('\\b' + block_type + '\\b', re.IGNORECASE)

   374

        return pattern.search(text) is not None

   375

    setattr(cls, "hasblock", hasblock)

   376

   377

    def Search(self, criteria, parent_infos):

   378

        return [(tuple(parent_infos),) + result for result in TestTextElement(self.getanyText(), criteria)]

   379

    setattr(cls, "Search", Search)

   380

   381

   382

cls = PLCOpenParser.GetElementClass("formattedText")

   383

if cls:

   384

    _updateFormattedTextClass(cls)

   385

   386

   387

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

   388

   389

   390

def _updateProjectClass(cls):

   391

    def setname(self, name):

   392

        self.contentHeader.setname(name)

   393

    setattr(cls, "setname", setname)

   394

   395

    def getname(self):

   396

        return self.contentHeader.getname()

   397

    setattr(cls, "getname", getname)

   398

   399

    def getfileHeader(self):

   400

        fileheader_obj = self.fileHeader

   401

        return {

   402

            attr: value if value is not None else ""

   403

            for attr, value in [

   404

                ("companyName", fileheader_obj.getcompanyName()),

   405

                ("companyURL", fileheader_obj.getcompanyURL()),

   406

                ("productName", fileheader_obj.getproductName()),

   407

                ("productVersion", fileheader_obj.getproductVersion()),

   408

                ("productRelease", fileheader_obj.getproductRelease()),

   409

                ("creationDateTime", fileheader_obj.getcreationDateTime()),

   410

                ("contentDescription", fileheader_obj.getcontentDescription())]

   411

        }

   412

    setattr(cls, "getfileHeader", getfileHeader)

   413

   414

    def setfileHeader(self, fileheader):

   415

        fileheader_obj = self.fileHeader

   416

        for attr in ["companyName", "companyURL", "productName",

   417

                     "productVersion", "productRelease", "creationDateTime",

   418

                     "contentDescription"]:

   419

            value = fileheader.get(attr)

   420

            if value is not None:

   421

                setattr(fileheader_obj, attr, value)

   422

    setattr(cls, "setfileHeader", setfileHeader)

   423

   424

    def getcontentHeader(self):

   425

        contentheader_obj = self.contentHeader

   426

        contentheader = {

   427

            attr: value if value is not None else ""

   428

            for attr, value in [

   429

                ("projectName", contentheader_obj.getname()),

   430

                ("projectVersion", contentheader_obj.getversion()),

   431

                ("modificationDateTime", contentheader_obj.getmodificationDateTime()),

   432

                ("organization", contentheader_obj.getorganization()),

   433

                ("authorName", contentheader_obj.getauthor()),

   434

                ("language", contentheader_obj.getlanguage())]

   435

        }

   436

        contentheader["pageSize"] = self.contentHeader.getpageSize()

   437

        contentheader["scaling"] = self.contentHeader.getscaling()

   438

        return contentheader

   439

    setattr(cls, "getcontentHeader", getcontentHeader)

   440

   441

    def setcontentHeader(self, contentheader):

   442

        contentheader_obj = self.contentHeader

   443

        for attr, value in contentheader.iteritems():

   444

            func = {"projectName": contentheader_obj.setname,

   445

                    "projectVersion": contentheader_obj.setversion,

   446

                    "authorName": contentheader_obj.setauthor,

   447

                    "pageSize": lambda v: contentheader_obj.setpageSize(*v),

   448

                    "scaling": contentheader_obj.setscaling}.get(attr)

   449

            if func is not None and value is not None:

   450

                func(value)

   451

            elif attr in ["modificationDateTime", "organization", "language"]:

   452

                setattr(contentheader_obj, attr, value)

   453

    setattr(cls, "setcontentHeader", setcontentHeader)

   454

   455

    def gettypeElementFunc(element_type):

   456

        elements_xpath = PLCOpen_XPath(

   457

            "ppx:types/ppx:%(element_type)ss/ppx:%(element_type)s[@name=$name]" % locals())

   458

   459

        def gettypeElement(self, name):

   460

            elements = elements_xpath(self, name=name)

   461

            if len(elements) == 1:

   462

                return elements[0]

   463

            return None

   464

        return gettypeElement

   465

   466

    datatypes_xpath = PLCOpen_XPath("ppx:types/ppx:dataTypes/ppx:dataType")

   467

    filtered_datatypes_xpath = PLCOpen_XPath(

   468

        "ppx:types/ppx:dataTypes/ppx:dataType[@name!=$exclude]")

   469

   470

    def getdataTypes(self, exclude=None):

   471

        if exclude is not None:

   472

            return filtered_datatypes_xpath(self, exclude=exclude)

   473

        return datatypes_xpath(self)

   474

    setattr(cls, "getdataTypes", getdataTypes)

   475

   476

    setattr(cls, "getdataType", gettypeElementFunc("dataType"))

   477

   478

    def appenddataType(self, name):

   479

        if self.getdataType(name) is not None:

   480

            raise ValueError("\"%s\" Data Type already exists !!!" % name)

   481

        self.types.appenddataTypeElement(name)

   482

    setattr(cls, "appenddataType", appenddataType)

   483

   484

    def insertdataType(self, index, datatype):

   485

        self.types.insertdataTypeElement(index, datatype)

   486

    setattr(cls, "insertdataType", insertdataType)

   487

   488

    def removedataType(self, name):

   489

        self.types.removedataTypeElement(name)

   490

    setattr(cls, "removedataType", removedataType)