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

from xml.dom import minidom

    27

from types import StringType, UnicodeType, TupleType

    28

from lxml import etree

    29

from copy import deepcopy

    30

import os,sys,re

    31

import datetime

    32

import util.paths as paths

    33

from time import localtime

    34

from collections import OrderedDict, namedtuple

    35

    36

from plcopen import *

    37

from graphics.GraphicCommons import *

    38

from PLCGenerator import *

    39

    40

duration_model = re.compile("(?:([0-9]{1,2})h)?(?:([0-9]{1,2})m(?!s))?(?:([0-9]{1,2})s)?(?:([0-9]{1,3}(?:\.[0-9]*)?)ms)?")

    41

    42

ITEMS_EDITABLE = [ITEM_PROJECT,

    43

                  ITEM_POU,

    44

                  ITEM_VARIABLE,

    45

                  ITEM_TRANSITION,

    46

                  ITEM_ACTION,

    47

                  ITEM_CONFIGURATION,

    48

                  ITEM_RESOURCE,

    49

                  ITEM_DATATYPE

    50

                 ] = range(8)

    51

    52

ITEMS_UNEDITABLE = [ITEM_DATATYPES,

    53

                    ITEM_FUNCTION,

    54

                    ITEM_FUNCTIONBLOCK,

    55

                    ITEM_PROGRAM,

    56

                    ITEM_TRANSITIONS,

    57

                    ITEM_ACTIONS,

    58

                    ITEM_CONFIGURATIONS,

    59

                    ITEM_RESOURCES,

    60

                    ITEM_PROPERTIES

    61

                   ] = range(8, 17)

    62

    63

ITEMS_VARIABLE = [ITEM_VAR_LOCAL,

    64

                  ITEM_VAR_GLOBAL,

    65

                  ITEM_VAR_EXTERNAL,

    66

                  ITEM_VAR_TEMP,

    67

                  ITEM_VAR_INPUT,

    68

                  ITEM_VAR_OUTPUT,

    69

                  ITEM_VAR_INOUT

    70

                 ] = range(17, 24)

    71

    72

VAR_CLASS_INFOS = {

    73

    "Local":    ("localVars",    ITEM_VAR_LOCAL),

    74

    "Global":   ("globalVars",   ITEM_VAR_GLOBAL),

    75

    "External": ("externalVars", ITEM_VAR_EXTERNAL),

    76

    "Temp":     ("tempVars",     ITEM_VAR_TEMP),

    77

    "Input":    ("inputVars",    ITEM_VAR_INPUT),

    78

    "Output":   ("outputVars",   ITEM_VAR_OUTPUT),

    79

    "InOut":    ("inOutVars",    ITEM_VAR_INOUT)}

    80

    81

POU_TYPES = {"program": ITEM_PROGRAM,

    82

             "functionBlock": ITEM_FUNCTIONBLOCK,

    83

             "function": ITEM_FUNCTION,

    84

            }

    85

    86

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    87

                   LOCATION_MODULE,

    88

                   LOCATION_GROUP,

    89

                   LOCATION_VAR_INPUT,

    90

                   LOCATION_VAR_OUTPUT,

    91

                   LOCATION_VAR_MEMORY] = range(6)

    92

    93

ScriptDirectory = paths.AbsDir(__file__)

    94

    95

def GetUneditableNames():

    96

    _ = lambda x:x

    97

    return [_("User-defined POUs"), _("Functions"), _("Function Blocks"),

    98

            _("Programs"), _("Data Types"), _("Transitions"), _("Actions"),

    99

            _("Configurations"), _("Resources"), _("Properties")]

   100

UNEDITABLE_NAMES = GetUneditableNames()

   101

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,

   102

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

   103

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   104

   105

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

   106

#                 Helper object for loading library in xslt stylesheets

   107

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

   108

   109

class LibraryResolver(etree.Resolver):

   110

   111

    def __init__(self, controller, debug=False):

   112

        self.Controller = controller

   113

        self.Debug = debug

   114

   115

    def resolve(self, url, pubid, context):

   116

        lib_name = os.path.basename(url)

   117

        if lib_name in ["project", "stdlib", "extensions"]:

   118

            lib_el = etree.Element(lib_name)

   119

            if lib_name == "project":

   120

                lib_el.append(deepcopy(self.Controller.GetProject(self.Debug)))

   121

            elif lib_name == "stdlib":

   122

                for lib in StdBlckLibs.values():

   123

                    lib_el.append(deepcopy(lib))

   124

            else:

   125

                for ctn in self.Controller.ConfNodeTypes:

   126

                    lib_el.append(deepcopy(ctn["types"]))

   127

            return self.resolve_string(etree.tostring(lib_el), context)

   128

   129

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

   130

#           Helpers functions for translating list of arguments

   131

#                       from xslt to valid arguments

   132

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

   133

   134

_StringValue = lambda x: x

   135

_BoolValue = lambda x: x in ["true", "0"]

   136

   137

def _translate_args(translations, args):

   138

    return [translate(arg[0]) if len(arg) > 0 else None

   139

            for translate, arg in

   140

            zip(translations, args)]

   141

   142

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

   143

#                 Helpers object for generating pou var list

   144

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

   145

   146

class _VariableInfos(object):

   147

    __slots__ = ["Name", "Class", "Option", "Location", "InitialValue",

   148

                 "Edit", "Documentation", "Type", "Tree", "Number"]

   149

    def __init__(self, *args):

   150

        for attr, value in zip(self.__slots__, args):

   151

            setattr(self, attr, value if value is not None else "")

   152

    def copy(self):

   153

        return _VariableInfos(*[getattr(self, attr) for attr in self.__slots__])

   154

   155

class VariablesInfosFactory:

   156

   157

    def __init__(self, variables):

   158

        self.Variables = variables

   159

        self.TreeStack = []

   160

        self.Type = None

   161

        self.Dimensions = None

   162

   163

    def SetType(self, context, *args):

   164

        self.Type = args[0][0]

   165

   166

    def GetType(self):

   167

        if len(self.Dimensions) > 0:

   168

            return ("array", self.Type, self.Dimensions)

   169

        return self.Type

   170

   171

    def GetTree(self):

   172

        return (self.TreeStack.pop(-1), self.Dimensions)

   173

   174

    def AddDimension(self, context, *args):

   175

        self.Dimensions.append(tuple(

   176

            _translate_args([_StringValue] * 2, args)))

   177

   178

    def AddTree(self, context, *args):

   179

        self.TreeStack.append([])

   180

        self.Dimensions = []

   181

   182

    def AddVarToTree(self, context, *args):

   183

        var = (args[0][0], self.Type, self.GetTree())

   184

        self.TreeStack[-1].append(var)

   185

   186

    def AddVariable(self, context, *args):

   187

        self.Variables.append(_VariableInfos(*(_translate_args(

   188

            [_StringValue] * 5 + [_BoolValue] + [_StringValue], args) +

   189

            [self.GetType(), self.GetTree()])))

   190

   191

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

   192

#            Helpers object for generating pou variable instance list

   193

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

   194

   195

def class_extraction(value):

   196

    class_type = {

   197

        "configuration": ITEM_CONFIGURATION,

   198

        "resource": ITEM_RESOURCE,

   199

        "action": ITEM_ACTION,

   200

        "transition": ITEM_TRANSITION,

   201

        "program": ITEM_PROGRAM}.get(value)

   202

    if class_type is not None:

   203

        return class_type

   204

   205

    pou_type = POU_TYPES.get(value)

   206

    if pou_type is not None:

   207

        return pou_type

   208

   209

    var_type = VAR_CLASS_INFOS.get(value)

   210

    if var_type is not None:

   211

        return var_type[1]

   212

   213

    return None

   214

   215

class _VariablesTreeItemInfos(object):

   216

    __slots__ = ["name", "var_class", "type", "edit", "debug", "variables"]

   217

    def __init__(self, *args):

   218

        for attr, value in zip(self.__slots__, args):

   219

            setattr(self, attr, value if value is not None else "")

   220

    def copy(self):

   221

        return _VariableTreeItem(*[getattr(self, attr) for attr in self.__slots__])

   222

   223

class VariablesTreeInfosFactory:

   224

   225

    def __init__(self):

   226

        self.Root = None

   227

   228

    def GetRoot(self):

   229

        return self.Root

   230

   231

    def SetRoot(self, context, *args):

   232

        self.Root = _VariablesTreeItemInfos(

   233

            *([''] + _translate_args(

   234

                [class_extraction, _StringValue] + [_BoolValue] * 2,

   235

                args) + [[]]))

   236

   237

    def AddVariable(self, context, *args):

   238

        if self.Root is not None:

   239

            self.Root.variables.append(_VariablesTreeItemInfos(

   240

                *(_translate_args(

   241

                    [_StringValue, class_extraction, _StringValue] +

   242

                    [_BoolValue] * 2, args) + [[]])))

   243

   244

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

   245

#            Helpers object for generating instances path list

   246

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

   247

   248

class InstancesPathFactory:

   249

   250

    def __init__(self, instances):

   251

        self.Instances = instances

   252

   253

    def AddInstance(self, context, *args):

   254

        self.Instances.append(args[0][0])

   255

   256

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

   257

#            Helpers object for generating instance tagname

   258

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

   259

   260

class InstanceTagName:

   261

   262

    def __init__(self, controller):

   263

        self.Controller = controller

   264

        self.TagName = None

   265

   266

    def GetTagName(self):

   267

        return self.TagName

   268

   269

    def ConfigTagName(self, context, *args):

   270

        self.TagName = self.Controller.ComputeConfigurationName(args[0][0])

   271

   272

    def ResourceTagName(self, context, *args):

   273

        self.TagName = self.Controller.ComputeConfigurationResourceName(args[0][0], args[1][0])

   274

   275

    def PouTagName(self, context, *args):

   276

        self.TagName = self.Controller.ComputePouName(args[0][0])

   277

   278

    def ActionTagName(self, context, *args):

   279

        self.TagName = self.Controller.ComputePouActionName(args[0][0], args[0][1])

   280

   281

    def TransitionTagName(self, context, *args):

   282

        self.TagName = self.Controller.ComputePouTransitionName(args[0][0], args[0][1])

   283

   284

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

   285

#           Helpers object for generating pou block instances list

   286

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

   287

   288

_Point = namedtuple("Point", ["x", "y"])

   289

   290

_BlockInstanceInfos = namedtuple("BlockInstanceInfos",

   291

    ["type", "id", "x", "y", "width", "height", "specific_values", "inputs", "outputs"])

   292

   293

_BlockSpecificValues = (

   294

    namedtuple("BlockSpecificValues",

   295

               ["name", "execution_order"]),

   296

    [_StringValue, int])

   297

_VariableSpecificValues = (

   298

    namedtuple("VariableSpecificValues",

   299

               ["name", "value_type", "execution_order"]),

   300

    [_StringValue, _StringValue, int])

   301

_ConnectionSpecificValues = (

   302

    namedtuple("ConnectionSpecificValues", ["name"]),

   303

    [_StringValue])

   304

   305

_PowerRailSpecificValues = (

   306

    namedtuple("PowerRailSpecificValues", ["connectors"]),

   307

    [int])

   308

   309

_LDElementSpecificValues = (

   310

    namedtuple("LDElementSpecificValues",

   311

               ["name", "negated", "edge", "storage", "execution_order"]),

   312

    [_StringValue, _BoolValue, _StringValue, _StringValue, int])

   313

   314

_DivergenceSpecificValues = (

   315

    namedtuple("DivergenceSpecificValues", ["connectors"]),

   316

    [int])

   317

   318

_SpecificValuesTuples = {

   319

    "comment": (

   320

        namedtuple("CommentSpecificValues", ["content"]),

   321

        [_StringValue]),

   322

    "input": _VariableSpecificValues,

   323

    "output": _VariableSpecificValues,

   324

    "inout": _VariableSpecificValues,

   325

    "connector": _ConnectionSpecificValues,

   326

    "continuation": _ConnectionSpecificValues,

   327

    "leftPowerRail": _PowerRailSpecificValues,

   328

    "rightPowerRail": _PowerRailSpecificValues,

   329

    "contact": _LDElementSpecificValues,

   330

    "coil": _LDElementSpecificValues,

   331

    "step": (

   332

        namedtuple("StepSpecificValues", ["name", "initial", "action"]),

   333

        [_StringValue, _BoolValue, lambda x: x]),

   334

    "transition": (

   335

        namedtuple("TransitionSpecificValues",

   336

                   ["priority", "condition_type", "condition", "connection"]),

   337

        [int, _StringValue, _StringValue, lambda x: x]),

   338

    "selectionDivergence": _DivergenceSpecificValues,

   339

    "selectionConvergence": _DivergenceSpecificValues,

   340

    "simultaneousDivergence": _DivergenceSpecificValues,

   341

    "simultaneousConvergence": _DivergenceSpecificValues,

   342

    "jump": (

   343

        namedtuple("JumpSpecificValues", ["target"]),

   344

        [_StringValue]),

   345

    "actionBlock": (

   346

        namedtuple("ActionBlockSpecificValues", ["actions"]),

   347

        [lambda x: x]),

   348

}

   349

   350

_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",

   351

    ["name", "negated", "edge", "position", "links"])

   352

   353

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

   354

    ["refLocalId", "formalParameter", "points"])

   355

   356

class _ActionInfos(object):

   357

    __slots__ = ["qualifier", "type", "value", "duration", "indicator"]

   358

    def __init__(self, *args):

   359

        for attr, value in zip(self.__slots__, args):

   360

            setattr(self, attr, value if value is not None else "")

   361

    def copy(self):

   362

        return _ActionInfos(*[getattr(self, attr) for attr in self.__slots__])

   363

   364

class BlockInstanceFactory:

   365

   366

    def __init__(self, block_instances):

   367

        self.BlockInstances = block_instances

   368

        self.CurrentInstance = None

   369

        self.SpecificValues = None

   370

        self.CurrentConnection = None

   371

        self.CurrentLink = None

   372

   373

    def SetSpecificValues(self, context, *args):

   374

        self.SpecificValues = list(args)

   375

        self.CurrentInstance = None

   376

        self.CurrentConnection = None

   377

        self.CurrentLink = None

   378

   379

    def AddBlockInstance(self, context, *args):

   380

        specific_values_tuple, specific_values_translation = \

   381

            _SpecificValuesTuples.get(args[0][0], _BlockSpecificValues)

   382

   383

        if (args[0][0] == "step" and len(self.SpecificValues) < 3 or

   384

            args[0][0] == "transition" and len(self.SpecificValues) < 4):

   385

            self.SpecificValues.append([None])

   386

        elif args[0][0] == "actionBlock" and len(self.SpecificValues) < 1:

   387

            self.SpecificValues.append([[]])

   388

        specific_values = specific_values_tuple(*_translate_args(

   389

            specific_values_translation, self.SpecificValues))

   390

        self.SpecificValues = None

   391

   392

        self.CurrentInstance = _BlockInstanceInfos(

   393

            *(_translate_args([_StringValue, int] + [float] * 4, args) +

   394

              [specific_values, [], []]))

   395

   396

        self.BlockInstances[self.CurrentInstance.id] = self.CurrentInstance

   397

   398

    def AddInstanceConnection(self, context, *args):

   399

        connection_args = _translate_args(

   400

            [_StringValue] * 2 + [_BoolValue, _StringValue] + [float] * 2, args)

   401

   402

        self.CurrentConnection = _InstanceConnectionInfos(

   403

            *(connection_args[1:4] + [

   404

                _Point(*connection_args[4:6]), []]))

   405

   406

        if self.CurrentInstance is not None:

   407

            if connection_args[0] == "input":

   408

                self.CurrentInstance.inputs.append(self.CurrentConnection)

   409

            else:

   410

                self.CurrentInstance.outputs.append(self.CurrentConnection)

   411

        else:

   412

            self.SpecificValues.append([self.CurrentConnection])

   413

   414

    def AddConnectionLink(self, context, *args):

   415

        self.CurrentLink = _ConnectionLinkInfos(

   416

            *(_translate_args([int, _StringValue], args) + [[]]))

   417

        self.CurrentConnection.links.append(self.CurrentLink)

   418

   419

    def AddLinkPoint(self, context, *args):

   420

        self.CurrentLink.points.append(_Point(

   421

            *_translate_args([float] * 2, args)))

   422

   423

    def AddAction(self, context, *args):

   424

        if len(self.SpecificValues) == 0:

   425

            self.SpecificValues.append([[]])

   426

        translated_args = _translate_args([_StringValue] * 5, args)

   427

        self.SpecificValues[0][0].append(_ActionInfos(*translated_args))

   428

   429

pou_block_instances_xslt = etree.parse(

   430

    os.path.join(ScriptDirectory, "plcopen", "pou_block_instances.xslt"))

   431

   432

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

   433

#                         Undo Buffer for PLCOpenEditor

   434

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

   435

   436

# Length of the buffer

   437

UNDO_BUFFER_LENGTH = 20

   438

   439

"""

   440

Class implementing a buffer of changes made on the current editing model

   441

"""

   442

class UndoBuffer:

   443

   444

    # Constructor initialising buffer

   445

    def __init__(self, currentstate, issaved = False):

   446

        self.Buffer = []

   447

        self.CurrentIndex = -1

   448

        self.MinIndex = -1

   449

        self.MaxIndex = -1

   450

        # if current state is defined

   451

        if currentstate:

   452

            self.CurrentIndex = 0

   453

            self.MinIndex = 0

   454

            self.MaxIndex = 0

   455

        # Initialising buffer with currentstate at the first place

   456

        for i in xrange(UNDO_BUFFER_LENGTH):

   457

            if i == 0:

   458

                self.Buffer.append(currentstate)

   459

            else:

   460

                self.Buffer.append(None)

   461

        # Initialising index of state saved

   462

        if issaved:

   463

            self.LastSave = 0

   464

        else:

   465

            self.LastSave = -1

   466

   467

    # Add a new state in buffer

   468

    def Buffering(self, currentstate):

   469

        self.CurrentIndex = (self.CurrentIndex + 1) % UNDO_BUFFER_LENGTH

   470

        self.Buffer[self.CurrentIndex] = currentstate

   471

        # Actualising buffer limits

   472

        self.MaxIndex = self.CurrentIndex

   473

        if self.MinIndex == self.CurrentIndex:

   474

            # If the removed state was the state saved, there is no state saved in the buffer

   475

            if self.LastSave == self.MinIndex:

   476

                self.LastSave = -1

   477

            self.MinIndex = (self.MinIndex + 1) % UNDO_BUFFER_LENGTH

   478

        self.MinIndex = max(self.MinIndex, 0)

   479

   480

    # Return current state of buffer

   481

    def Current(self):

   482

        return self.Buffer[self.CurrentIndex]

   483

   484

    # Change current state to previous in buffer and return new current state

   485

    def Previous(self):

   486

        if self.CurrentIndex != self.MinIndex:

   487

            self.CurrentIndex = (self.CurrentIndex - 1) % UNDO_BUFFER_LENGTH

   488

            return self.Buffer[self.CurrentIndex]

   489

        return None

   490

   491

    # Change current state to next in buffer and return new current state

   492

    def Next(self):

   493

        if self.CurrentIndex != self.MaxIndex: