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

    _ = NoTranslate

   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

def _StringValue(x):

   142

    return x

   143

   144

   145

def _BoolValue(x):

   146

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

   147

   148

   149

def _translate_args(translations, args):

   150

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

   151

            for translate, arg in

   152

            zip(translations, args)]

   153

   154

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

   155

#                 Helpers object for generating pou var list

   156

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

   157

   158

   159

class _VariableInfos(object):

   160

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

   161

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

   162

   163

    def __init__(self, *args):

   164

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

   165

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

   166

   167

    def copy(self):

   168

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

   169

   170

   171

class VariablesInfosFactory:

   172

   173

    def __init__(self, variables):

   174

        self.Variables = variables

   175

        self.TreeStack = []

   176

        self.Type = None

   177

        self.Dimensions = None

   178

   179

    def SetType(self, context, *args):

   180

        self.Type = args[0][0]

   181

   182

    def GetType(self):

   183

        if len(self.Dimensions) > 0:

   184

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

   185

        return self.Type

   186

   187

    def GetTree(self):

   188

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

   189

   190

    def AddDimension(self, context, *args):

   191

        self.Dimensions.append(tuple(

   192

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

   193

   194

    def AddTree(self, context, *args):

   195

        self.TreeStack.append([])

   196

        self.Dimensions = []

   197

   198

    def AddVarToTree(self, context, *args):

   199

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

   200

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

   201

   202

    def AddVariable(self, context, *args):

   203

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

   204

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

   205

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

   206

   207

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

   208

#            Helpers object for generating pou variable instance list

   209

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

   210

   211

   212

def class_extraction(value):

   213

    class_type = {

   214

        "configuration": ITEM_CONFIGURATION,

   215

        "resource": ITEM_RESOURCE,

   216

        "action": ITEM_ACTION,

   217

        "transition": ITEM_TRANSITION,

   218

        "program": ITEM_PROGRAM}.get(value)

   219

    if class_type is not None:

   220

        return class_type

   221

   222

    pou_type = POU_TYPES.get(value)

   223

    if pou_type is not None:

   224

        return pou_type

   225

   226

    var_type = VAR_CLASS_INFOS.get(value)

   227

    if var_type is not None:

   228

        return var_type[1]

   229

   230

    return None

   231

   232

   233

class _VariablesTreeItemInfos(object):

   234

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

   235

   236

    def __init__(self, *args):

   237

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

   238

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

   239

   240

    def copy(self):

   241

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

   242

   243

   244

class VariablesTreeInfosFactory:

   245

   246

    def __init__(self):

   247

        self.Root = None

   248

   249

    def GetRoot(self):

   250

        return self.Root

   251

   252

    def SetRoot(self, context, *args):

   253

        self.Root = _VariablesTreeItemInfos(

   254

            *([''] + _translate_args(

   255

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

   256

                args) + [[]]))

   257

   258

    def AddVariable(self, context, *args):

   259

        if self.Root is not None:

   260

            self.Root.variables.append(_VariablesTreeItemInfos(

   261

                *(_translate_args(

   262

                    [_StringValue, class_extraction, _StringValue] +

   263

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

   264

   265

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

   266

#            Helpers object for generating instances path list

   267

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

   268

   269

   270

class InstancesPathFactory:

   271

   272

    def __init__(self, instances):

   273

        self.Instances = instances

   274

   275

    def AddInstance(self, context, *args):

   276

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

   277

   278

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

   279

#            Helpers object for generating instance tagname

   280

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

   281

   282

   283

class InstanceTagName:

   284

   285

    def __init__(self, controller):

   286

        self.Controller = controller

   287

        self.TagName = None

   288

   289

    def GetTagName(self):

   290

        return self.TagName

   291

   292

    def ConfigTagName(self, context, *args):

   293

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

   294

   295

    def ResourceTagName(self, context, *args):

   296

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

   297

   298

    def PouTagName(self, context, *args):

   299

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

   300

   301

    def ActionTagName(self, context, *args):

   302

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

   303

   304

    def TransitionTagName(self, context, *args):

   305

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

   306

   307

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

   308

#           Helpers object for generating pou block instances list

   309

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

   310

   311

   312

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

   313

   316

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

   317

   318

_BlockSpecificValues = (

   319

    namedtuple("BlockSpecificValues",

   320

               ["name", "execution_order"]),

   321

    [_StringValue, int])

   322

_VariableSpecificValues = (

   323

    namedtuple("VariableSpecificValues",

   324

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

   325

    [_StringValue, _StringValue, int])

   326

_ConnectionSpecificValues = (

   327

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

   328

    [_StringValue])

   329

   330

_PowerRailSpecificValues = (

   331

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

   332

    [int])

   333

   334

_LDElementSpecificValues = (

   335

    namedtuple("LDElementSpecificValues",

   336

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

   337

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

   338

   339

_DivergenceSpecificValues = (

   340

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

   341

    [int])

   342

   343

_SpecificValuesTuples = {

   344

    "comment": (

   345

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

   346

        [_StringValue]),

   347

    "input": _VariableSpecificValues,

   348

    "output": _VariableSpecificValues,

   349

    "inout": _VariableSpecificValues,

   350

    "connector": _ConnectionSpecificValues,

   351

    "continuation": _ConnectionSpecificValues,

   352

    "leftPowerRail": _PowerRailSpecificValues,

   353

    "rightPowerRail": _PowerRailSpecificValues,

   354

    "contact": _LDElementSpecificValues,

   355

    "coil": _LDElementSpecificValues,

   356

    "step": (

   357

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

   358

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

   359

    "transition": (

   360

        namedtuple("TransitionSpecificValues",

   361

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

   362

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

   363

    "selectionDivergence": _DivergenceSpecificValues,

   364

    "selectionConvergence": _DivergenceSpecificValues,

   365

    "simultaneousDivergence": _DivergenceSpecificValues,

   366

    "simultaneousConvergence": _DivergenceSpecificValues,

   367

    "jump": (

   368

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

   369

        [_StringValue]),

   370

    "actionBlock": (

   371

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

   372

        [lambda x: x]),

   373

}

   374

   377

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

   378

   381

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

   382

   383

   384

class _ActionInfos(object):

   385

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

   386

   387

    def __init__(self, *args):

   388

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

   389

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

   390

   391

    def copy(self):

   392

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

   393

   394

   395

class BlockInstanceFactory:

   396

   397

    def __init__(self, block_instances):

   398

        self.BlockInstances = block_instances

   399

        self.CurrentInstance = None

   400

        self.SpecificValues = None

   401

        self.CurrentConnection = None

   402

        self.CurrentLink = None

   403

   404

    def SetSpecificValues(self, context, *args):

   405

        self.SpecificValues = list(args)

   406

        self.CurrentInstance = None

   407

        self.CurrentConnection = None

   408

        self.CurrentLink = None

   409

   410

    def AddBlockInstance(self, context, *args):

   411

        specific_values_tuple, specific_values_translation = \

   412

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

   413

   414

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

   415

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

   416

            self.SpecificValues.append([None])

   417

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

   418

            self.SpecificValues.append([[]])

   419

        specific_values = specific_values_tuple(*_translate_args(

   420

            specific_values_translation, self.SpecificValues))

   421

        self.SpecificValues = None

   422

   423

        self.CurrentInstance = _BlockInstanceInfos(

   424

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

   425

              [specific_values, [], []]))

   426

   427

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

   428

   429

    def AddInstanceConnection(self, context, *args):

   430

        connection_args = _translate_args(

   431

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

   432

   433

        self.CurrentConnection = _InstanceConnectionInfos(

   434

            *(connection_args[1:4] + [

   435

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

   436

   437

        if self.CurrentInstance is not None:

   438

            if connection_args[0] == "input":

   439

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

   440

            else:

   441

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

   442

        else:

   443

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

   444

   445

    def AddConnectionLink(self, context, *args):

   446

        self.CurrentLink = _ConnectionLinkInfos(

   447

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

   448

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

   449

   450

    def AddLinkPoint(self, context, *args):

   451

        self.CurrentLink.points.append(_Point(

   452

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

   453

   454

    def AddAction(self, context, *args):

   455

        if len(self.SpecificValues) == 0:

   456

            self.SpecificValues.append([[]])

   457

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

   458

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

   459

   460

   461

pou_block_instances_xslt = etree.parse(

   462

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

   463

   464

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

   465

#                         Undo Buffer for PLCOpenEditor

   466

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

   467

   468

# Length of the buffer

   469

UNDO_BUFFER_LENGTH = 20

   470

   471

   472

class UndoBuffer:

   473

    """

   474

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

   475

    """

   476

   477

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

   478

        """

   479

        Constructor initialising buffer

   480

        """

   481

        self.Buffer = []

   482

        self.CurrentIndex = -1

   483

        self.MinIndex = -1

   484

        self.MaxIndex = -1

   485

        # if current state is defined

   486

        if currentstate:

   487

            self.CurrentIndex = 0

   488

            self.MinIndex = 0