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 lxml import etree

    29

from copy import deepcopy

    30

import os

    31

import sys

    32

import re

    33

import datetime

    34

import util.paths as paths

    35

from time import localtime

    36

from collections import OrderedDict, namedtuple

    37

from util.TranslationCatalogs import NoTranslate

    38

from plcopen import *

    39

from graphics.GraphicCommons import *

    40

from PLCGenerator import *

    41

    42

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

    43

    44

ITEMS_EDITABLE = [

    45

    ITEM_PROJECT,

    46

    ITEM_POU,

    47

    ITEM_VARIABLE,

    48

    ITEM_TRANSITION,

    49

    ITEM_ACTION,

    50

    ITEM_CONFIGURATION,

    51

    ITEM_RESOURCE,

    52

    ITEM_DATATYPE

    53

] = range(8)

    54

    55

ITEMS_UNEDITABLE = [

    56

    ITEM_DATATYPES,

    57

    ITEM_FUNCTION,

    58

    ITEM_FUNCTIONBLOCK,

    59

    ITEM_PROGRAM,

    60

    ITEM_TRANSITIONS,

    61

    ITEM_ACTIONS,

    62

    ITEM_CONFIGURATIONS,

    63

    ITEM_RESOURCES,

    64

    ITEM_PROPERTIES

    65

] = range(8, 17)

    66

    67

ITEMS_VARIABLE = [

    68

    ITEM_VAR_LOCAL,

    69

    ITEM_VAR_GLOBAL,

    70

    ITEM_VAR_EXTERNAL,

    71

    ITEM_VAR_TEMP,

    72

    ITEM_VAR_INPUT,

    73

    ITEM_VAR_OUTPUT,

    74

    ITEM_VAR_INOUT

    75

] = range(17, 24)

    76

    77

VAR_CLASS_INFOS = {

    78

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

    79

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

    80

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

    81

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

    82

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

    83

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

    84

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

    85

    86

POU_TYPES = {

    87

    "program": ITEM_PROGRAM,

    88

    "functionBlock": ITEM_FUNCTIONBLOCK,

    89

    "function": ITEM_FUNCTION,

    90

}

    91

    92

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    93

                   LOCATION_MODULE,

    94

                   LOCATION_GROUP,

    95

                   LOCATION_VAR_INPUT,

    96

                   LOCATION_VAR_OUTPUT,

    97

                   LOCATION_VAR_MEMORY] = range(6)

    98

    99

ScriptDirectory = paths.AbsDir(__file__)

   100

   101

   102

def GetUneditableNames():

   103

    _ = NoTranslate

   104

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

   105

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

   106

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

   107

   108

   109

UNEDITABLE_NAMES = GetUneditableNames()

   110

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,

   111

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

   112

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   113

   114

   115

class LibraryResolver(etree.Resolver):

   116

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

   117

   118

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

   119

        self.Controller = controller

   120

        self.Debug = debug

   121

   122

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

   123

        lib_name = os.path.basename(url)

   124

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

   125

            lib_el = etree.Element(lib_name)

   126

            if lib_name == "project":

   127

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

   128

            elif lib_name == "stdlib":

   129

                for lib in StdBlckLibs.values():

   130

                    lib_el.append(deepcopy(lib))

   131

            else:

   132

                for ctn in self.Controller.ConfNodeTypes:

   133

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

   134

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

   135

   136

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

   137

#           Helpers functions for translating list of arguments

   138

#                       from xslt to valid arguments

   139

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

   140

   141

   142

def _StringValue(x):

   143

    return x

   144

   145

   146

def _BoolValue(x):

   147

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

   148

   149

   150

def _translate_args(translations, args):

   151

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

   152

            for translate, arg in

   153

            zip(translations, args)]

   154

   155

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

   156

#                 Helpers object for generating pou var list

   157

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

   158

   159

   160

class _VariableInfos(object):

   161

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

   162

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

   163

   164

    def __init__(self, *args):

   165

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

   166

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

   167

   168

    def copy(self):

   169

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

   170

   171

   172

