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

from xmlclass import *

    26

from structures import *

    27

from types import *

    28

import os, re

    30

from collections import OrderedDict

    31

"""

    32

Dictionary that makes the relation between var names in plcopen and displayed values

    33

"""

    34

VarTypes = {"Local" : "localVars", "Temp" : "tempVars", "Input" : "inputVars",

    35

            "Output" : "outputVars", "InOut" : "inOutVars", "External" : "externalVars",

    36

            "Global" : "globalVars", "Access" : "accessVars"}

    37

    38

searchResultVarTypes = {

    39

    "inputVars": "var_input",

    40

    "outputVars": "var_output",

    41

    "inOutVars": "var_inout"

    42

}

    43

    44

"""

    45

Define in which order var types must be displayed

    46

"""

    47

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

    48

    49

"""

    50

Define which action qualifier must be associated with a duration 

    51

"""

    52

QualifierList = {"N" : False, "R" : False, "S" : False, "L" : True, "D" : True, 

    53

    "P" : False, "P0" : False, "P1" : False, "SD" : True, "DS" : True, "SL" : True}

    54

    55

    56

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

    57

    58

def update_address(address, address_model, new_leading):

    59

    result = address_model.match(address)

    60

    if result is None:

    61

        return address

    62

    groups = result.groups()

    63

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

    64

    65

def _init_and_compare(function, v1, v2):

    66

    if v1 is None:

    67

        return v2

    68

    if v2 is not None:

    69

        return function(v1, v2)

    70

    return v1

    71

    72

"""

    73

Helper class for bounding_box calculation 

    74

"""

    75

class rect:

    76

    77

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

    78

        self.x_min = x

    79

        self.x_max = None

    80

        self.y_min = y

    81

        self.y_max = None

    82

        if width is not None and x is not None:

    83

            self.x_max = x + width

    84

        if height is not None and y is not None:

    85

            self.y_max = y + height

    86

    87

    def update(self, x, y):

    88

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

    89

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

    90

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

    91

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

    92

    93

    def union(self, rect):

    94

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

    95

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

    96

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

    97

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

    98

    99

    def bounding_box(self):

   100

        width = height = None

   101

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

   102

            width = self.x_max - self.x_min

   103

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

   104

            height = self.y_max - self.y_min

   105

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

   106

   107

def TextLenInRowColumn(text):

   108

    if text == "":

   109

        return (0, 0)

   110

    lines = text.split("\n")

   111

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

   112

   113

def TestTextElement(text, criteria):

   114

    lines = text.splitlines()

   115

    if not criteria["case_sensitive"]:

   116

        text = text.upper()

   117

    test_result = []

   118

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

   119

    while result is not None:

   120

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

   121

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

   122

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

   123

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

   124

    return test_result

   125

   149

