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

    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 = [ITEM_PROJECT,

    45

                  ITEM_POU,

    46

                  ITEM_VARIABLE,

    47

                  ITEM_TRANSITION,

    48

                  ITEM_ACTION,

    49

                  ITEM_CONFIGURATION,

    50

                  ITEM_RESOURCE,

    51

                  ITEM_DATATYPE

    52

                 ] = range(8)

    53

    54

ITEMS_UNEDITABLE = [ITEM_DATATYPES,

    55

                    ITEM_FUNCTION,

    56

                    ITEM_FUNCTIONBLOCK,

    57

                    ITEM_PROGRAM,

    58

                    ITEM_TRANSITIONS,

    59

                    ITEM_ACTIONS,

    60

                    ITEM_CONFIGURATIONS,

    61

                    ITEM_RESOURCES,

    62

                    ITEM_PROPERTIES

    63

                   ] = range(8, 17)

    64

    65

ITEMS_VARIABLE = [ITEM_VAR_LOCAL,

    66

                  ITEM_VAR_GLOBAL,

    67

                  ITEM_VAR_EXTERNAL,

    68

                  ITEM_VAR_TEMP,

    69

                  ITEM_VAR_INPUT,

    70

                  ITEM_VAR_OUTPUT,

    71

                  ITEM_VAR_INOUT

    72

                 ] = range(17, 24)

    73

    74

VAR_CLASS_INFOS = {

    75

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

    76

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

    77

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

    78

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

    79

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

    80

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

    81

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

    82

    83

POU_TYPES = {"program": ITEM_PROGRAM,

    84

             "functionBlock": ITEM_FUNCTIONBLOCK,

    85

             "function": ITEM_FUNCTION,

    86

            }

    87

    88

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    89

                   LOCATION_MODULE,

    90

                   LOCATION_GROUP,

    91

                   LOCATION_VAR_INPUT,

    92

                   LOCATION_VAR_OUTPUT,

    93

                   LOCATION_VAR_MEMORY] = range(6)

    94

    95

ScriptDirectory = paths.AbsDir(__file__)

    96

    97

def GetUneditableNames():

    98

    _ = lambda x:x

    99

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

   100

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

   101

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

   102

UNEDITABLE_NAMES = GetUneditableNames()

   103

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,

   104

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

   105

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   106

   107

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

   108

#                 Helper object for loading library in xslt stylesheets

   109

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

   110

   111

class LibraryResolver(etree.Resolver):

   112

   113

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

   114

        self.Controller = controller

   115

        self.Debug = debug

   116

   117

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

   118

        lib_name = os.path.basename(url)

   119

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

   120

            lib_el = etree.Element(lib_name)

   121

            if lib_name == "project":

   122

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

   123

            elif lib_name == "stdlib":

   124

                for lib in StdBlckLibs.values():

   125

                    lib_el.append(deepcopy(lib))

   126

            else:

   127

                for ctn in self.Controller.ConfNodeTypes:

   128

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

   129

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

   130

   131

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

   132

#           Helpers functions for translating list of arguments

   133

#                       from xslt to valid arguments

   134

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

   135

   136

_StringValue = lambda x: x

   137

_BoolValue = lambda x: x in ["true", "0"]

   138

   139

def _translate_args(translations, args):

   140

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

   141

            for translate, arg in

   142

            zip(translations, args)]

   143

   144

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

   145

#                 Helpers object for generating pou var list

   146

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

   147

   148

class _VariableInfos(object):

   149

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

   150

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

   151

    def __init__(self, *args):

   152

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

   153

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

   154

    def copy(self):

   155

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

   156

   157

class VariablesInfosFactory:

   158

   159

    def __init__(self, variables):

   160

        self.Variables = variables

   161

        self.TreeStack = []

   162

        self.Type = None

   163

        self.Dimensions = None

   164

   165

    def SetType(self, context, *args):

   166

        self.Type = args[0][0]

   167

   168

    def GetType(self):

   169

        if len(self.Dimensions) > 0:

   170

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

   171

        return self.Type

   172

   173

    def GetTree(self):

   174

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

   175

   176

    def AddDimension(self, context, *args):

   177

        self.Dimensions.append(tuple(

   178

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

   179

   180

    def AddTree(self, context, *args):

   181

        self.TreeStack.append([])

   182

        self.Dimensions = []

   183

   184

    def AddVarToTree(self, context, *args):

   185

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

   186

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

   187

   188

    def AddVariable(self, context, *args):

   189

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

   190

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

   191

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

   192

   193

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

   194

#            Helpers object for generating pou variable instance list

   195

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

   196

   197

def class_extraction(value):

   198

    class_type = {

   199

        "configuration": ITEM_CONFIGURATION,

   200

        "resource": ITEM_RESOURCE,

   201

        "action": ITEM_ACTION,

   202

        "transition": ITEM_TRANSITION,

   203

        "program": ITEM_PROGRAM}.get(value)

   204

    if class_type is not None:

   205

        return class_type

   206

   207

    pou_type = POU_TYPES.get(value)

   208

    if pou_type is not None:

   209

        return pou_type

   210

   211

    var_type = VAR_CLASS_INFOS.get(value)

   212

    if var_type is not None:

   213

        return var_type[1]

   214

   215

    return None

   216

   217

class _VariablesTreeItemInfos(object):

   218

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

   219

    def __init__(self, *args):

   220

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

   221

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

   222

    def copy(self):

   223

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

   224

   225

class VariablesTreeInfosFactory:

   226

   227

    def __init__(self):

   228

        self.Root = None

   229

   230

    def GetRoot(self):

   231

        return self.Root

   232

   233

    def SetRoot(self, context, *args):

   234

        self.Root = _VariablesTreeItemInfos(

   235

            *([''] + _translate_args(

   236

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

   237

                args) + [[]]))

   238

   239

    def AddVariable(self, context, *args):

   240

        if self.Root is not None:

   241

            self.Root.variables.append(_VariablesTreeItemInfos(

   242

                *(_translate_args(

   243

                    [_StringValue, class_extraction, _StringValue] +

   244

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

   245

   246

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

   247

#            Helpers object for generating instances path list

   248

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

   249

   250

class InstancesPathFactory:

   251

   252

    def __init__(self, instances):

   253

        self.Instances = instances

   254

   255

    def AddInstance(self, context, *args):

   256

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

   257

   258

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

   259

#            Helpers object for generating instance tagname

   260

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

   261

   262

class InstanceTagName:

   263

   264

    def __init__(self, controller):

   265

        self.Controller = controller

   266

        self.TagName = None

   267

   268

    def GetTagName(self):

   269

        return self.TagName

   270

   271

    def ConfigTagName(self, context, *args):

   272

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

   273

   274

    def ResourceTagName(self, context, *args):

   275

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

   276

   277

    def PouTagName(self, context, *args):

   278

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

   279

   280

    def ActionTagName(self, context, *args):

   281

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

   282

   283

    def TransitionTagName(self, context, *args):

   284

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

   285

   286

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

   287

#           Helpers object for generating pou block instances list

   288

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

   289

   290

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

   291

   292

_BlockInstanceInfos = namedtuple("BlockInstanceInfos",

   293

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

   294

   295

_BlockSpecificValues = (

   296

    namedtuple("BlockSpecificValues",

   297

               ["name", "execution_order"]),

   298

    [_StringValue, int])

   299

_VariableSpecificValues = (

   300

    namedtuple("VariableSpecificValues",

   301

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

   302

    [_StringValue, _StringValue, int])

   303

_ConnectionSpecificValues = (

   304

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

   305

    [_StringValue])

   306

   307

_PowerRailSpecificValues = (

   308

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

   309

    [int])

   310

   311

_LDElementSpecificValues = (

   312

    namedtuple("LDElementSpecificValues",

   313

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

   314

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

   315

   316

_DivergenceSpecificValues = (

   317

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

   318

    [int])

   319

   320

_SpecificValuesTuples = {

   321

    "comment": (

   322

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

   323

        [_StringValue]),

   324

    "input": _VariableSpecificValues,

   325

    "output": _VariableSpecificValues,

   326

    "inout": _VariableSpecificValues,

   327

    "connector": _ConnectionSpecificValues,

   328

    "continuation": _ConnectionSpecificValues,

   329

    "leftPowerRail": _PowerRailSpecificValues,

   330

    "rightPowerRail": _PowerRailSpecificValues,

   331

    "contact": _LDElementSpecificValues,

   332

    "coil": _LDElementSpecificValues,

   333

    "step": (

   334

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

   335

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

   336

    "transition": (

   337

        namedtuple("TransitionSpecificValues",

   338

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

   339

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

   340

    "selectionDivergence": _DivergenceSpecificValues,

   341

    "selectionConvergence": _DivergenceSpecificValues,

   342

    "simultaneousDivergence": _DivergenceSpecificValues,

   343

    "simultaneousConvergence": _DivergenceSpecificValues,

   344

    "jump": (

   345

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

   346

        [_StringValue]),

   347

    "actionBlock": (

   348

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

   349

        [lambda x: x]),

   350

}

   351

   352

_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",

   353

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

   354

   355

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

   356

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

   357

   358

class _ActionInfos(object):

   359

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

   360

    def __init__(self, *args):

   361

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

   362

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

   363

    def copy(self):

   364

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

   365

   366

class BlockInstanceFactory:

   367

   368

    def __init__(self, block_instances):

   369

        self.BlockInstances = block_instances

   370

        self.CurrentInstance = None

   371

        self.SpecificValues = None

   372

        self.CurrentConnection = None

   373

        self.CurrentLink = None

   374

   375

    def SetSpecificValues(self, context, *args):

   376

        self.SpecificValues = list(args)

   377

        self.CurrentInstance = None

   378

        self.CurrentConnection = None

   379

        self.CurrentLink = None

   380

   381

    def AddBlockInstance(self, context, *args):

   382

        specific_values_tuple, specific_values_translation = \

   383

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

   384

   385

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

   386

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

   387

            self.SpecificValues.append([None])

   388

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

   389

            self.SpecificValues.append([[]])

   390

        specific_values = specific_values_tuple(*_translate_args(

   391

            specific_values_translation, self.SpecificValues))

   392

        self.SpecificValues = None

   393

   394

        self.CurrentInstance = _BlockInstanceInfos(

   395

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

   396

              [specific_values, [], []]))

   397

   398

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

   399

   400

    def AddInstanceConnection(self, context, *args):

   401

        connection_args = _translate_args(

   402

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

   403

   404

        self.CurrentConnection = _InstanceConnectionInfos(

   405

            *(connection_args[1:4] + [

   406

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

   407

   408

        if self.CurrentInstance is not None:

   409

            if connection_args[0] == "input":

   410

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

   411

            else:

   412

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

   413

        else:

   414

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

   415

   416

    def AddConnectionLink(self, context, *args):

   417

        self.CurrentLink = _ConnectionLinkInfos(

   418

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

   419

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

   420

   421

    def AddLinkPoint(self, context, *args):

   422

        self.CurrentLink.points.append(_Point(

   423

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

   424

   425

    def AddAction(self, context, *args):

   426

        if len(self.SpecificValues) == 0:

   427

            self.SpecificValues.append([[]])

   428

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

   429

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

   430

   431

pou_block_instances_xslt = etree.parse(

   432

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

   433

   434

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

   435

#                         Undo Buffer for PLCOpenEditor

   436

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

   437

   438

# Length of the buffer

   439

UNDO_BUFFER_LENGTH = 20

   440

   441

"""

   442

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

   443

"""

   444

class UndoBuffer:

   445

   446

    # Constructor initialising buffer

   447

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

   448

        self.Buffer = []

   449

        self.CurrentIndex = -1

   450

        self.MinIndex = -1

   451

        self.MaxIndex = -1

   452

        # if current state is defined

   453

        if currentstate:

   454

            self.CurrentIndex = 0

   455

            self.MinIndex = 0

   456

            self.MaxIndex = 0

   457

        # Initialising buffer with currentstate at the first place

   458

        for i in xrange(UNDO_BUFFER_LENGTH):

   459

            if i == 0:

   460

                self.Buffer.append(currentstate)

   461

            else:

   462

                self.Buffer.append(None)

   463

        # Initialising index of state saved

   464

        if issaved:

   465

            self.LastSave = 0

   466

        else:

   467

            self.LastSave = -1

   468

   469

    # Add a new state in buffer

   470

    def Buffering(self, currentstate):

   471

        self.CurrentIndex = (self.CurrentIndex + 1) % UNDO_BUFFER_LENGTH

   472

        self.Buffer[self.CurrentIndex] = currentstate

   473

        # Actualising buffer limits

   474

        self.MaxIndex = self.CurrentIndex

   475

        if self.MinIndex == self.CurrentIndex:

   476

            # If the removed state was the state saved, there is no state saved in the buffer

   477

            if self.LastSave == self.MinIndex:

   478

                self.LastSave = -1

   479

            self.MinIndex = (self.MinIndex + 1) % UNDO_BUFFER_LENGTH

   480

        self.MinIndex = max(self.MinIndex, 0)

   481

   482

    # Return current state of buffer

   483

    def Current(self):

   484

        return self.Buffer[self.CurrentIndex]

   485

   486

    # Change current state to previous in buffer and return new current state

   487

    def Previous(self):

   488

        if self.CurrentIndex != self.MinIndex:

   489

            self.CurrentIndex = (self.CurrentIndex - 1) % UNDO_BUFFER_LENGTH

   490

            return self.Buffer[self.CurrentIndex]

   491

        return None

   492

   493

    # Change current state to next in buffer and return new current state