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 *

    41

from graphics.GraphicCommons import *

    42

from PLCGenerator import *

    43

    44

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

    45

VARIABLE_NAME_SUFFIX_MODEL = re.compile('(\d+)$')

    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

        lib_name = os.path.basename(url)

   127

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

   128

            lib_el = etree.Element(lib_name)

   129

            if lib_name == "project":

   130

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

   131

            elif lib_name == "stdlib":

   132

                for lib in StdBlckLibs.values():

   133

                    lib_el.append(deepcopy(lib))

   134

            else:

   135

                for ctn in self.Controller.ConfNodeTypes:

   136

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

   137

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

   138

   139

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

   140

#           Helpers functions for translating list of arguments

   141

#                       from xslt to valid arguments

   142

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

   143

   144

   145

def _StringValue(x):

   146

    return x

   147

   148

   149

def _BoolValue(x):

   150

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

   151

   152

   153

def _translate_args(translations, args):

   154

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

   155

            for translate, arg in

   156

            zip(translations, args)]

   157

   158

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

   159

#                 Helpers object for generating pou var list

   160

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

   161

   162

   163

class _VariableInfos(object):

   164

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

   165

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

   166

   167

    def __init__(self, *args):

   168

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

   169

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

   170

   171

    def copy(self):

   172

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

   173

   174

   175

class VariablesInfosFactory(object):

   176

   177

    def __init__(self, variables):

   178

        self.Variables = variables

   179

        self.TreeStack = []

   180

        self.Type = None

   181

        self.Dimensions = None

   182

   183

    def SetType(self, context, *args):

   184

        self.Type = args[0][0]

   185

   186

    def GetType(self):

   187

        if len(self.Dimensions) > 0:

   188

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

   189

        return self.Type

   190

   191

    def GetTree(self):

   192

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

   193

   194

    def AddDimension(self, context, *args):

   195

        self.Dimensions.append(tuple(

   196

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

   197

   198

    def AddTree(self, context, *args):

   199

        self.TreeStack.append([])

   200

        self.Dimensions = []

   201

   202

    def AddVarToTree(self, context, *args):

   203

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

   204

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

   205

   206

    def AddVariable(self, context, *args):

   207

        self.Variables.append(_VariableInfos(*(

   208

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

   209

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

   210

   211

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

   212

#            Helpers object for generating pou variable instance list

   213

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

   214

   215

   216

def class_extraction(value):

   217

    class_type = {

   218

        "configuration": ITEM_CONFIGURATION,

   219

        "resource": ITEM_RESOURCE,

   220

        "action": ITEM_ACTION,

   221

        "transition": ITEM_TRANSITION,

   222

        "program": ITEM_PROGRAM}.get(value)

   223

    if class_type is not None:

   224

        return class_type

   225

   226

    pou_type = POU_TYPES.get(value)

   227

    if pou_type is not None:

   228

        return pou_type

   229

   230

    var_type = VAR_CLASS_INFOS.get(value)

   231

    if var_type is not None:

   232

        return var_type[1]

   233

   234

    return None

   235

   236

   237

class _VariablesTreeItemInfos(object):

   238

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

   239

   240

    def __init__(self, *args):

   241

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

   242

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

   243

   244

    def copy(self):

   245

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

   246

   247

   248

class VariablesTreeInfosFactory(object):

   249

   250

    def __init__(self):

   251

        self.Root = None

   252

   253

    def GetRoot(self):

   254

        return self.Root

   255

   256

    def SetRoot(self, context, *args):

   257

        self.Root = _VariablesTreeItemInfos(

   258

            *([''] + _translate_args(

   259

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

   260

                args) + [[]]))

   261

   262

    def AddVariable(self, context, *args):

   263

        if self.Root is not None:

   264

            self.Root.variables.append(_VariablesTreeItemInfos(

   265

                *(_translate_args(

   266

                    [_StringValue, class_extraction, _StringValue] +

   267

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

   268

   269

   270

class InstancesPathFactory(object):

   271

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

   272

    def __init__(self, instances):

   273

        self.Instances = instances

   274

   275

    def AddInstance(self, context, *args):

   276

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

   277

   278

   279

class InstanceTagName(object):

   280

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

   281

   282

    def __init__(self, controller):

   283

        self.Controller = controller

   284

        self.TagName = None

   285

   286

    def GetTagName(self):

   287

        return self.TagName

   288

   289

    def ConfigTagName(self, context, *args):

   290

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

   291

   292

    def ResourceTagName(self, context, *args):

   293

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

   294

   295

    def PouTagName(self, context, *args):

   296

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

   297

   298

    def ActionTagName(self, context, *args):

   299

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

   300

   301

    def TransitionTagName(self, context, *args):

   302

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

   303

   304

   305

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

   306

#           Helpers object for generating pou block instances list

   307

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

   308

   309

   310

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

   311

   312

_BlockInstanceInfos = namedtuple(

   313

    "BlockInstanceInfos",

   314

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

   315

   316

_BlockSpecificValues = (

   317

    namedtuple("BlockSpecificValues",

   318

               ["name", "execution_order"]),

   319

    [_StringValue, int])

   320

_VariableSpecificValues = (

   321

    namedtuple("VariableSpecificValues",

   322

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

   323

    [_StringValue, _StringValue, int])

   324

_ConnectionSpecificValues = (

   325

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

   326

    [_StringValue])

   327

   328

_PowerRailSpecificValues = (

   329

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

   330

    [int])

   331

   332

_LDElementSpecificValues = (

   333

    namedtuple("LDElementSpecificValues",

   334

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

   335

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

   336

   337

_DivergenceSpecificValues = (

   338

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

   339

    [int])

   340

   341

_SpecificValuesTuples = {

   342

    "comment": (

   343

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

   344

        [_StringValue]),

   345

    "input": _VariableSpecificValues,

   346

    "output": _VariableSpecificValues,

   347

    "inout": _VariableSpecificValues,

   348

    "connector": _ConnectionSpecificValues,

   349

    "continuation": _ConnectionSpecificValues,

   350

    "leftPowerRail": _PowerRailSpecificValues,

   351

    "rightPowerRail": _PowerRailSpecificValues,

   352

    "contact": _LDElementSpecificValues,

   353

    "coil": _LDElementSpecificValues,

   354

    "step": (

   355

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

   356

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

   357

    "transition": (

   358

        namedtuple("TransitionSpecificValues",

   359

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

   360

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

   361

    "selectionDivergence": _DivergenceSpecificValues,

   362

    "selectionConvergence": _DivergenceSpecificValues,

   363

    "simultaneousDivergence": _DivergenceSpecificValues,

   364

    "simultaneousConvergence": _DivergenceSpecificValues,

   365

    "jump": (

   366

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

   367

        [_StringValue]),

   368

    "actionBlock": (

   369

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

   370

        [lambda x: x]),

   371

}

   372

   373

_InstanceConnectionInfos = namedtuple(

   374

    "InstanceConnectionInfos",

   375

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

   376

   377

_ConnectionLinkInfos = namedtuple(

   378

    "ConnectionLinkInfos",

   379

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

   380

   381

   382

class _ActionInfos(object):

   383

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

   384

   385

    def __init__(self, *args):

   386

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

   387

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

   388

   389

    def copy(self):

   390

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

   391

   392

   393

class BlockInstanceFactory(object):

   394

   395

    def __init__(self, block_instances):

   396

        self.BlockInstances = block_instances

   397

        self.CurrentInstance = None

   398

        self.SpecificValues = None

   399

        self.CurrentConnection = None

   400

        self.CurrentLink = None

   401

   402

    def SetSpecificValues(self, context, *args):

   403

        self.SpecificValues = list(args)

   404

        self.CurrentInstance = None

   405

        self.CurrentConnection = None

   406

        self.CurrentLink = None

   407

   408

    def AddBlockInstance(self, context, *args):

   409

        specific_values_tuple, specific_values_translation = \

   410

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

   411

   412

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

   413

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

   414

            self.SpecificValues.append([None])

   415

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

   416

            self.SpecificValues.append([[]])

   417

        specific_values = specific_values_tuple(*_translate_args(

   418

            specific_values_translation, self.SpecificValues))

   419

        self.SpecificValues = None

   420

   421

        self.CurrentInstance = _BlockInstanceInfos(

   422

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

   423

              [specific_values, [], []]))

   424

   425

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

   426

   427

    def AddInstanceConnection(self, context, *args):

   428

        connection_args = _translate_args(

   429

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

   430

   431

        self.CurrentConnection = _InstanceConnectionInfos(

   432

            *(connection_args[1:4] + [

   433

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

   434

   435

        if self.CurrentInstance is not None:

   436

            if connection_args[0] == "input":

   437

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

   438

            else:

   439

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

   440

        else:

   441

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

   442

   443

    def AddConnectionLink(self, context, *args):

   444

        self.CurrentLink = _ConnectionLinkInfos(

   445

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

   446

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

   447

   448

    def AddLinkPoint(self, context, *args):

   449

        self.CurrentLink.points.append(_Point(

   450

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

   451

   452

    def AddAction(self, context, *args):

   453

        if len(self.SpecificValues) == 0:

   454

            self.SpecificValues.append([[]])

   455

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

   456

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

   457

   458

   459

pou_block_instances_xslt = etree.parse(

   460

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

   461

   462

   463

# Length of the buffer

   464

UNDO_BUFFER_LENGTH = 20

   465

   466

   467

class UndoBuffer(object):

   468

    """

   469

    Undo Buffer for PLCOpenEditor

   470

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

   471

    """

   472

   473

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

   474

        """

   475

        Constructor initialising buffer

   476

        """

   477

        self.Buffer = []

   478

        self.CurrentIndex = -1

   479

        self.MinIndex = -1

   480

        self.MaxIndex = -1

   481

        # if current state is defined

   482

        if currentstate:

   483

            self.CurrentIndex = 0

   484

            self.MinIndex = 0