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

    28

from copy import deepcopy

    29

import os

    30

import re

    31

import datetime

    32

from time import localtime

    33

from collections import OrderedDict, namedtuple

    34

    35

from lxml import etree

    36

    37

import util.paths as paths

    38

from util.TranslationCatalogs import NoTranslate

    39

from plcopen import *

    40

from graphics.GraphicCommons import *

    41

from PLCGenerator import *

    42

    43

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

    44

    45

ITEMS_EDITABLE = [

    46

    ITEM_PROJECT,

    47

    ITEM_POU,

    48

    ITEM_VARIABLE,

    49

    ITEM_TRANSITION,

    50

    ITEM_ACTION,

    51

    ITEM_CONFIGURATION,

    52

    ITEM_RESOURCE,

    53

    ITEM_DATATYPE

    54

] = range(8)

    55

    56

ITEMS_UNEDITABLE = [

    57

    ITEM_DATATYPES,

    58

    ITEM_FUNCTION,

    59

    ITEM_FUNCTIONBLOCK,

    60

    ITEM_PROGRAM,

    61

    ITEM_TRANSITIONS,

    62

    ITEM_ACTIONS,

    63

    ITEM_CONFIGURATIONS,

    64

    ITEM_RESOURCES,

    65

    ITEM_PROPERTIES

    66

] = range(8, 17)

    67

    68

ITEMS_VARIABLE = [

    69

    ITEM_VAR_LOCAL,

    70

    ITEM_VAR_GLOBAL,

    71

    ITEM_VAR_EXTERNAL,

    72

    ITEM_VAR_TEMP,

    73

    ITEM_VAR_INPUT,

    74

    ITEM_VAR_OUTPUT,

    75

    ITEM_VAR_INOUT

    76

] = range(17, 24)

    77

    78

VAR_CLASS_INFOS = {

    79

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

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

    87

POU_TYPES = {

    88

    "program": ITEM_PROGRAM,

    89

    "functionBlock": ITEM_FUNCTIONBLOCK,

    90

    "function": ITEM_FUNCTION,

    91

}

    92

    93

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    94

                   LOCATION_MODULE,

    95

                   LOCATION_GROUP,

    96

                   LOCATION_VAR_INPUT,

    97

                   LOCATION_VAR_OUTPUT,

    98

                   LOCATION_VAR_MEMORY] = range(6)

    99

   100

ScriptDirectory = paths.AbsDir(__file__)

   101

   102

   103

def GetUneditableNames():

   104

    _ = NoTranslate

   105

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

   106

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

   107

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

   108

   109

   110

UNEDITABLE_NAMES = GetUneditableNames()

   111

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,

   112

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

   113

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   114

   115

   116

class LibraryResolver(etree.Resolver):

   117

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

   118

   119

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

   120

        self.Controller = controller

   121

        self.Debug = debug

   122

   123

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

   124

        lib_name = os.path.basename(url)

   125

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

   126

            lib_el = etree.Element(lib_name)

   127

            if lib_name == "project":

   128

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

   129

            elif lib_name == "stdlib":

   130

                for lib in StdBlckLibs.values():

   131

                    lib_el.append(deepcopy(lib))

   132

            else:

   133

                for ctn in self.Controller.ConfNodeTypes:

   134

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

   135

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

   136

   137

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

   138

#           Helpers functions for translating list of arguments

   139

#                       from xslt to valid arguments

   140

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

   141

   142

   143

def _StringValue(x):

   144

    return x

   145

   146

   147

def _BoolValue(x):

   148

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

   149

   150

   151

def _translate_args(translations, args):

   152

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

   153

            for translate, arg in

   154

            zip(translations, args)]

   155

   156

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

   157

#                 Helpers object for generating pou var list

   158

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

   159

   160

   161

class _VariableInfos(object):

   162

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

   163

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

   164

   165

    def __init__(self, *args):

   166

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

   167

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

   168

   169

    def copy(self):

   170

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

   171

   172

   173

class VariablesInfosFactory(object):

   174

   175

    def __init__(self, variables):

   176

        self.Variables = variables

   177

        self.TreeStack = []

   178

        self.Type = None

   179

        self.Dimensions = None

   180

   181

    def SetType(self, context, *args):

   182

        self.Type = args[0][0]

   183

   184

    def GetType(self):

   185

        if len(self.Dimensions) > 0:

   186

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

   187

        return self.Type

   188

   189

    def GetTree(self):

   190

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

   191

   192

    def AddDimension(self, context, *args):

   193

        self.Dimensions.append(tuple(

   194

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

   195

   196

    def AddTree(self, context, *args):

   197

        self.TreeStack.append([])

   198

        self.Dimensions = []

   199

   200

    def AddVarToTree(self, context, *args):

   201

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

   202

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

   203

   204

    def AddVariable(self, context, *args):

   205

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

   206

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

   207

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

   208

   209

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

   210

#            Helpers object for generating pou variable instance list

   211

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

   212

   213

   214

def class_extraction(value):

   215

    class_type = {

   216

        "configuration": ITEM_CONFIGURATION,

   217

        "resource": ITEM_RESOURCE,

   218

        "action": ITEM_ACTION,

   219

        "transition": ITEM_TRANSITION,

   220

        "program": ITEM_PROGRAM}.get(value)

   221

    if class_type is not None:

   222

        return class_type

   223

   224

    pou_type = POU_TYPES.get(value)

   225

    if pou_type is not None:

   226

        return pou_type

   227

   228

    var_type = VAR_CLASS_INFOS.get(value)

   229

    if var_type is not None:

   230

        return var_type[1]

   231

   232

    return None

   233

   234

   235

class _VariablesTreeItemInfos(object):

   236

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

   237

   238

    def __init__(self, *args):

   239

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

   240

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

   241

   242

    def copy(self):

   243

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

   244

   245

   246

class VariablesTreeInfosFactory(object):

   247

   248

    def __init__(self):

   249

        self.Root = None

   250

   251

    def GetRoot(self):

   252

        return self.Root

   253

   254

    def SetRoot(self, context, *args):

   255

        self.Root = _VariablesTreeItemInfos(

   256

            *([''] + _translate_args(

   257

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

   258

                args) + [[]]))

   259

   260

    def AddVariable(self, context, *args):

   261

        if self.Root is not None:

   262

            self.Root.variables.append(_VariablesTreeItemInfos(

   263

                *(_translate_args(

   264

                    [_StringValue, class_extraction, _StringValue] +

   265

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

   266

   267

   268

class InstancesPathFactory(object):

   269

    """Helpers object for generating instances path list"""

   270

    def __init__(self, instances):

   271

        self.Instances = instances

   272

   273

    def AddInstance(self, context, *args):

   274

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

   275

   276

   277

class InstanceTagName(object):

   278

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

   279

   280

    def __init__(self, controller):

   281

        self.Controller = controller

   282

        self.TagName = None

   283

   284

    def GetTagName(self):

   285

        return self.TagName

   286

   287

    def ConfigTagName(self, context, *args):

   288

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

   289

   290

    def ResourceTagName(self, context, *args):

   291

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

   292

   293

    def PouTagName(self, context, *args):

   294

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

   295

   296

    def ActionTagName(self, context, *args):

   297

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

   298

   299

    def TransitionTagName(self, context, *args):

   300

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

   301

   302

   303

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

   304

#           Helpers object for generating pou block instances list

   305

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

   306

   307

   308

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

   309

   310

_BlockInstanceInfos = namedtuple(

   311

    "BlockInstanceInfos",

   312

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

   313

   314

_BlockSpecificValues = (

   315

    namedtuple("BlockSpecificValues",

   316

               ["name", "execution_order"]),

   317

    [_StringValue, int])

   318

_VariableSpecificValues = (

   319

    namedtuple("VariableSpecificValues",

   320

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

   321

    [_StringValue, _StringValue, int])

   322

_ConnectionSpecificValues = (

   323

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

   324

    [_StringValue])

   325

   326

_PowerRailSpecificValues = (

   327

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

   328

    [int])

   329

   330

_LDElementSpecificValues = (

   331

    namedtuple("LDElementSpecificValues",

   332

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

   333

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

   334

   335

_DivergenceSpecificValues = (

   336

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

   337

    [int])

   338

   339

_SpecificValuesTuples = {

   340

    "comment": (

   341

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

   342

        [_StringValue]),

   343

    "input": _VariableSpecificValues,

   344

    "output": _VariableSpecificValues,

   345

    "inout": _VariableSpecificValues,

   346

    "connector": _ConnectionSpecificValues,

   347

    "continuation": _ConnectionSpecificValues,

   348

    "leftPowerRail": _PowerRailSpecificValues,

   349

    "rightPowerRail": _PowerRailSpecificValues,

   350

    "contact": _LDElementSpecificValues,

   351

    "coil": _LDElementSpecificValues,

   352

    "step": (

   353

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

   354

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

   355

    "transition": (

   356

        namedtuple("TransitionSpecificValues",

   357

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

   358

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

   359

    "selectionDivergence": _DivergenceSpecificValues,

   360

    "selectionConvergence": _DivergenceSpecificValues,

   361

    "simultaneousDivergence": _DivergenceSpecificValues,

   362

    "simultaneousConvergence": _DivergenceSpecificValues,

   363

    "jump": (

   364

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

   365

        [_StringValue]),

   366

    "actionBlock": (

   367

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

   368

        [lambda x: x]),

   369

}

   370

   371

_InstanceConnectionInfos = namedtuple(

   372

    "InstanceConnectionInfos",

   373

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

   374

   375

_ConnectionLinkInfos = namedtuple(

   376

    "ConnectionLinkInfos",

   377

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

   378

   379

   380

class _ActionInfos(object):

   381

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

   382

   383

    def __init__(self, *args):

   384

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

   385

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

   386

   387

    def copy(self):

   388

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

   389

   390

   391

class BlockInstanceFactory(object):

   392

   393

    def __init__(self, block_instances):

   394

        self.BlockInstances = block_instances

   395

        self.CurrentInstance = None

   396

        self.SpecificValues = None

   397

        self.CurrentConnection = None

   398

        self.CurrentLink = None

   399

   400

    def SetSpecificValues(self, context, *args):

   401

        self.SpecificValues = list(args)

   402

        self.CurrentInstance = None

   403

        self.CurrentConnection = None

   404

        self.CurrentLink = None

   405

   406

    def AddBlockInstance(self, context, *args):

   407

        specific_values_tuple, specific_values_translation = \

   408

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

   409

   410

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

   411

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

   412

            self.SpecificValues.append([None])

   413

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

   414

            self.SpecificValues.append([[]])

   415

        specific_values = specific_values_tuple(*_translate_args(

   416

            specific_values_translation, self.SpecificValues))

   417

        self.SpecificValues = None

   418

   419

        self.CurrentInstance = _BlockInstanceInfos(

   420

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

   421

              [specific_values, [], []]))

   422

   423

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

   424

   425

    def AddInstanceConnection(self, context, *args):

   426

        connection_args = _translate_args(

   427

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

   428

   429

        self.CurrentConnection = _InstanceConnectionInfos(

   430

            *(connection_args[1:4] + [

   431

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

   432

   433

        if self.CurrentInstance is not None:

   434

            if connection_args[0] == "input":

   435

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

   436

            else:

   437

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

   438

        else:

   439

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

   440

   441

    def AddConnectionLink(self, context, *args):

   442

        self.CurrentLink = _ConnectionLinkInfos(

   443

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

   444

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

   445

   446

    def AddLinkPoint(self, context, *args):

   447

        self.CurrentLink.points.append(_Point(

   448

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

   449

   450

    def AddAction(self, context, *args):

   451

        if len(self.SpecificValues) == 0:

   452

            self.SpecificValues.append([[]])

   453

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

   454

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

   455

   456

   457

pou_block_instances_xslt = etree.parse(

   458

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

   459

   460

   461

# Length of the buffer

   462

UNDO_BUFFER_LENGTH = 20

   463

   464

   465

class UndoBuffer(object):

   466

    """

   467

    Undo Buffer for PLCOpenEditor

   468

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

   469

    """

   470

   471

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

   472

        """

   473

        Constructor initialising buffer

   474

        """

   475

        self.Buffer = []

   476

        self.CurrentIndex = -1

   477

        self.MinIndex = -1

   478

        self.MaxIndex = -1

   479

        # if current state is defined

   480

        if currentstate:

   481

            self.CurrentIndex = 0

   482

            self.MinIndex = 0

   483

            self.MaxIndex = 0

   484

        # Initialising buffer with currentstate at the first place

   485