class VariablesInfosFactory:

   173

   174

    def __init__(self, variables):

   175

        self.Variables = variables

   176

        self.TreeStack = []

   177

        self.Type = None

   178

        self.Dimensions = None

   179

   180

    def SetType(self, context, *args):

   181

        self.Type = args[0][0]

   182

   183

    def GetType(self):

   184

        if len(self.Dimensions) > 0:

   185

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

   186

        return self.Type

   187

   188

    def GetTree(self):

   189

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

   190

   191

    def AddDimension(self, context, *args):

   192

        self.Dimensions.append(tuple(

   193

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

   194

   195

    def AddTree(self, context, *args):

   196

        self.TreeStack.append([])

   197

        self.Dimensions = []

   198

   199

    def AddVarToTree(self, context, *args):

   200

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

   201

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

   202

   203

    def AddVariable(self, context, *args):

   204

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

   205

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

   206

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

   207

   208

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

   209

#            Helpers object for generating pou variable instance list

   210

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

   211

   212

   213

def class_extraction(value):

   214

    class_type = {

   215

        "configuration": ITEM_CONFIGURATION,

   216

        "resource": ITEM_RESOURCE,

   217

        "action": ITEM_ACTION,

   218

        "transition": ITEM_TRANSITION,

   219

        "program": ITEM_PROGRAM}.get(value)

   220

    if class_type is not None:

   221

        return class_type

   222

   223

    pou_type = POU_TYPES.get(value)

   224

    if pou_type is not None:

   225

        return pou_type

   226

   227

    var_type = VAR_CLASS_INFOS.get(value)

   228

    if var_type is not None:

   229

        return var_type[1]

   230

   231

    return None

   232

   233

   234

class _VariablesTreeItemInfos(object):

   235

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

   236

   237

    def __init__(self, *args):

   238

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

   239

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

   240

   241

    def copy(self):

   242

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

   243

   244

   245

class VariablesTreeInfosFactory:

   246

   247

    def __init__(self):

   248

        self.Root = None

   249

   250

    def GetRoot(self):

   251

        return self.Root

   252

   253

    def SetRoot(self, context, *args):

   254

        self.Root = _VariablesTreeItemInfos(

   255

            *([''] + _translate_args(

   256

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

   257

                args) + [[]]))

   258

   259

    def AddVariable(self, context, *args):

   260

        if self.Root is not None:

   261

            self.Root.variables.append(_VariablesTreeItemInfos(

   262

                *(_translate_args(

   263

                    [_StringValue, class_extraction, _StringValue] +

   264

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

   265

   266

   267

class InstancesPathFactory:

   268

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

   269

    def __init__(self, instances):

   270

        self.Instances = instances

   271

   272

    def AddInstance(self, context, *args):

   273

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

   274

   275

   276

class InstanceTagName:

   277

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

   278

   279

    def __init__(self, controller):

   280

        self.Controller = controller

   281

        self.TagName = None

   282

   283

    def GetTagName(self):

   284

        return self.TagName

   285

   286

    def ConfigTagName(self, context, *args):

   287

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

   288

   289

    def ResourceTagName(self, context, *args):

   290

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

   291

   292

    def PouTagName(self, context, *args):

   293

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

   294

   295

    def ActionTagName(self, context, *args):

   296

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

   297

   298

    def TransitionTagName(self, context, *args):

   299

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

   300

   301

   302

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

   303

#           Helpers object for generating pou block instances list

   304

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

   305

   306

   307

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

   308

   309

_BlockInstanceInfos = namedtuple(

   310

    "BlockInstanceInfos",

   311

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

   312

   313

_BlockSpecificValues = (

   314

    namedtuple("BlockSpecificValues",

   315

               ["name", "execution_order"]),

   316

    [_StringValue, int])

   317

_VariableSpecificValues = (

   318

    namedtuple("VariableSpecificValues",

   319

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

   320

    [_StringValue, _StringValue, int])

   321

_ConnectionSpecificValues = (

   322

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

   323

    [_StringValue])

   324

   325

_PowerRailSpecificValues = (

   326

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

   327

    [int])

   328

   329

_LDElementSpecificValues = (

   330

    namedtuple("LDElementSpecificValues",

   331

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

   332

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

   333

   334

_DivergenceSpecificValues = (

   335

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

   336

    [int])

   337

   338

_SpecificValuesTuples = {

   339

    "comment": (

   340

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

   341

        [_StringValue]),

   342

    "input": _VariableSpecificValues,

   343

    "output": _VariableSpecificValues,

   344

    "inout": _VariableSpecificValues,

   345

    "connector": _ConnectionSpecificValues,

   346

    "continuation": _ConnectionSpecificValues,

   347

    "leftPowerRail": _PowerRailSpecificValues,

   348

    "rightPowerRail": _PowerRailSpecificValues,

   349

    "contact": _LDElementSpecificValues,

   350

    "coil": _LDElementSpecificValues,

   351

    "step": (

   352

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

   353

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

   354

    "transition": (

   355

        namedtuple("TransitionSpecificValues",

   356

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

   357

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

   358

    "selectionDivergence": _DivergenceSpecificValues,

   359

    "selectionConvergence": _DivergenceSpecificValues,

   360

    "simultaneousDivergence": _DivergenceSpecificValues,

   361

    "simultaneousConvergence": _DivergenceSpecificValues,

   362

    "jump": (

   363

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

   364

        [_StringValue]),

   365

    "actionBlock": (

   366

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

   367

        [lambda x: x]),

   368

}

   369

   370

_InstanceConnectionInfos = namedtuple(

   371

    "InstanceConnectionInfos",

   372

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

   373

   374

_ConnectionLinkInfos = namedtuple(

   375

    "ConnectionLinkInfos",

   376

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

   377

   378

   379

class _ActionInfos(object):

   380

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

   381

   382

    def __init__(self, *args):

   383

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

   384

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

   385

   386

    def copy(self):

   387

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

   388

   389

   390

class BlockInstanceFactory:

   391

   392

    def __init__(self, block_instances):

   393

        self.BlockInstances = block_instances

   394

        self.CurrentInstance = None

   395

        self.SpecificValues = None

   396

        self.CurrentConnection = None

   397

        self.CurrentLink = None

   398

   399

    def SetSpecificValues(self, context, *args):

   400

        self.SpecificValues = list(args)

   401

        self.CurrentInstance = None

   402

        self.CurrentConnection = None

   403

        self.CurrentLink = None

   404

   405

    def AddBlockInstance(self, context, *args):

   406

        specific_values_tuple, specific_values_translation = \

   407

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

   408

   409

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

   410

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

   411

            self.SpecificValues.append([None])

   412

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

   413

            self.SpecificValues.append([[]])

   414

        specific_values = specific_values_tuple(*_translate_args(

   415

            specific_values_translation, self.SpecificValues))

   416

        self.SpecificValues = None

   417

   418

        self.CurrentInstance = _BlockInstanceInfos(

   419

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

   420

              [specific_values, [], []]))

   421

   422

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

   423

   424

    def AddInstanceConnection(self, context, *args):

   425

        connection_args = _translate_args(

   426

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

   427

   428

        self.CurrentConnection = _InstanceConnectionInfos(

   429

            *(connection_args[1:4] + [

   430

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

   431

   432

        if self.CurrentInstance is not None:

   433

            if connection_args[0] == "input":

   434

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

   435

            else:

   436

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

   437

        else:

   438

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

   439

   440

    def AddConnectionLink(self, context, *args):

   441

        self.CurrentLink = _ConnectionLinkInfos(

   442

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

   443

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

   444

   445

    def AddLinkPoint(self, context, *args):

   446

        self.CurrentLink.points.append(_Point(

   447

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

   448

   449

    def AddAction(self, context, *args):

   450

        if len(self.SpecificValues) == 0:

   451

            self.SpecificValues.append([[]])

   452

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

   453

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

   454

   455

   456

pou_block_instances_xslt = etree.parse(

   457

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

   458

   459

   460

# Length of the buffer

   461

UNDO_BUFFER_LENGTH = 20

   462

   463

   464

class UndoBuffer:

   465

    """

   466

    Undo Buffer for PLCOpenEditor

   467

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

   468

    """

   469

   470

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

   471

        """

   472

        Constructor initialising buffer

   473

        """

   474

        self.Buffer = []

   475

        self.CurrentIndex = -1

   476

        self.MinIndex = -1

   477

        self.MaxIndex = -1

   478

        # if current state is defined

   479

        if currentstate:

   480

            self.CurrentIndex = 0

   481

            self.MinIndex = 0

   482

            self.MaxIndex = 0

   483

        # Initialising buffer with currentstate at the first place

   484

        for i in xrange(UNDO_BUFFER_LENGTH):

   485