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 InstancesPathCollector(XSLTModelQuery):

   272

    """ object for collecting instances path list"""

   273

    def __init__(self, controller):

   274

        self.Instances = []

   275

        XSLTModelQuery.__init__(self,

   276

                                controller,

   277

                                "instances_path.xslt",

   278

                                [("AddInstance", self.AddInstance)])

   279

   280

    def AddInstance(self, context, *args):

   281

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

   282

   283

    def Collect(self, root, name, debug):

   284

        self._process_xslt(root, debug, instance_type = name)

   285

        res = self.Instances

   286

        self.Instances = []

   287

        return res

   288

   289

class InstanceTagName(object):

   290

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

   291

   292

    def __init__(self, controller):

   293

        self.Controller = controller

   294

        self.TagName = None

   295

   296

    def GetTagName(self):

   297

        return self.TagName

   298

   299

    def ConfigTagName(self, context, *args):

   300

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

   301

   302

    def ResourceTagName(self, context, *args):

   303

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

   304

   305

    def PouTagName(self, context, *args):

   306

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

   307

   308

    def ActionTagName(self, context, *args):

   309

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

   310

   311

    def TransitionTagName(self, context, *args):

   312

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

   313

   314

   315

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

   316

#           Helpers object for generating pou block instances list

   317

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

   318

   319

   320

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

   321

   322

_BlockInstanceInfos = namedtuple(

   323

    "BlockInstanceInfos",

   324

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

   325

   326

_BlockSpecificValues = (

   327

    namedtuple("BlockSpecificValues",

   328

               ["name", "execution_order"]),

   329

    [_StringValue, int])

   330

_VariableSpecificValues = (

   331

    namedtuple("VariableSpecificValues",

   332

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

   333

    [_StringValue, _StringValue, int])

   334

_ConnectionSpecificValues = (

   335

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

   336

    [_StringValue])

   337

   338

_PowerRailSpecificValues = (

   339

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

   340

    [int])

   341

   342

_LDElementSpecificValues = (

   343

    namedtuple("LDElementSpecificValues",

   344

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

   345

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

   346

   347

_DivergenceSpecificValues = (

   348

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

   349

    [int])

   350

   351

_SpecificValuesTuples = {

   352

    "comment": (

   353

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

   354

        [_StringValue]),

   355

    "input": _VariableSpecificValues,

   356

    "output": _VariableSpecificValues,

   357

    "inout": _VariableSpecificValues,

   358

    "connector": _ConnectionSpecificValues,

   359

    "continuation": _ConnectionSpecificValues,

   360

    "leftPowerRail": _PowerRailSpecificValues,

   361

    "rightPowerRail": _PowerRailSpecificValues,

   362

    "contact": _LDElementSpecificValues,

   363

    "coil": _LDElementSpecificValues,

   364

    "step": (

   365

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

   366

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

   367

    "transition": (

   368

        namedtuple("TransitionSpecificValues",

   369

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

   370

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

   371

    "selectionDivergence": _DivergenceSpecificValues,

   372

    "selectionConvergence": _DivergenceSpecificValues,

   373

    "simultaneousDivergence": _DivergenceSpecificValues,

   374

    "simultaneousConvergence": _DivergenceSpecificValues,

   375

    "jump": (

   376

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

   377

        [_StringValue]),

   378

    "actionBlock": (

   379

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

   380

        [lambda x: x]),

   381

}

   382

   383

_InstanceConnectionInfos = namedtuple(

   384

    "InstanceConnectionInfos",

   385

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

   386

   387

_ConnectionLinkInfos = namedtuple(

   388

    "ConnectionLinkInfos",

   389

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

   390

   391

   392

class _ActionInfos(object):

   393

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

   394

   395

    def __init__(self, *args):

   396

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

   397

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

   398

   399

    def copy(self):

   400

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

   401

   402

   403

class BlockInstanceFactory(object):

   404

   405

    def __init__(self, block_instances):

   406

        self.BlockInstances = block_instances

   407

        self.CurrentInstance = None

   408

        self.SpecificValues = None

   409

        self.CurrentConnection = None

   410

        self.CurrentLink = None

   411

   412

    def SetSpecificValues(self, context, *args):

   413

        self.SpecificValues = list(args)

   414

        self.CurrentInstance = None

   415

        self.CurrentConnection = None

   416

        self.CurrentLink = None

   417

   418

    def AddBlockInstance(self, context, *args):

   419

        specific_values_tuple, specific_values_translation = \

   420

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

   421

   422

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

   423

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

   424

            self.SpecificValues.append([None])

   425

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

   426

            self.SpecificValues.append([[]])

   427

        specific_values = specific_values_tuple(*_translate_args(

   428

            specific_values_translation, self.SpecificValues))

   429

        self.SpecificValues = None

   430

   431

        self.CurrentInstance = _BlockInstanceInfos(

   432

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

   433

              [specific_values, [], []]))

   434

   435

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

   436

   437

    def AddInstanceConnection(self, context, *args):

   438

        connection_args = _translate_args(

   439

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

   440

   441

        self.CurrentConnection = _InstanceConnectionInfos(

   442

            *(connection_args[1:4] + [

   443

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

   444

   445

        if self.CurrentInstance is not None:

   446

            if connection_args[0] == "input":

   447

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

   448

            else:

   449

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

   450

        else:

   451

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

   452

   453

    def AddConnectionLink(self, context, *args):

   454

        self.CurrentLink = _ConnectionLinkInfos(

   455

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

   456

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

   457

   458

    def AddLinkPoint(self, context, *args):

   459

        self.CurrentLink.points.append(_Point(

   460

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

   461

   462

    def AddAction(self, context, *args):

   463

        if len(self.SpecificValues) == 0:

   464

            self.SpecificValues.append([[]])

   465

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

   466

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

   467

   468

   469

pou_block_instances_xslt = etree.parse(

   470

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

   471

   472

   473

# Length of the buffer

   474

UNDO_BUFFER_LENGTH = 20

   475

   476

   477

class UndoBuffer(object):

   478

    """

   479

    Undo Buffer for PLCOpenEditor

   480

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

   481

    """

   482

   483

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