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 copy import deepcopy

    29

import os

    30

import sys

    31

import re

    32

import datetime

    33

from time import localtime

    34

from collections import OrderedDict, namedtuple

    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

    46

ITEMS_EDITABLE = [

    47

    ITEM_PROJECT,

    48

    ITEM_POU,

    49

    ITEM_VARIABLE,

    50

    ITEM_TRANSITION,

    51

    ITEM_ACTION,

    52

    ITEM_CONFIGURATION,

    53

    ITEM_RESOURCE,

    54

    ITEM_DATATYPE

    55

] = range(8)

    56

    57

ITEMS_UNEDITABLE = [

    58

    ITEM_DATATYPES,

    59

    ITEM_FUNCTION,

    60

    ITEM_FUNCTIONBLOCK,

    61

    ITEM_PROGRAM,

    62

    ITEM_TRANSITIONS,

    63

    ITEM_ACTIONS,

    64

    ITEM_CONFIGURATIONS,

    65

    ITEM_RESOURCES,

    66

    ITEM_PROPERTIES

    67

] = range(8, 17)

    68

    69

ITEMS_VARIABLE = [

    70

    ITEM_VAR_LOCAL,

    71

    ITEM_VAR_GLOBAL,

    72

    ITEM_VAR_EXTERNAL,

    73

    ITEM_VAR_TEMP,

    74

    ITEM_VAR_INPUT,

    75

    ITEM_VAR_OUTPUT,

    76

    ITEM_VAR_INOUT

    77

] = range(17, 24)

    78

    79

VAR_CLASS_INFOS = {

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

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

    87

    88

POU_TYPES = {

    89

    "program": ITEM_PROGRAM,

    90

    "functionBlock": ITEM_FUNCTIONBLOCK,

    91

    "function": ITEM_FUNCTION,

    92

}

    93

    94

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    95

                   LOCATION_MODULE,

    96

                   LOCATION_GROUP,

    97

                   LOCATION_VAR_INPUT,

    98

                   LOCATION_VAR_OUTPUT,

    99

                   LOCATION_VAR_MEMORY] = range(6)

   100

   101

ScriptDirectory = paths.AbsDir(__file__)

   102

   103

   104

def GetUneditableNames():

   105

    _ = NoTranslate

   106

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

   107

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

   108

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

   109

   110

   111

UNEDITABLE_NAMES = GetUneditableNames()

   112

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,

   113

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

   114

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   115

   116

   117

class LibraryResolver(etree.Resolver):

   118

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

   119

   120

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

   121

        self.Controller = controller

   122

        self.Debug = debug

   123

   124

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

   125

        lib_name = os.path.basename(url)

   126

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

   127

            lib_el = etree.Element(lib_name)

   128

            if lib_name == "project":

   129

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

   130

            elif lib_name == "stdlib":

   131

                for lib in StdBlckLibs.values():

   132

                    lib_el.append(deepcopy(lib))

   133

            else:

   134

                for ctn in self.Controller.ConfNodeTypes:

   135

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

   136

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

   137

   138

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

   139

#           Helpers functions for translating list of arguments

   140

#                       from xslt to valid arguments

   141

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

   142

   143

   144

def _StringValue(x):

   145

    return x

   146

   147

   148

def _BoolValue(x):

   149

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

   150

   151

   152

def _translate_args(translations, args):

   153

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

   154

            for translate, arg in

   155

            zip(translations, args)]

   156

   157

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

   158

#                 Helpers object for generating pou var list

   159

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

   160

   161

   162

class _VariableInfos(object):

   163

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

   164

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

   165

   166

    def __init__(self, *args):

   167

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

   168

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

   169

   170

    def copy(self):

   171

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

   172

   173

   174

class VariablesInfosFactory(object):

   175

   176

    def __init__(self, variables):

   177

        self.Variables = variables

   178

        self.TreeStack = []

   179

        self.Type = None

   180

        self.Dimensions = None

   181

   182

    def SetType(self, context, *args):

   183

        self.Type = args[0][0]

   184

   185

    def GetType(self):

   186

        if len(self.Dimensions) > 0:

   187

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

   188

        return self.Type

   189

   190

    def GetTree(self):

   191

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

   192

   193

    def AddDimension(self, context, *args):

   194

        self.Dimensions.append(tuple(

   195

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

   196

   197

    def AddTree(self, context, *args):

   198

        self.TreeStack.append([])

   199

        self.Dimensions = []

   200

   201

    def AddVarToTree(self, context, *args):

   202

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

   203

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

   204

   205

    def AddVariable(self, context, *args):

   206

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

   207

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

   208

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

   209

   210

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

   211

#            Helpers object for generating pou variable instance list

   212

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

   213

   214

   215

def class_extraction(value):

   216

    class_type = {

   217

        "configuration": ITEM_CONFIGURATION,

   218

        "resource": ITEM_RESOURCE,

   219

        "action": ITEM_ACTION,

   220

        "transition": ITEM_TRANSITION,

   221

        "program": ITEM_PROGRAM}.get(value)

   222

    if class_type is not None:

   223

        return class_type

   224

   225

    pou_type = POU_TYPES.get(value)

   226

    if pou_type is not None:

   227

        return pou_type

   228

   229

    var_type = VAR_CLASS_INFOS.get(value)

   230

    if var_type is not None:

   231

        return var_type[1]

   232

   233

    return None

   234

   235

   236

class _VariablesTreeItemInfos(object):

   237

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

   238

   239

    def __init__(self, *args):

   240

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

   241

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

   242

   243

    def copy(self):

   244

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

   245

   246

   247

class VariablesTreeInfosFactory(object):

   248

   249

    def __init__(self):

   250

        self.Root = None

   251

   252

    def GetRoot(self):

   253

        return self.Root

   254

   255

    def SetRoot(self, context, *args):

   256

        self.Root = _VariablesTreeItemInfos(

   257

            *([''] + _translate_args(

   258

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

   259

                args) + [[]]))

   260

   261

    def AddVariable(self, context, *args):

   262

        if self.Root is not None:

   263

            self.Root.variables.append(_VariablesTreeItemInfos(

   264

                *(_translate_args(

   265

                    [_StringValue, class_extraction, _StringValue] +

   266

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

   267

   268

   269

class InstancesPathFactory(object):

   270

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

   271

    def __init__(self, instances):

   272

        self.Instances = instances

   273

   274

    def AddInstance(self, context, *args):

   275

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

   276

   277

   278

class InstanceTagName(object):

   279

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

   280

   281

    def __init__(self, controller):

   282

        self.Controller = controller

   283

        self.TagName = None

   284

   285

    def GetTagName(self):

   286

        return self.TagName

   287

   288

    def ConfigTagName(self, context, *args):

   289

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

   290

   291

    def ResourceTagName(self, context, *args):

   292

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

   293

   294

    def PouTagName(self, context, *args):

   295

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

   296

   297

    def ActionTagName(self, context, *args):

   298

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

   299

   300

    def TransitionTagName(self, context, *args):

   301

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

   302

   303

   304

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

   305

#           Helpers object for generating pou block instances list

   306

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

   307

   308

   309

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

   310

   311

_BlockInstanceInfos = namedtuple(

   312

    "BlockInstanceInfos",

   313

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

   314

   315

_BlockSpecificValues = (

   316

    namedtuple("BlockSpecificValues",

   317

               ["name", "execution_order"]),

   318

    [_StringValue, int])

   319

_VariableSpecificValues = (

   320

    namedtuple("VariableSpecificValues",

   321

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

   322

    [_StringValue, _StringValue, int])

   323

_ConnectionSpecificValues = (

   324

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

   325

    [_StringValue])

   326

   327

_PowerRailSpecificValues = (

   328

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

   329

    [int])

   330

   331

_LDElementSpecificValues = (

   332

    namedtuple("LDElementSpecificValues",

   333

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

   334

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

   335

   336

_DivergenceSpecificValues = (

   337

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

   338

    [int])

   339

   340

_SpecificValuesTuples = {

   341

    "comment": (

   342

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

   343

        [_StringValue]),

   344

    "input": _VariableSpecificValues,

   345

    "output": _VariableSpecificValues,

   346

    "inout": _VariableSpecificValues,

   347

    "connector": _ConnectionSpecificValues,

   348

    "continuation": _ConnectionSpecificValues,

   349

    "leftPowerRail": _PowerRailSpecificValues,

   350

    "rightPowerRail": _PowerRailSpecificValues,

   351

    "contact": _LDElementSpecificValues,

   352

    "coil": _LDElementSpecificValues,

   353

    "step": (

   354

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

   355

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

   356

    "transition": (

   357

        namedtuple("TransitionSpecificValues",

   358

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

   359

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

   360

    "selectionDivergence": _DivergenceSpecificValues,

   361

    "selectionConvergence": _DivergenceSpecificValues,

   362

    "simultaneousDivergence": _DivergenceSpecificValues,

   363

    "simultaneousConvergence": _DivergenceSpecificValues,

   364

    "jump": (

   365

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

   366

        [_StringValue]),

   367

    "actionBlock": (

   368

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

   369

        [lambda x: x]),

   370

}

   371

   372

_InstanceConnectionInfos = namedtuple(

   373

    "InstanceConnectionInfos",

   374

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

   375

   376

_ConnectionLinkInfos = namedtuple(

   377

    "ConnectionLinkInfos",

   378

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

   379

   380

   381

class _ActionInfos(object):

   382

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

   383

   384

    def __init__(self, *args):

   385

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

   386

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

   387

   388

    def copy(self):

   389

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

   390

   391

   392

class BlockInstanceFactory(object):

   393

   394

    def __init__(self, block_instances):

   395

        self.BlockInstances = block_instances

   396

        self.CurrentInstance = None

   397

        self.SpecificValues = None

   398

        self.CurrentConnection = None

   399

        self.CurrentLink = None

   400

   401

    def SetSpecificValues(self, context, *args):

   402

        self.SpecificValues = list(args)

   403

        self.CurrentInstance = None

   404

        self.CurrentConnection = None

   405

        self.CurrentLink = None

   406

   407

    def AddBlockInstance(self, context, *args):

   408

        specific_values_tuple, specific_values_translation = \

   409

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

   410

   411

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

   412

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

   413

            self.SpecificValues.append([None])

   414

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

   415

            self.SpecificValues.append([[]])

   416

        specific_values = specific_values_tuple(*_translate_args(

   417

            specific_values_translation, self.SpecificValues))

   418

        self.SpecificValues = None

   419

   420

        self.CurrentInstance = _BlockInstanceInfos(

   421

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

   422

              [specific_values, [], []]))

   423

   424

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

   425

   426

    def AddInstanceConnection(self, context, *args):

   427

        connection_args = _translate_args(

   428

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

   429

   430

        self.CurrentConnection = _InstanceConnectionInfos(

   431

            *(connection_args[1:4] + [

   432

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

   433

   434

        if self.CurrentInstance is not None:

   435

            if connection_args[0] == "input":

   436

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

   437

            else:

   438

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

   439

        else:

   440

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

   441

   442

    def AddConnectionLink(self, context, *args):

   443

        self.CurrentLink = _ConnectionLinkInfos(

   444

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

   445

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

   446

   447

    def AddLinkPoint(self, context, *args):

   448

        self.CurrentLink.points.append(_Point(

   449

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

   450

   451

    def AddAction(self, context, *args):

   452

        if len(self.SpecificValues) == 0:

   453

            self.SpecificValues.append([[]])

   454

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

   455

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

   456

   457

   458

pou_block_instances_xslt = etree.parse(

   459

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

   460

   461

   462

# Length of the buffer

   463

UNDO_BUFFER_LENGTH = 20

   464

   465

   466

class UndoBuffer(object):

   467

    """

   468

    Undo Buffer for PLCOpenEditor

   469

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

   470

    """

   471

   472

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

   473

        """

   474

        Constructor initialising buffer

   475

        """

   476

        self.Buffer = []

   477

        self.CurrentIndex = -1

   478

        self.MinIndex = -1

   479

        self.MaxIndex = -1

   480

        # if current state is defined

   481

        if currentstate:

   482

            self.CurrentIndex = 0

   483

            self.MinIndex = 0

   484

            self.MaxIndex = 0

   485

        # Initialising buffer with currentstate at the first place