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

    98

def GetUneditableNames():

    99

    _ = lambda x: x

   100

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

   101

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

   102

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

   103

   104

   105

UNEDITABLE_NAMES = GetUneditableNames()

   106

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,

   107

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

   108

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   109

   110

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

   111

#                 Helper object for loading library in xslt stylesheets

   112

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

   113

   114

   115

class LibraryResolver(etree.Resolver):

   116

   117

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

   118

        self.Controller = controller

   119

        self.Debug = debug

   120

   121

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

   122

        lib_name = os.path.basename(url)

   123

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

   124

            lib_el = etree.Element(lib_name)

   125

            if lib_name == "project":

   126

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

   127

            elif lib_name == "stdlib":

   128

                for lib in StdBlckLibs.values():

   129

                    lib_el.append(deepcopy(lib))

   130

            else:

   131

                for ctn in self.Controller.ConfNodeTypes:

   132

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

   133

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

   134

   135

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

   136

#           Helpers functions for translating list of arguments

   137

#                       from xslt to valid arguments

   138

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

   139

   140

   141

_StringValue = lambda x: x

   142

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

   143

   144

   145

def _translate_args(translations, args):

   146

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

   147

            for translate, arg in

   148

            zip(translations, args)]

   149

   150

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

   151

#                 Helpers object for generating pou var list

   152

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

   153

   154

   155

class _VariableInfos(object):

   156

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

   157

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

   158

    def __init__(self, *args):

   159

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

   160

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

   161

    def copy(self):

   162

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

   163

   164

   165

class VariablesInfosFactory:

   166

   167

    def __init__(self, variables):

   168

        self.Variables = variables

   169

        self.TreeStack = []

   170

        self.Type = None

   171

        self.Dimensions = None

   172

   173

    def SetType(self, context, *args):

   174

        self.Type = args[0][0]

   175

   176

    def GetType(self):

   177

        if len(self.Dimensions) > 0:

   178

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

   179

        return self.Type

   180

   181

    def GetTree(self):

   182

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

   183

   184

    def AddDimension(self, context, *args):

   185

        self.Dimensions.append(tuple(

   186

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

   187

   188

    def AddTree(self, context, *args):

   189

        self.TreeStack.append([])

   190

        self.Dimensions = []

   191

   192

    def AddVarToTree(self, context, *args):

   193

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

   194

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

   195

   196

    def AddVariable(self, context, *args):

   197

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

   198

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

   199

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

   200

   201

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

   202

#            Helpers object for generating pou variable instance list

   203

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

   204

   205

   206

def class_extraction(value):

   207

    class_type = {

   208

        "configuration": ITEM_CONFIGURATION,

   209

        "resource": ITEM_RESOURCE,

   210

        "action": ITEM_ACTION,

   211

        "transition": ITEM_TRANSITION,

   212

        "program": ITEM_PROGRAM}.get(value)

   213

    if class_type is not None:

   214

        return class_type

   215

   216

    pou_type = POU_TYPES.get(value)

   217

    if pou_type is not None:

   218

        return pou_type

   219

   220

    var_type = VAR_CLASS_INFOS.get(value)

   221

    if var_type is not None:

   222

        return var_type[1]

   223

   224

    return None

   225

   226

   227

class _VariablesTreeItemInfos(object):

   228

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

   229

    def __init__(self, *args):

   230

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

   231

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

   232

    def copy(self):

   233

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

   234

   235

   236

class VariablesTreeInfosFactory:

   237

   238

    def __init__(self):

   239

        self.Root = None

   240

   241

    def GetRoot(self):

   242

        return self.Root

   243

   244

    def SetRoot(self, context, *args):

   245

        self.Root = _VariablesTreeItemInfos(

   246

            *([''] + _translate_args(

   247

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

   248

                args) + [[]]))

   249

   250

    def AddVariable(self, context, *args):

   251

        if self.Root is not None:

   252

            self.Root.variables.append(_VariablesTreeItemInfos(

   253

                *(_translate_args(

   254

                    [_StringValue, class_extraction, _StringValue] +

   255

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

   256

   257

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

   258

#            Helpers object for generating instances path list

   259

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

   260

   261

   262

class InstancesPathFactory:

   263

   264

    def __init__(self, instances):

   265

        self.Instances = instances

   266

   267

    def AddInstance(self, context, *args):

   268

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

   269

   270

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

   271

#            Helpers object for generating instance tagname

   272

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

   273

   274

   275

class InstanceTagName:

   276

   277

    def __init__(self, controller):

   278

        self.Controller = controller

   279

        self.TagName = None

   280

   281

    def GetTagName(self):

   282

        return self.TagName

   283

   284

    def ConfigTagName(self, context, *args):

   285

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

   286

   287

    def ResourceTagName(self, context, *args):

   288

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

   289

   290

    def PouTagName(self, context, *args):

   291

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

   292

   293

    def ActionTagName(self, context, *args):

   294

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

   295

   296

    def TransitionTagName(self, context, *args):

   297

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

   298

   299

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

   300

#           Helpers object for generating pou block instances list

   301

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

   302

   303

   304

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

   305

   306

_BlockInstanceInfos = namedtuple("BlockInstanceInfos",

   307

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

   308

   309

_BlockSpecificValues = (

   310

    namedtuple("BlockSpecificValues",

   311

               ["name", "execution_order"]),

   312

    [_StringValue, int])

   313

_VariableSpecificValues = (

   314

    namedtuple("VariableSpecificValues",

   315

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

   316

    [_StringValue, _StringValue, int])

   317

_ConnectionSpecificValues = (

   318

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

   319

    [_StringValue])

   320

   321

_PowerRailSpecificValues = (

   322

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

   323

    [int])

   324

   325

_LDElementSpecificValues = (

   326

    namedtuple("LDElementSpecificValues",

   327

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

   328

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

   329

   330

_DivergenceSpecificValues = (

   331

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

   332

    [int])

   333

   334

_SpecificValuesTuples = {

   335

    "comment": (

   336

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

   337

        [_StringValue]),

   338

    "input": _VariableSpecificValues,

   339

    "output": _VariableSpecificValues,

   340

    "inout": _VariableSpecificValues,

   341

    "connector": _ConnectionSpecificValues,

   342

    "continuation": _ConnectionSpecificValues,

   343

    "leftPowerRail": _PowerRailSpecificValues,

   344

    "rightPowerRail": _PowerRailSpecificValues,

   345

    "contact": _LDElementSpecificValues,

   346

    "coil": _LDElementSpecificValues,

   347

    "step": (

   348

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

   349

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

   350

    "transition": (

   351

        namedtuple("TransitionSpecificValues",

   352

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

   353

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

   354

    "selectionDivergence": _DivergenceSpecificValues,

   355

    "selectionConvergence": _DivergenceSpecificValues,

   356

    "simultaneousDivergence": _DivergenceSpecificValues,

   357

    "simultaneousConvergence": _DivergenceSpecificValues,

   358

    "jump": (

   359

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

   360

        [_StringValue]),

   361

    "actionBlock": (

   362

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

   363

        [lambda x: x]),

   364

}

   365

   366

_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",

   367

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

   368

   369

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

   370

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

   371

   372

   373

class _ActionInfos(object):

   374

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

   375

    def __init__(self, *args):

   376

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

   377

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

   378

    def copy(self):

   379

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

   380

   381

   382

class BlockInstanceFactory:

   383

   384

    def __init__(self, block_instances):

   385

        self.BlockInstances = block_instances

   386

        self.CurrentInstance = None

   387

        self.SpecificValues = None

   388

        self.CurrentConnection = None

   389

        self.CurrentLink = None

   390

   391

    def SetSpecificValues(self, context, *args):

   392

        self.SpecificValues = list(args)

   393

        self.CurrentInstance = None

   394

        self.CurrentConnection = None

   395

        self.CurrentLink = None

   396

   397

    def AddBlockInstance(self, context, *args):

   398

        specific_values_tuple, specific_values_translation = \

   399

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

   400

   401

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

   402

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

   403

            self.SpecificValues.append([None])

   404

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

   405

            self.SpecificValues.append([[]])

   406

        specific_values = specific_values_tuple(*_translate_args(

   407

            specific_values_translation, self.SpecificValues))

   408

        self.SpecificValues = None

   409

   410

        self.CurrentInstance = _BlockInstanceInfos(

   411

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

   412

              [specific_values, [], []]))

   413

   414

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

   415

   416

    def AddInstanceConnection(self, context, *args):

   417

        connection_args = _translate_args(

   418

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

   419

   420

        self.CurrentConnection = _InstanceConnectionInfos(

   421

            *(connection_args[1:4] + [

   422

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

   423

   424

        if self.CurrentInstance is not None:

   425

            if connection_args[0] == "input":

   426

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

   427

            else:

   428

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

   429

        else:

   430

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

   431

   432

    def AddConnectionLink(self, context, *args):

   433

        self.CurrentLink = _ConnectionLinkInfos(

   434

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

   435

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

   436

   437

    def AddLinkPoint(self, context, *args):

   438

        self.CurrentLink.points.append(_Point(

   439

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

   440

   441

    def AddAction(self, context, *args):

   442

        if len(self.SpecificValues) == 0:

   443

            self.SpecificValues.append([[]])

   444

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

   445

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

   446

   447

   448

pou_block_instances_xslt = etree.parse(

   449

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

   450

   451

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

   452

#                         Undo Buffer for PLCOpenEditor

   453

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

   454

   455

# Length of the buffer

   456

UNDO_BUFFER_LENGTH = 20

   457

   458

   459

class UndoBuffer:

   460

    """

   461

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

   462

    """

   463

   464

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

   465

        """

   466

        Constructor initialising buffer

   467

        """

   468

        self.Buffer = []

   469

        self.CurrentIndex = -1

   470

        self.MinIndex = -1

   471

        self.MaxIndex = -1

   472

        # if current state is defined

   473

        if currentstate:

   474

            self.CurrentIndex = 0

   475

            self.MinIndex = 0

   476

            self.MaxIndex = 0

   477

        # Initialising buffer with currentstate at the first place

   478

        for i in xrange(UNDO_BUFFER_LENGTH):

   479

            if i == 0:

   480

                self.Buffer.append(currentstate)

   481

            else:

   482

                self.Buffer.append(None)

   483

        # Initialising index of state saved

   484

        if issaved:

   485

            self.LastSave = 0

   486

        else:

   487

            self.LastSave = -1

   488

   489

    def Buffering(self, currentstate):

   490