if cls:

   150

    def updateElementName(self, old_name, new_name):

   151

        text = self.text

   152

        index = text.find(old_name)

   153

        while index != -1:

   154

            if index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_"):

   155

                index = text.find(old_name, index + len(old_name))

   156

            elif index < len(text) - len(old_name) and (text[index + len(old_name)].isalnum() or text[index + len(old_name)] == "_"):

   157

                index = text.find(old_name, index + len(old_name))

   158

            else:

   159

                text = text[:index] + new_name + text[index + len(old_name):]

   160

                index = text.find(old_name, index + len(new_name))

   161

        self.text = text

   162

    setattr(cls, "updateElementName", updateElementName)

   163

   164

    def updateElementAddress(self, address_model, new_leading):

   165

        text = self.text

   166

        startpos = 0

   167

        result = address_model.search(text, startpos)

   168

        while result is not None:

   169

            groups = result.groups()

   170

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

   171

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

   172

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

   173

            result = address_model.search(self.text, startpos)

   174

        self.text = text

   175

    setattr(cls, "updateElementAddress", updateElementAddress)

   176

   177

    def hasblock(self, block_type):

   178

        text = self.text.upper()

   179

        index = text.find(block_type.upper())

   180

        while index != -1:

   181

            if (not (index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_")) and 

   182

                not (index < len(text) - len(block_type) and text[index + len(block_type)] != "(")):

   183

                return True

   184

            index = text.find(block_type.upper(), index + len(block_type))

   185

        return False

   186

    setattr(cls, "hasblock", hasblock)

   187

   188

    def Search(self, criteria, parent_infos):

   189

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

   190

    setattr(cls, "Search", Search)

   191

   194

    cls.EnumeratedDataTypeValues = {}

   195

    cls.CustomDataTypeRange = {}

   196

    cls.CustomTypeHierarchy = {}

   197

    cls.ElementUsingTree = {}

   198

    cls.CustomBlockTypes = OrderedDict()

   199

   200

    def setname(self, name):

   201

        self.contentHeader.setname(name)

   202

    setattr(cls, "setname", setname)

   203

   204

    def getname(self):

   205

        return self.contentHeader.getname()

   206

    setattr(cls, "getname", getname)

   207

   208

    def getfileHeader(self):

   209

        fileheader = {}

   210

        for name, value in [("companyName", self.fileHeader.getcompanyName()),

   211

                            ("companyURL", self.fileHeader.getcompanyURL()),

   212

                            ("productName", self.fileHeader.getproductName()),

   213

                            ("productVersion", self.fileHeader.getproductVersion()),

   214

                            ("productRelease", self.fileHeader.getproductRelease()),

   215

                            ("creationDateTime", self.fileHeader.getcreationDateTime()),

   216

                            ("contentDescription", self.fileHeader.getcontentDescription())]:

   217

            if value is not None:

   218

                fileheader[name] = value

   219

            else:

   220

                fileheader[name] = ""

   221

        return fileheader

   222

    setattr(cls, "getfileHeader", getfileHeader)

   223

   224

    def setfileHeader(self, fileheader):

   225

        if fileheader.has_key("companyName"):

   226

            self.fileHeader.setcompanyName(fileheader["companyName"])

   227

        if fileheader.has_key("companyURL"):

   228

            self.fileHeader.setcompanyURL(fileheader["companyURL"])

   229

        if fileheader.has_key("productName"):

   230

            self.fileHeader.setproductName(fileheader["productName"])

   231

        if fileheader.has_key("productVersion"):

   232

            self.fileHeader.setproductVersion(fileheader["productVersion"])

   233

        if fileheader.has_key("productRelease"):

   234

            self.fileHeader.setproductRelease(fileheader["productRelease"])

   235

        if fileheader.has_key("creationDateTime"):

   236

            self.fileHeader.setcreationDateTime(fileheader["creationDateTime"])

   237

        if fileheader.has_key("contentDescription"):

   238

            self.fileHeader.setcontentDescription(fileheader["contentDescription"])

   239

    setattr(cls, "setfileHeader", setfileHeader)

   240

   241

    def getcontentHeader(self):

   242

        contentheader = {}

   243

        for name, value in [("projectName", self.contentHeader.getname()),

   244

                            ("projectVersion", self.contentHeader.getversion()),

   245

                            ("modificationDateTime", self.contentHeader.getmodificationDateTime()),

   246

                            ("organization", self.contentHeader.getorganization()),

   247

                            ("authorName", self.contentHeader.getauthor()),

   248

                            ("language", self.contentHeader.getlanguage())]:

   249

            if value is not None:

   250

                contentheader[name] = value

   251

            else:

   252

                contentheader[name] = ""

   253

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

   254

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

   255

        return contentheader

   256

    setattr(cls, "getcontentHeader", getcontentHeader)

   257

   258

    def setcontentHeader(self, contentheader):

   259

        if contentheader.has_key("projectName"):

   260

            self.contentHeader.setname(contentheader["projectName"])

   261

        if contentheader.has_key("projectVersion"):

   262

            self.contentHeader.setversion(contentheader["projectVersion"])

   263

        if contentheader.has_key("modificationDateTime"):

   264

            self.contentHeader.setmodificationDateTime(contentheader["modificationDateTime"])

   265

        if contentheader.has_key("organization"):

   266

            self.contentHeader.setorganization(contentheader["organization"])

   267

        if contentheader.has_key("authorName"):

   268

            self.contentHeader.setauthor(contentheader["authorName"])

   269

        if contentheader.has_key("language"):

   270

            self.contentHeader.setlanguage(contentheader["language"])

   271

        if contentheader.has_key("pageSize"):

   272

            self.contentHeader.setpageSize(*contentheader["pageSize"])

   273

        if contentheader.has_key("scaling"):

   274

            self.contentHeader.setscaling(contentheader["scaling"])

   275

    setattr(cls, "setcontentHeader", setcontentHeader)

   276

   277

    def getdataTypes(self):

   278

        return self.types.getdataTypeElements()

   279

    setattr(cls, "getdataTypes", getdataTypes)

   280

   281

    def getdataType(self, name):

   282

        return self.types.getdataTypeElement(name)

   283

    setattr(cls, "getdataType", getdataType)

   284

   285

    def appenddataType(self, name):

   286

        if self.CustomTypeHierarchy.has_key(name):

   287

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

   288

        self.types.appenddataTypeElement(name)

   289

        self.AddCustomDataType(self.getdataType(name))

   290

    setattr(cls, "appenddataType", appenddataType)

   291

   292

    def insertdataType(self, index, datatype):

   293

        self.types.insertdataTypeElement(index, datatype)

   294

        self.AddCustomDataType(datatype)

   295

    setattr(cls, "insertdataType", insertdataType)

   296

   297

    def removedataType(self, name):

   298

        self.types.removedataTypeElement(name)

   299

        self.RefreshDataTypeHierarchy()

   300

        self.RefreshElementUsingTree()

   301

    setattr(cls, "removedataType", removedataType)

   302

   303

    def getpous(self):

   304

        return self.types.getpouElements()

   305

    setattr(cls, "getpous", getpous)

   306

   307

    def getpou(self, name):

   308

        return self.types.getpouElement(name)

   309

    setattr(cls, "getpou", getpou)

   310

   311

    def appendpou(self, name, pou_type, body_type):

   312

        self.types.appendpouElement(name, pou_type, body_type)

   313

        self.AddCustomBlockType(self.getpou(name))

   314

    setattr(cls, "appendpou", appendpou)

   315

   316

    def insertpou(self, index, pou):

   317

        self.types.insertpouElement(index, pou)

   318

        self.AddCustomBlockType(pou)

   319

    setattr(cls, "insertpou", insertpou)

   320

   321

    def removepou(self, name):

   322

        self.types.removepouElement(name)

   323

        self.RefreshCustomBlockTypes()

   324

        self.RefreshElementUsingTree()

   325

    setattr(cls, "removepou", removepou)

   326

   327

    def getconfigurations(self):

   328

        configurations = self.instances.configurations.getconfiguration()

   329

        if configurations:

   330

            return configurations

   331

        return []

   332

    setattr(cls, "getconfigurations", getconfigurations)

   333

   334

    def getconfiguration(self, name):

   335

        for configuration in self.instances.configurations.getconfiguration():

   336

            if configuration.getname() == name:

   337

                return configuration

   338

        return None

   339

    setattr(cls, "getconfiguration", getconfiguration)

   340

   341

    def addconfiguration(self, name):

   342

        for configuration in self.instances.configurations.getconfiguration():

   343

            if configuration.getname() == name:

   344

                raise ValueError, _("\"%s\" configuration already exists !!!")%name

   346

        new_configuration.setname(name)

   347

        self.instances.configurations.appendconfiguration(new_configuration)

   348

    setattr(cls, "addconfiguration", addconfiguration)    

   349

   350

    def removeconfiguration(self, name):

   351

        found = False

   352

        for idx, configuration in enumerate(self.instances.configurations.getconfiguration()):

   353

            if configuration.getname() == name:

   354

                self.instances.configurations.removeconfiguration(idx)

   355

                found = True

   356

                break

   357

        if not found:

   358

            raise ValueError, ("\"%s\" configuration doesn't exist !!!")%name

   359

    setattr(cls, "removeconfiguration", removeconfiguration)

   360

   361

    def getconfigurationResource(self, config_name, name):

   362

        configuration = self.getconfiguration(config_name)

   363

        if configuration:

   364

            for resource in configuration.getresource():

   365

                if resource.getname() == name:

   366

                    return resource

   367

        return None

   368

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   369

   370

    def addconfigurationResource(self, config_name, name):

   371

        configuration = self.getconfiguration(config_name)

   372

        if configuration:

   373

            for resource in configuration.getresource():

   374

                if resource.getname() == name:

   375

                    raise ValueError, _("\"%s\" resource already exists in \"%s\" configuration !!!")%(name, config_name)

   377

            new_resource.setname(name)

   378

            configuration.appendresource(new_resource)

   379

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   380

   381

    def removeconfigurationResource(self, config_name, name):

   382

        configuration = self.getconfiguration(config_name)

   383

        if configuration:

   384

            found = False

   385

            for idx, resource in enumerate(configuration.getresource()):

   386

                if resource.getname() == name:

   387

                    configuration.removeresource(idx)

   388

                    found = True

   389

                    break

   390

            if not found:

   391

                raise ValueError, _("\"%s\" resource doesn't exist in \"%s\" configuration !!!")%(name, config_name)

   392

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   393

   394

    def updateElementName(self, old_name, new_name):

   395

        for datatype in self.types.getdataTypeElements():

   396

            datatype.updateElementName(old_name, new_name)

   397

        for pou in self.types.getpouElements():

   398

            pou.updateElementName(old_name, new_name)

   399

        for configuration in self.instances.configurations.getconfiguration():

   400

            configuration.updateElementName(old_name, new_name)

   401

    setattr(cls, "updateElementName", updateElementName)

   402

   403

    def updateElementAddress(self, old_leading, new_leading):

   404

        address_model = re.compile(FILTER_ADDRESS_MODEL % old_leading)

   405

        for pou in self.types.getpouElements():

   406

            pou.updateElementAddress(address_model, new_leading)

   407

        for configuration in self.instances.configurations.getconfiguration():

   408

            configuration.updateElementAddress(address_model, new_leading)

   409

    setattr(cls, "updateElementAddress", updateElementAddress)

   410

   411

    def removeVariableByAddress(self, address):

   412

        for pou in self.types.getpouElements():

   413

            pou.removeVariableByAddress(address)

   414

        for configuration in self.instances.configurations.getconfiguration():

   415

            configuration.removeVariableByAddress(address)

   416

    setattr(cls, "removeVariableByAddress", removeVariableByAddress)

   417

   418

    def removeVariableByFilter(self, leading):

   419

        address_model = re.compile(FILTER_ADDRESS_MODEL % leading)

   420

        for pou in self.types.getpouElements():

   421

            pou.removeVariableByFilter(address_model)

   422

        for configuration in self.instances.configurations.getconfiguration():

   423

            configuration.removeVariableByFilter(address_model)

   424

    setattr(cls, "removeVariableByFilter", removeVariableByFilter)

   425

   426

    def RefreshDataTypeHierarchy(self):

   427

        self.EnumeratedDataTypeValues = {}

   428

        self.CustomDataTypeRange = {}

   429

        self.CustomTypeHierarchy = {}

   430

        for datatype in self.getdataTypes():

   431

            self.AddCustomDataType(datatype)

   432

    setattr(cls, "RefreshDataTypeHierarchy", RefreshDataTypeHierarchy)

   433

   434

    def AddCustomDataType(self, datatype):

   435

        name = datatype.getname()

   436

        basetype_content = datatype.getbaseType().getcontent()

   447

            self.CustomDataTypeRange[name] = range

   451

            else:

   453

        else:

   455

                values = []

   457

                    values.append(value.getname())

   458

                self.EnumeratedDataTypeValues[name] = values

   459

            self.CustomTypeHierarchy[name] = "ANY_DERIVED"

   460

    setattr(cls, "AddCustomDataType", AddCustomDataType)

   461

   462

    # Update Block types with user-defined pou added

   463

    def RefreshCustomBlockTypes(self):

   464

        # Reset the tree of user-defined pou cross-use

   465

        self.CustomBlockTypes = OrderedDict()

   466

        for pou in self.getpous():

   467

            self.AddCustomBlockType(pou)

   468

    setattr(cls, "RefreshCustomBlockTypes", RefreshCustomBlockTypes)

   469

   470

    def AddCustomBlockType(self, pou): 

   471

        pou_name = pou.getname()

   472

        pou_type = pou.getpouType()

   473

        block_infos = {"name" : pou_name, "type" : pou_type, "extensible" : False,

   474

                       "inputs" : [], "outputs" : [], "comment" : pou.getdescription(),

   475

                       "generate" : generate_block, "initialise" : initialise_block}

   476

        if pou.getinterface():

   477

            return_type = pou.interface.getreturnType()

   478

            if return_type:

   479

                var_type = return_type.getcontent()

   485

                else:

   487

            for type, varlist in pou.getvars():

   488

                if type == "InOut":

   489

                    for var in varlist.getvariable():

   490

                        var_type = var.type.getcontent()

   498

                        else:

   501

                elif type == "Input":

   502

                    for var in varlist.getvariable():

   503

                        var_type = var.type.getcontent()

   509

                        else:

   511

                elif type == "Output":

   512

                    for var in varlist.getvariable():

   513

                        var_type = var.type.getcontent()

   519

                        else: