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 types import TupleType

    29

from copy import deepcopy

    30

import os

    31

import re

    32

import datetime

    33

from time import localtime

    34

from collections import OrderedDict, namedtuple

    35

    36

from lxml import etree

    37

    38

import util.paths as paths

    39

from util.TranslationCatalogs import NoTranslate

    40

from plcopen import *

    42

from graphics.GraphicCommons import *

    43

from PLCGenerator import *

    44

    45

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)?")

    46

    47

ITEMS_EDITABLE = [

    48

    ITEM_PROJECT,

    49

    ITEM_POU,

    50

    ITEM_VARIABLE,

    51

    ITEM_TRANSITION,

    52

    ITEM_ACTION,

    53

    ITEM_CONFIGURATION,

    54

    ITEM_RESOURCE,

    55

    ITEM_DATATYPE

    56

] = range(8)

    57

    58

ITEMS_UNEDITABLE = [

    59

    ITEM_DATATYPES,

    60

    ITEM_FUNCTION,

    61

    ITEM_FUNCTIONBLOCK,

    62

    ITEM_PROGRAM,

    63

    ITEM_TRANSITIONS,

    64

    ITEM_ACTIONS,

    65

    ITEM_CONFIGURATIONS,

    66

    ITEM_RESOURCES,

    67

    ITEM_PROPERTIES

    68

] = range(8, 17)

    69

    70

ITEMS_VARIABLE = [

    71

    ITEM_VAR_LOCAL,

    72

    ITEM_VAR_GLOBAL,

    73

    ITEM_VAR_EXTERNAL,

    74

    ITEM_VAR_TEMP,

    75

    ITEM_VAR_INPUT,

    76

    ITEM_VAR_OUTPUT,

    77

    ITEM_VAR_INOUT

    78

] = range(17, 24)

    79

    80

VAR_CLASS_INFOS = {

    81

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

    82

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

    83

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

    84

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

    85

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

    86

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

    87

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

    88

    89

POU_TYPES = {

    90

    "program": ITEM_PROGRAM,

    91

    "functionBlock": ITEM_FUNCTIONBLOCK,

    92

    "function": ITEM_FUNCTION,

    93

}

    94

    95

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    96

                   LOCATION_MODULE,

    97

                   LOCATION_GROUP,

    98

                   LOCATION_VAR_INPUT,

    99

                   LOCATION_VAR_OUTPUT,

   100

                   LOCATION_VAR_MEMORY] = range(6)

   101

   102

ScriptDirectory = paths.AbsDir(__file__)

   103

   104

   105

def GetUneditableNames():

   106

    _ = NoTranslate

   107

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

   108

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

   109

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

   110

   111

   112

UNEDITABLE_NAMES = GetUneditableNames()

   113

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,

   114

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

   115

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   116

   117

   118

class LibraryResolver(etree.Resolver):

   119

    """Helper object for loading library in xslt stylesheets"""

   120

   121

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

   122

        self.Controller = controller

   123

        self.Debug = debug

   124

   125

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

   126

        # TODO stop deepcopy

   127

        lib_name = os.path.basename(url)

   128

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

   129

            lib_el = etree.Element(lib_name)

   130

            if lib_name == "project":

   131

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

   132

            elif lib_name == "stdlib":

   133

                for lib in StdBlckLibs.values():

   134

                    lib_el.append(deepcopy(lib))

   135

            else:

   136

                for ctn in self.Controller.ConfNodeTypes:

   137

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

   138

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

   139

   140

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

   141

#           Helpers functions for translating list of arguments

   142

#                       from xslt to valid arguments

   143

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

   144

   145

   146

def _StringValue(x):

   147

    return x

   148

   149

   150

def _BoolValue(x):

   151

    return x in ["true", "0"]

   152

   153

   154

def _translate_args(translations, args):

   155

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

   156

            for translate, arg in

   157

            zip(translations, args)]

   158

   159

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

   160

#                 Helpers object for generating pou var list

   161

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

   162

   163

   164

class _VariableInfos(object):

   165

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

   166

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

   167

   168

    def __init__(self, *args):

   169

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

   170

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

   171

   172

    def copy(self):

   173

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

   174

   175

   176

class VariablesInfosFactory(object):

   177

   178

    def __init__(self, variables):

   179

        self.Variables = variables

   180

        self.TreeStack = []

   181

        self.Type = None

   182

        self.Dimensions = None

   183

   184

    def SetType(self, context, *args):

   185

        self.Type = args[0][0]

   186

   187

    def GetType(self):

   188

        if len(self.Dimensions) > 0:

   189

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

   190

        return self.Type

   191

   192

    def GetTree(self):

   193

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

   194

   195

    def AddDimension(self, context, *args):

   196

        self.Dimensions.append(tuple(

   197

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

   198

   199

    def AddTree(self, context, *args):

   200

        self.TreeStack.append([])

   201

        self.Dimensions = []

   202

   203

    def AddVarToTree(self, context, *args):

   204

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

   205

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

   206

   207

    def AddVariable(self, context, *args):

   208

        self.Variables.append(_VariableInfos(*(

   209

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

   210

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

   211

   212

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

   213

#            Helpers object for generating pou variable instance list

   214

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

   215

   216

   217

def class_extraction(value):

   218

    class_type = {

   219

        "configuration": ITEM_CONFIGURATION,

   220

        "resource": ITEM_RESOURCE,

   221

        "action": ITEM_ACTION,

   222

        "transition": ITEM_TRANSITION,

   223

        "program": ITEM_PROGRAM}.get(value)

   224

    if class_type is not None:

   225

        return class_type

   226

   227

    pou_type = POU_TYPES.get(value)

   228

    if pou_type is not None:

   229

        return pou_type

   230

   231

    var_type = VAR_CLASS_INFOS.get(value)

   232

    if var_type is not None:

   233

        return var_type[1]

   234

   235

    return None

   236

   237

   238

class _VariablesTreeItemInfos(object):

   239

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

   240

   241

    def __init__(self, *args):

   242

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

   243

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

   244

   245

    def copy(self):

   246

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

   247

   248

   249

class VariablesTreeInfosFactory(object):

   250

   251

    def __init__(self):

   252

        self.Root = None

   253

   254

    def GetRoot(self):

   255

        return self.Root

   256

   257

    def SetRoot(self, context, *args):

   258

        self.Root = _VariablesTreeItemInfos(

   259

            *([''] + _translate_args(

   260

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

   261

                args) + [[]]))

   262

   263

    def AddVariable(self, context, *args):

   264

        if self.Root is not None:

   265

            self.Root.variables.append(_VariablesTreeItemInfos(

   266

                *(_translate_args(

   267

                    [_StringValue, class_extraction, _StringValue] +

   268

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

   269

   270

   271

class InstanceTagName(object):

   272

    """Helpers object for generating instance tagname"""

   273

   274

    def __init__(self, controller):

   275

        self.Controller = controller

   276

        self.TagName = None

   277

   278

    def GetTagName(self):

   279

        return self.TagName

   280

   281

    def ConfigTagName(self, context, *args):

   282

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

   283

   284

    def ResourceTagName(self, context, *args):

   285

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

   286

   287

    def PouTagName(self, context, *args):

   288

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

   289

   290

    def ActionTagName(self, context, *args):

   291

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

   292

   293

    def TransitionTagName(self, context, *args):

   294

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

   295

   296

   297

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

   298

#           Helpers object for generating pou block instances list

   299

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

   300

   301

   302

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

   303

   304

_BlockInstanceInfos = namedtuple(

   305

    "BlockInstanceInfos",

   306

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

   307

   308

_BlockSpecificValues = (

   309

    namedtuple("BlockSpecificValues",

   310

               ["name", "execution_order"]),

   311

    [_StringValue, int])

   312

_VariableSpecificValues = (

   313

    namedtuple("VariableSpecificValues",

   314

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

   315

    [_StringValue, _StringValue, int])

   316

_ConnectionSpecificValues = (

   317

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

   318

    [_StringValue])

   319

   320

_PowerRailSpecificValues = (

   321

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

   322

    [int])

   323

   324

_LDElementSpecificValues = (

   325

    namedtuple("LDElementSpecificValues",

   326

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

   327

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

   328

   329

_DivergenceSpecificValues = (

   330

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

   331

    [int])

   332

   333

_SpecificValuesTuples = {

   334

    "comment": (

   335

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

   336

        [_StringValue]),

   337

    "input": _VariableSpecificValues,

   338

    "output": _VariableSpecificValues,

   339

    "inout": _VariableSpecificValues,

   340

    "connector": _ConnectionSpecificValues,

   341

    "continuation": _ConnectionSpecificValues,

   342

    "leftPowerRail": _PowerRailSpecificValues,

   343

    "rightPowerRail": _PowerRailSpecificValues,

   344

    "contact": _LDElementSpecificValues,

   345

    "coil": _LDElementSpecificValues,

   346

    "step": (

   347

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

   348

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

   349

    "transition": (

   350

        namedtuple("TransitionSpecificValues",

   351

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

   352

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

   353

    "selectionDivergence": _DivergenceSpecificValues,

   354

    "selectionConvergence": _DivergenceSpecificValues,

   355

    "simultaneousDivergence": _DivergenceSpecificValues,

   356

    "simultaneousConvergence": _DivergenceSpecificValues,

   357

    "jump": (

   358

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

   359

        [_StringValue]),

   360

    "actionBlock": (

   361

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

   362

        [lambda x: x]),

   363

}

   364

   365

_InstanceConnectionInfos = namedtuple(

   366

    "InstanceConnectionInfos",

   367

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

   368

   369

_ConnectionLinkInfos = namedtuple(

   370

    "ConnectionLinkInfos",

   371

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

   372

   373

   374

class _ActionInfos(object):

   375

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

   376

   377

    def __init__(self, *args):

   378

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

   379

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

   380

   381

    def copy(self):

   382

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

   383

   384

   385

class BlockInstanceFactory(object):

   386

   387

    def __init__(self, block_instances):

   388

        self.BlockInstances = block_instances

   389

        self.CurrentInstance = None

   390

        self.SpecificValues = None

   391

        self.CurrentConnection = None

   392

        self.CurrentLink = None

   393

   394

    def SetSpecificValues(self, context, *args):

   395

        self.SpecificValues = list(args)

   396

        self.CurrentInstance = None

   397

        self.CurrentConnection = None

   398

        self.CurrentLink = None

   399

   400

    def AddBlockInstance(self, context, *args):

   401

        specific_values_tuple, specific_values_translation = \

   402

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

   403

   404

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

   405

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

   406

            self.SpecificValues.append([None])

   407

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

   408

            self.SpecificValues.append([[]])

   409

        specific_values = specific_values_tuple(*_translate_args(

   410

            specific_values_translation, self.SpecificValues))

   411

        self.SpecificValues = None

   412

   413

        self.CurrentInstance = _BlockInstanceInfos(

   414

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

   415

              [specific_values, [], []]))

   416

   417

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

   418

   419

    def AddInstanceConnection(self, context, *args):

   420

        connection_args = _translate_args(

   421

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

   422

   423

        self.CurrentConnection = _InstanceConnectionInfos(

   424

            *(connection_args[1:4] + [

   425

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

   426

   427

        if self.CurrentInstance is not None:

   428

            if connection_args[0] == "input":

   429

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

   430

            else:

   431

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

   432

        else:

   433

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

   434

   435

    def AddConnectionLink(self, context, *args):

   436

        self.CurrentLink = _ConnectionLinkInfos(

   437

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

   438

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

   439

   440

    def AddLinkPoint(self, context, *args):

   441

        self.CurrentLink.points.append(_Point(

   442

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

   443

   444

    def AddAction(self, context, *args):

   445

        if len(self.SpecificValues) == 0:

   446

            self.SpecificValues.append([[]])

   447

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

   448

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

   449

   450

   451

pou_block_instances_xslt = etree.parse(

   452

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

   453

   454

   455

# Length of the buffer

   456

UNDO_BUFFER_LENGTH = 20

   457

   458

   459

class UndoBuffer(object):

   460

    """

   461

    Undo Buffer for PLCOpenEditor

   462

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

   463

    """

   464

   465

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

   466

        """

   467

        Constructor initialising buffer

   468

        """

   469

        self.Buffer = []

   470

        self.CurrentIndex = -1

   471

        self.MinIndex = -1

   472

        self.MaxIndex = -1

   473

        # if current state is defined

   474

        if currentstate:

   475

            self.CurrentIndex = 0

   476

            self.MinIndex = 0

   477

            self.MaxIndex = 0

   478

        # Initialising buffer with currentstate at the first place

   479

        for i in xrange(UNDO_BUFFER_LENGTH):

   480

            if i == 0:

   481

                self.Buffer.append(currentstate)

   482

            else:

   483

                self.Buffer.append(None)

   484

        # Initialising index of state saved

   485

        if issaved: