1 #!/usr/bin/env python

     2 # -*- coding: utf-8 -*-

     3 

     4 #This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5 #based on the plcopen standard. 

     6 #

     7 #Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8 #

     9 #See COPYING file for copyrights details.

    10 #

    11 #This library is free software; you can redistribute it and/or

    12 #modify it under the terms of the GNU General Public

    13 #License as published by the Free Software Foundation; either

    14 #version 2.1 of the License, or (at your option) any later version.

    15 #

    16 #This library is distributed in the hope that it will be useful,

    17 #but WITHOUT ANY WARRANTY; without even the implied warranty of

    18 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19 #General Public License for more details.

    20 #

    21 #You should have received a copy of the GNU General Public

    22 #License along with this library; if not, write to the Free Software

    23 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24 

    25 from xml.dom import minidom

    26 from types import StringType, UnicodeType, TupleType

    27 import cPickle

    28 import os,sys,re

    29 import datetime

    30 from time import localtime

    31 

    32 from plcopen import plcopen

    33 from plcopen.structures import *

    34 from graphics.GraphicCommons import *

    35 from PLCGenerator import *

    36 

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

    38 

    39 ITEMS_EDITABLE = [ITEM_PROJECT,

    40                   ITEM_POU,

    41                   ITEM_VARIABLE,

    42                   ITEM_TRANSITION,

    43                   ITEM_ACTION,

    44                   ITEM_CONFIGURATION,

    45                   ITEM_RESOURCE,

    46                   ITEM_DATATYPE

    47                  ] = range(8)

    48 

    49 ITEMS_UNEDITABLE = [ITEM_DATATYPES,

    50                     ITEM_FUNCTION,

    51                     ITEM_FUNCTIONBLOCK,

    52                     ITEM_PROGRAM,

    53                     ITEM_TRANSITIONS,

    54                     ITEM_ACTIONS,

    55                     ITEM_CONFIGURATIONS,

    56                     ITEM_RESOURCES,

    57                     ITEM_PROPERTIES

    58                    ] = range(8, 17)

    59  

    60 ITEMS_VARIABLE = [ITEM_VAR_LOCAL,

    61                   ITEM_VAR_GLOBAL,

    62                   ITEM_VAR_EXTERNAL,

    63                   ITEM_VAR_TEMP,

    64                   ITEM_VAR_INPUT,

    65                   ITEM_VAR_OUTPUT,

    66                   ITEM_VAR_INOUT

    67                  ] = range(17, 24)

    68 

    69 VAR_CLASS_INFOS = {"Local" :    (plcopen.interface_localVars,    ITEM_VAR_LOCAL),

    70                    "Global" :   (plcopen.interface_globalVars,   ITEM_VAR_GLOBAL),

    71                    "External" : (plcopen.interface_externalVars, ITEM_VAR_EXTERNAL),

    72                    "Temp" :     (plcopen.interface_tempVars,     ITEM_VAR_TEMP),

    73                    "Input" :    (plcopen.interface_inputVars,    ITEM_VAR_INPUT),

    74                    "Output" :   (plcopen.interface_outputVars,   ITEM_VAR_OUTPUT),

    75                    "InOut" :    (plcopen.interface_inOutVars,    ITEM_VAR_INOUT)

    76                   }

    77 

    78 POU_TYPES = {"program": ITEM_PROGRAM,

    79              "functionBlock": ITEM_FUNCTIONBLOCK,

    80              "function": ITEM_FUNCTION,

    81             }

    82 

    83 LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    84                    LOCATION_MODULE,

    85                    LOCATION_GROUP,

    86                    LOCATION_VAR_INPUT,

    87                    LOCATION_VAR_OUTPUT,

    88                    LOCATION_VAR_MEMORY] = range(6)

    89 

    90 ScriptDirectory = os.path.split(os.path.realpath(__file__))[0]

    91 

    92 def GetUneditableNames():

    93     _ = lambda x:x

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

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

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

    97 UNEDITABLE_NAMES = GetUneditableNames()

    98 [USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS, 

    99  DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS, 

   100  RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   101 

   102 #-------------------------------------------------------------------------------

   103 #                         Undo Buffer for PLCOpenEditor

   104 #-------------------------------------------------------------------------------

   105 

   106 # Length of the buffer

   107 UNDO_BUFFER_LENGTH = 20

   108 

   109 """

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

   111 """

   112 class UndoBuffer:

   113 

   114     # Constructor initialising buffer

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

   116         self.Buffer = []

   117         self.CurrentIndex = -1

   118         self.MinIndex = -1

   119         self.MaxIndex = -1

   120         # if current state is defined

   121         if currentstate:

   122             self.CurrentIndex = 0

   123             self.MinIndex = 0

   124             self.MaxIndex = 0

   125         # Initialising buffer with currentstate at the first place

   126         for i in xrange(UNDO_BUFFER_LENGTH):

   127             if i == 0:

   128                 self.Buffer.append(currentstate)

   129             else:

   130                 self.Buffer.append(None)

   131         # Initialising index of state saved

   132         if issaved:

   133             self.LastSave = 0

   134         else:

   135             self.LastSave = -1

   136     

   137     # Add a new state in buffer

   138     def Buffering(self, currentstate):

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

   140         self.Buffer[self.CurrentIndex] = currentstate

   141         # Actualising buffer limits

   142         self.MaxIndex = self.CurrentIndex

   143         if self.MinIndex == self.CurrentIndex:

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

   145             if self.LastSave == self.MinIndex:

   146                 self.LastSave = -1

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

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

   149     

   150     # Return current state of buffer

   151     def Current(self):

   152         return self.Buffer[self.CurrentIndex]

   153     

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

   155     def Previous(self):

   156         if self.CurrentIndex != self.MinIndex:

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

   158             return self.Buffer[self.CurrentIndex]

   159         return None

   160     

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

   162     def Next(self):

   163         if self.CurrentIndex != self.MaxIndex:

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

   165             return self.Buffer[self.CurrentIndex]

   166         return None

   167     

   168     # Return True if current state is the first in buffer

   169     def IsFirst(self):

   170         return self.CurrentIndex == self.MinIndex

   171     

   172     # Return True if current state is the last in buffer

   173     def IsLast(self):

   174         return self.CurrentIndex == self.MaxIndex

   175 

   176     # Note that current state is saved

   177     def CurrentSaved(self):

   178         self.LastSave = self.CurrentIndex

   179         

   180     # Return True if current state is saved

   181     def IsCurrentSaved(self):

   182         return self.LastSave == self.CurrentIndex

   183 

   184 

   185 #-------------------------------------------------------------------------------

   186 #                           Controler for PLCOpenEditor

   187 #-------------------------------------------------------------------------------

   188 

   189 """

   190 Class which controls the operations made on the plcopen model and answers to view requests

   191 """

   192 class PLCControler:

   193     

   194     # Create a new PLCControler

   195     def __init__(self):

   196         self.LastNewIndex = 0

   197         self.Reset()

   198     

   199     # Reset PLCControler internal variables

   200     def Reset(self):

   201         self.Project = None

   202         self.ProjectBufferEnabled = True

   203         self.ProjectBuffer = None

   204         self.ProjectSaved = True

   205         self.Buffering = False

   206         self.FilePath = ""

   207         self.FileName = ""

   208         self.ProgramChunks = []

   209         self.ProgramOffset = 0

   210         self.NextCompiledProject = None

   211         self.CurrentCompiledProject = None

   212         self.ConfNodeTypes = []

   213         self.ProgramFilePath = ""

   214         

   215     def GetQualifierTypes(self):

   216         return plcopen.QualifierList

   217 

   218     def GetProject(self, debug = False):

   219         if debug and self.CurrentCompiledProject is not None:

   220             return self.CurrentCompiledProject

   221         else:

   222             return self.Project

   223 

   224 #-------------------------------------------------------------------------------

   225 #                         Project management functions

   226 #-------------------------------------------------------------------------------

   227 

   228     # Return if a project is opened

   229     def HasOpenedProject(self):

   230         return self.Project is not None

   231 

   232     # Create a new project by replacing the current one

   233     def CreateNewProject(self, properties):

   234         # Create the project

   235         self.Project = plcopen.project()

   236         properties["creationDateTime"] = datetime.datetime(*localtime()[:6])

   237         self.Project.setfileHeader(properties)

   238         self.Project.setcontentHeader(properties)

   239         self.SetFilePath("")

   240         # Initialize the project buffer

   241         self.CreateProjectBuffer(False)

   242         self.ProgramChunks = []

   243         self.ProgramOffset = 0

   244         self.NextCompiledProject = self.Copy(self.Project)

   245         self.CurrentCompiledProject = None

   246         self.Buffering = False

   247     

   248     # Return project data type names

   249     def GetProjectDataTypeNames(self, debug = False):

   250         project = self.GetProject(debug)

   251         if project is not None:

   252             return [datatype.getname() for datatype in project.getdataTypes()]

   253         return []

   254     

   255     # Return project pou names

   256     def GetProjectPouNames(self, debug = False):

   257         project = self.GetProject(debug)

   258         if project is not None:

   259             return [pou.getname() for pou in project.getpous()]

   260         return []

   261     

   262     # Return project pou names

   263     def GetProjectConfigNames(self, debug = False):

   264         project = self.GetProject(debug)

   265         if project is not None:

   266             return [config.getname() for config in project.getconfigurations()]

   267         return []

   268     

   269     # Return project pou variables

   270     def GetProjectPouVariables(self, pou_name = None, debug = False):

   271         variables = []

   272         project = self.GetProject(debug)

   273         if project is not None:

   274             for pou in project.getpous():

   275                 if pou_name is None or pou_name == pou.getname():

   276                     variables.extend([var["Name"] for var in self.GetPouInterfaceVars(pou, debug)])

   277                     for transition in pou.gettransitionList():

   278                         variables.append(transition.getname())

   279                     for action in pou.getactionList():

   280                         variables.append(action.getname())

   281         return variables

   282     

   283     # Return file path if project is an open file

   284     def GetFilePath(self):

   285         return self.FilePath

   286     

   287     # Return file path if project is an open file

   288     def GetProgramFilePath(self):

   289         return self.ProgramFilePath

   290     

   291     # Return file name and point out if file is up to date

   292     def GetFilename(self):

   293         if self.Project is not None:

   294             if self.ProjectIsSaved():

   295                 return self.FileName

   296             else:

   297                 return "~%s~"%self.FileName

   298         return ""

   299     

   300     # Change file path and save file name or create a default one if file path not defined

   301     def SetFilePath(self, filepath):

   302         self.FilePath = filepath

   303         if filepath == "":

   304             self.LastNewIndex += 1

   305             self.FileName = _("Unnamed%d")%self.LastNewIndex

   306         else:

   307             self.FileName = os.path.splitext(os.path.basename(filepath))[0]

   308     

   309     # Change project properties

   310     def SetProjectProperties(self, name = None, properties = None, buffer = True):

   311         if self.Project is not None:

   312             if name is not None:

   313                 self.Project.setname(name)

   314             if properties is not None:

   315                 self.Project.setfileHeader(properties)

   316                 self.Project.setcontentHeader(properties)

   317             if buffer and (name is not None or properties is not None):

   318                 self.BufferProject()

   319     

   320     # Return project name

   321     def GetProjectName(self, debug=False):

   322         project = self.GetProject(debug)

   323         if project is not None:

   324             return project.getname()

   325         return None

   326     

   327     # Return project properties

   328     def GetProjectProperties(self, debug = False):

   329         project = self.GetProject(debug)

   330         if project is not None:

   331             properties = project.getfileHeader()

   332             properties.update(project.getcontentHeader())

   333             return properties

   334         return None

   335     

   336     # Return project informations

   337     def GetProjectInfos(self, debug = False):

   338         project = self.GetProject(debug)

   339         if project is not None:

   340             infos = {"name": project.getname(), "type": ITEM_PROJECT}

   341             datatypes = {"name": DATA_TYPES, "type": ITEM_DATATYPES, "values":[]}

   342             for datatype in project.getdataTypes():

   343                 datatypes["values"].append({"name": datatype.getname(), "type": ITEM_DATATYPE, 

   344                     "tagname": self.ComputeDataTypeName(datatype.getname()), "values": []})

   345             pou_types = {"function": {"name": FUNCTIONS, "type": ITEM_FUNCTION, "values":[]},

   346                          "functionBlock": {"name": FUNCTION_BLOCKS, "type": ITEM_FUNCTIONBLOCK, "values":[]},

   347                          "program": {"name": PROGRAMS, "type": ITEM_PROGRAM, "values":[]}}

   348             for pou in project.getpous():

   349                 pou_type = pou.getpouType()

   350                 pou_infos = {"name": pou.getname(), "type": ITEM_POU,

   351                              "tagname": self.ComputePouName(pou.getname())}

   352                 pou_values = []

   353                 if pou.getbodyType() == "SFC":

   354                     transitions = []

   355                     for transition in pou.gettransitionList():

   356                         transitions.append({"name": transition.getname(), "type": ITEM_TRANSITION, 

   357                             "tagname": self.ComputePouTransitionName(pou.getname(), transition.getname()), 

   358                             "values": []})

   359                     pou_values.append({"name": TRANSITIONS, "type": ITEM_TRANSITIONS, "values": transitions})

   360                     actions = []

   361                     for action in pou.getactionList():

   362                         actions.append({"name": action.getname(), "type": ITEM_ACTION, 

   363                             "tagname": self.ComputePouActionName(pou.getname(), action.getname()), 

   364                             "values": []})

   365                     pou_values.append({"name": ACTIONS, "type": ITEM_ACTIONS, "values": actions})

   366                 if pou_type in pou_types:

   367                     pou_infos["values"] = pou_values

   368                     pou_types[pou_type]["values"].append(pou_infos)

   369             configurations = {"name": CONFIGURATIONS, "type": ITEM_CONFIGURATIONS, "values": []}

   370             for config in project.getconfigurations():

   371                 config_name = config.getname()

   372                 config_infos = {"name": config_name, "type": ITEM_CONFIGURATION, 

   373                     "tagname": self.ComputeConfigurationName(config.getname()), 

   374                     "values": []}

   375                 resources = {"name": RESOURCES, "type": ITEM_RESOURCES, "values": []}

   376                 for resource in config.getresource():

   377                     resource_name = resource.getname()

   378                     resource_infos = {"name": resource_name, "type": ITEM_RESOURCE, 

   379                         "tagname": self.ComputeConfigurationResourceName(config.getname(), resource.getname()), 

   380                         "values": []}

   381                     resources["values"].append(resource_infos)

   382                 config_infos["values"] = [resources]

   383                 configurations["values"].append(config_infos)

   384             infos["values"] = [datatypes, pou_types["function"], pou_types["functionBlock"], 

   385                                pou_types["program"], configurations]

   386             return infos

   387         return None

   388 

   389     def GetPouVariableInfos(self, project, variable, var_class, debug=False):

   390         vartype_content = variable.gettype().getcontent()

   391         if vartype_content["name"] == "derived":

   392             var_type = vartype_content["value"].getname()

   393             pou_type = None

   394             pou = project.getpou(var_type)

   395             if pou is not None:

   396                 pou_type = pou.getpouType()

   397             edit = debug = pou_type is not None

   398             if pou_type is None:

   399                 block_infos = self.GetBlockType(var_type, debug = debug)

   400                 if block_infos is not None:

   401                     pou_type = block_infos["type"]

   402             if pou_type is not None:

   403                 var_class = None

   404                 if pou_type == "program":

   405                     var_class = ITEM_PROGRAM

   406                 elif pou_type != "function":

   407                     var_class = ITEM_FUNCTIONBLOCK

   408                 if var_class is not None:

   409                     return {"name": variable.getname(), 

   410                             "type": var_type, 

   411                             "class": var_class,

   412                             "edit": edit,

   413                             "debug": debug}

   414             elif var_type in self.GetDataTypes(debug = debug):

   415                 return {"name": variable.getname(), 

   416                         "type": var_type, 

   417                         "class": var_class,

   418                         "edit": False,

   419                         "debug": False}

   420         elif vartype_content["name"] in ["string", "wstring"]:

   421             return {"name": variable.getname(), 

   422                     "type": vartype_content["name"].upper(), 

   423                     "class": var_class,

   424                     "edit": False,

   425                     "debug": True}

   426         else:

   427             return {"name": variable.getname(),

   428                     "type": vartype_content["name"], 

   429                     "class": var_class,

   430                     "edit": False,

   431                     "debug": True}

   432         return None

   433 

   434     def GetPouVariables(self, tagname, debug = False):

   435         vars = []

   436         pou_type = None

   437         project = self.GetProject(debug)

   438         if project is not None:

   439             words = tagname.split("::")

   440             if words[0] == "P":

   441                 pou = project.getpou(words[1])

   442                 if pou is not None:

   443                     pou_type = pou.getpouType()

   444                     if (pou_type in ["program", "functionBlock"] and 

   445                         pou.interface is not None):

   446                         # Extract variables from every varLists

   447                         for varlist_type, varlist in pou.getvars():

   448                             var_infos = VAR_CLASS_INFOS.get(varlist_type, None)

   449                             if var_infos is not None:

   450                                 var_class = var_infos[1]

   451                             else:

   452                                 var_class = ITEM_VAR_LOCAL

   453                             for variable in varlist.getvariable():

   454                                 var_infos = self.GetPouVariableInfos(project, variable, var_class, debug)

   455                                 if var_infos is not None:

   456                                     vars.append(var_infos)

   457                         return {"class": POU_TYPES[pou_type],

   458                                 "type": words[1],

   459                                 "variables": vars,

   460                                 "edit": True,

   461                                 "debug": True}

   462                 else:

   463                     block_infos = self.GetBlockType(words[1], debug = debug)

   464                     if (block_infos is not None and 

   465                         block_infos["type"] in ["program", "functionBlock"]):

   466                         for varname, vartype, varmodifier in block_infos["inputs"]:

   467                             vars.append({"name" : varname, 

   468                                          "type" : vartype, 

   469                                          "class" : ITEM_VAR_INPUT,

   470                                          "edit": False,

   471                                          "debug": True})

   472                         for varname, vartype, varmodifier in block_infos["outputs"]:

   473                             vars.append({"name" : varname, 

   474                                          "type" : vartype, 

   475                                          "class" : ITEM_VAR_OUTPUT,

   476                                          "edit": False,

   477                                          "debug": True})

   478                         return {"class": POU_TYPES[block_infos["type"]],

   479                                 "type": None,

   480                                 "variables": vars,

   481                                 "edit": False,

   482                                 "debug": False}

   483             elif words[0] in ['C', 'R']:

   484                 if words[0] == 'C':

   485                     element_type = ITEM_CONFIGURATION

   486                     element = project.getconfiguration(words[1])

   487                     if element is not None:

   488                         for resource in element.getresource():

   489                             vars.append({"name": resource.getname(),

   490                                          "type": None,

   491                                          "class": ITEM_RESOURCE,

   492                                          "edit": True,

   493                                          "debug": False})

   494                 elif words[0] == 'R':

   495                     element_type = ITEM_RESOURCE

   496                     element = project.getconfigurationResource(words[1], words[2])

   497                     if element is not None:

   498                         for task in element.gettask():

   499                             for pou in task.getpouInstance():

   500                                 vars.append({"name": pou.getname(),

   501                                              "type": pou.gettypeName(),

   502                                              "class": ITEM_PROGRAM,

   503                                              "edit": True,

   504                                              "debug": True})

   505                         for pou in element.getpouInstance():

   506                             vars.append({"name": pou.getname(),

   507                                          "type": pou.gettypeName(),

   508                                          "class": ITEM_PROGRAM,

   509                                          "edit": True,

   510                                          "debug": True})

   511                 if element is not None:

   512                     for varlist in element.getglobalVars():

   513                         for variable in varlist.getvariable():

   514                             var_infos = self.GetPouVariableInfos(project, variable, ITEM_VAR_GLOBAL, debug)

   515                             if var_infos is not None:

   516                                 vars.append(var_infos)

   517                     return {"class": element_type,

   518                             "type": None,

   519                             "variables": vars,

   520                             "edit": True,

   521                             "debug": False}

   522         return None

   523 

   524     def RecursiveSearchPouInstances(self, project, pou_type, parent_path, varlists, debug = False):

   525         instances = []

   526         for varlist in varlists:

   527             for variable in varlist.getvariable():

   528                 vartype_content = variable.gettype().getcontent()

   529                 if vartype_content["name"] == "derived":

   530                     var_path = "%s.%s" % (parent_path, variable.getname())

   531                     var_type = vartype_content["value"].getname()

   532                     if var_type == pou_type:

   533                         instances.append(var_path)

   534                     else:

   535                         pou = project.getpou(var_type)

   536                         if pou is not None:

   537                             instances.extend(

   538                                 self.RecursiveSearchPouInstances(

   539                                     project, pou_type, var_path, 

   540                                     [varlist for type, varlist in pou.getvars()], 

   541                                     debug))

   542         return instances

   543                         

   544     def SearchPouInstances(self, tagname, debug = False):

   545         project = self.GetProject(debug)

   546         if project is not None:

   547             words = tagname.split("::")

   548             if words[0] == "P":

   549                 instances = []

   550                 for config in project.getconfigurations():

   551                     config_name = config.getname()

   552                     instances.extend(

   553                         self.RecursiveSearchPouInstances(

   554                             project, words[1], config_name, 

   555                             config.getglobalVars(), debug))

   556                     for resource in config.getresource():

   557                         res_path = "%s.%s" % (config_name, resource.getname())

   558                         instances.extend(

   559                             self.RecursiveSearchPouInstances(

   560                                 project, words[1], res_path, 

   561                                 resource.getglobalVars(), debug))

   562                         pou_instances = resource.getpouInstance()[:]

   563                         for task in resource.gettask():

   564                             pou_instances.extend(task.getpouInstance())

   565                         for pou_instance in pou_instances:

   566                             pou_path = "%s.%s" % (res_path, pou_instance.getname())

   567                             pou_type = pou_instance.gettypeName()

   568                             if pou_type == words[1]:

   569                                 instances.append(pou_path)

   570                             pou = project.getpou(pou_type)

   571                             if pou is not None:

   572                                 instances.extend(

   573                                     self.RecursiveSearchPouInstances(

   574                                         project, words[1], pou_path, 

   575                                         [varlist for type, varlist in pou.getvars()], 

   576                                         debug))

   577                 return instances

   578             elif words[0] == 'C':

   579                 return [words[1]]

   580             elif words[0] == 'R':

   581                 return ["%s.%s" % (words[1], words[2])]

   582         return []

   583     

   584     def RecursiveGetPouInstanceTagName(self, project, pou_type, parts):

   585         pou = project.getpou(pou_type)

   586         if pou is not None:

   587             if len(parts) == 0:

   588                 return self.ComputePouName(pou_type)

   589             

   590             for varlist_type, varlist in pou.getvars():

   591                 for variable in varlist.getvariable():

   592                     vartype_content = variable.gettype().getcontent()

   593                     if vartype_content["name"] == "derived":

   594                         return self.RecursiveGetPouInstanceTagName(

   595                                         project, 

   596                                         vartype_content["value"].getname(),

   597                                         parts[1:])

   598         return None

   599     

   600     def GetPouInstanceTagName(self, instance_path, debug = False):

   601         parts = instance_path.split(".")

   602         if len(parts) == 1:

   603             return self.ComputeConfigurationName(parts[0])

   604         elif len(parts) == 2:

   605             return self.ComputeConfigurationResourceName(parts[0], parts[1])

   606         else:

   607             project = self.GetProject(debug)

   608             for config in project.getconfigurations():

   609                 if config.getname() == parts[0]:

   610                     for resource in config.getresource():

   611                         if resource.getname() == parts[1]:

   612                             pou_instances = resource.getpouInstance()[:]

   613                             for task in resource.gettask():

   614                                 pou_instances.extend(task.getpouInstance())

   615                             for pou_instance in pou_instances:

   616                                 if pou_instance.getname() == parts[2]:

   617                                     if len(parts) == 3:

   618                                         return self.ComputePouName(

   619                                                     pou_instance.gettypeName())

   620                                     else:

   621                                         return self.RecursiveGetPouInstanceTagName(

   622                                                     project,

   623                                                     pou_instance.gettypeName(),

   624                                                     parts[3:])

   625         return None

   626     

   627     def GetInstanceInfos(self, instance_path, debug = False):

   628         tagname = self.GetPouInstanceTagName(instance_path)

   629         if tagname is not None:

   630             return self.GetPouVariables(tagname, debug)

   631         else:

   632             pou_path, var_name = instance_path.rsplit(".", 1)

   633             tagname = self.GetPouInstanceTagName(pou_path)

   634             if tagname is not None:

   635                 pou_infos = self.GetPouVariables(tagname, debug)

   636                 for var_infos in pou_infos["variables"]:

   637                     if var_infos["name"] == var_name:

   638                         return var_infos

   639         return None

   640     

   641     # Return if data type given by name is used by another data type or pou

   642     def DataTypeIsUsed(self, name, debug = False):

   643         project = self.GetProject(debug)

   644         if project is not None:

   645             return project.ElementIsUsed(name) or project.DataTypeIsDerived(name)

   646         return False

   647 

   648     # Return if pou given by name is used by another pou

   649     def PouIsUsed(self, name, debug = False):

   650         project = self.GetProject(debug)

   651         if project is not None:

   652             return project.ElementIsUsed(name)

   653         return False

   654 

   655     # Return if pou given by name is directly or undirectly used by the reference pou

   656     def PouIsUsedBy(self, name, reference, debug = False):

   657         project = self.GetProject(debug)

   658         if project is not None:

   659             return project.ElementIsUsedBy(name, reference)

   660         return False

   661 

   662     def GenerateProgram(self, filepath=None):

   663         errors = []

   664         warnings = []

   665         if self.Project is not None:

   666             try:

   667                 self.ProgramChunks = GenerateCurrentProgram(self, self.Project, errors, warnings)

   668                 self.NextCompiledProject = self.Copy(self.Project)

   669                 program_text = "".join([item[0].decode("utf-8") for item in self.ProgramChunks])

   670                 if filepath is not None:

   671                     programfile = open(filepath, "w")

   672                     programfile.write(program_text.encode("utf-8"))

   673                     programfile.close()

   674                     self.ProgramFilePath = filepath

   675                 return program_text, errors, warnings

   676             except PLCGenException, e:

   677                 errors.append(e.message)

   678         else:

   679             errors.append("No project opened")

   680         return "", errors, warnings

   681 

   682     def DebugAvailable(self):

   683         return self.CurrentCompiledProject is not None

   684 

   685     def ProgramTransferred(self):

   686         if self.NextCompiledProject is None:

   687             self.CurrentCompiledProject = self.NextCompiledProject

   688         else:

   689             self.CurrentCompiledProject = self.Copy(self.Project)

   690 

   691     def GetChunkInfos(self, from_location, to_location):

   692         row = self.ProgramOffset + 1

   693         col = 1

   694         infos = []

   695         for chunk, chunk_infos in self.ProgramChunks:

   696             lines = chunk.split("\n")

   697             if len(lines) > 1:

   698                 next_row = row + len(lines) - 1

   699                 next_col = len(lines[-1]) + 1

   700             else:

   701                 next_row = row

   702                 next_col = col + len(chunk)

   703             if (next_row > from_location[0] or next_row == from_location[0] and next_col >= from_location[1]) and len(chunk_infos) > 0:

   704                 infos.append((chunk_infos, (row, col)))

   705             if next_row == to_location[0] and next_col > to_location[1] or next_row > to_location[0]:

   706                 return infos

   707             row, col = next_row, next_col

   708         return infos

   709         

   710 #-------------------------------------------------------------------------------

   711 #                        Project Pous management functions

   712 #-------------------------------------------------------------------------------

   713     

   714     # Add a Data Type to Project

   715     def ProjectAddDataType(self, datatype_name=None):

   716         if self.Project is not None:

   717             if datatype_name is None:

   718                 datatype_name = self.GenerateNewName(None, None, "datatype%d")

   719             # Add the datatype to project

   720             self.Project.appenddataType(datatype_name)

   721             self.BufferProject()

   722             return self.ComputeDataTypeName(datatype_name)

   723         return None

   724         

   725     # Remove a Data Type from project

   726     def ProjectRemoveDataType(self, datatype_name):

   727         if self.Project is not None:

   728             self.Project.removedataType(datatype_name)

   729             self.BufferProject()

   730     

   731     # Add a Pou to Project

   732     def ProjectAddPou(self, pou_name, pou_type, body_type):

   733         if self.Project is not None:

   734             # Add the pou to project

   735             self.Project.appendpou(pou_name, pou_type, body_type)

   736             if pou_type == "function":

   737                 self.SetPouInterfaceReturnType(pou_name, "BOOL")

   738             self.BufferProject()

   739             return self.ComputePouName(pou_name)

   740         return None

   741     

   742     def ProjectChangePouType(self, name, pou_type):

   743         if self.Project is not None:

   744             pou = self.Project.getpou(name)

   745             if pou is not None:

   746                 pou.setpouType(pou_type)

   747                 self.Project.RefreshCustomBlockTypes()

   748                 self.BufferProject()

   749                 

   750     def GetPouXml(self, pou_name):

   751         if self.Project is not None:

   752             pou = self.Project.getpou(pou_name)

   753             if pou is not None:

   754                 return pou.generateXMLText('pou', 0)

   755         return None

   756     

   757     def PastePou(self, pou_type, pou_xml):

   758         '''

   759         Adds the POU defined by 'pou_xml' to the current project with type 'pou_type'

   760         '''

   761         try:

   762             tree = minidom.parseString(pou_xml.encode("utf-8"))

   763             root = tree.childNodes[0]

   764         except:

   765             return _("Couldn't paste non-POU object.")

   766 

   767         if root.nodeName == "pou":

   768             new_pou = plcopen.pous_pou()

   769             new_pou.loadXMLTree(root)

   770 

   771             name = new_pou.getname()

   772             

   773             idx = 0

   774             new_name = name

   775             while self.Project.getpou(new_name):

   776                 # a POU with that name already exists.

   777                 # make a new name and test if a POU with that name exists.

   778                 # append an incrementing numeric suffix to the POU name.

   779                 idx += 1

   780                 new_name = "%s%d" % (name, idx)

   781                 

   782             # we've found a name that does not already exist, use it

   783             new_pou.setname(new_name)

   784             

   785             if pou_type is not None:

   786                 orig_type = new_pou.getpouType()

   787     

   788                 # prevent violations of POU content restrictions:

   789                 # function blocks cannot be pasted as functions,

   790                 # programs cannot be pasted as functions or function blocks

   791                 if orig_type == 'functionBlock' and pou_type == 'function' or \

   792                    orig_type == 'program' and pou_type in ['function', 'functionBlock']:

   793                     return _('''%s "%s" can't be pasted as a %s.''') % (orig_type, name, pou_type)

   794                 

   795                 new_pou.setpouType(pou_type)

   796 

   797             self.Project.insertpou(-1, new_pou)

   798             self.BufferProject()

   799             

   800             return self.ComputePouName(new_name),

   801         else:

   802             return _("Couldn't paste non-POU object.")

   803 

   804     # Remove a Pou from project

   805     def ProjectRemovePou(self, pou_name):

   806         if self.Project is not None:

   807             self.Project.removepou(pou_name)

   808             self.BufferProject()

   809     

   810     # Return the name of the configuration if only one exist

   811     def GetProjectMainConfigurationName(self):

   812         if self.Project is not None:

   813             # Found the configuration corresponding to old name and change its name to new name

   814             configurations = self.Project.getconfigurations()

   815             if len(configurations) == 1:

   816                 return configurations[0].getname()

   817         return None

   818                 

   819     # Add a configuration to Project

   820     def ProjectAddConfiguration(self, config_name=None):

   821         if self.Project is not None:

   822             if config_name is None:

   823                 config_name = self.GenerateNewName(None, None, "configuration%d")

   824             self.Project.addconfiguration(config_name)

   825             self.BufferProject()

   826             return self.ComputeConfigurationName(config_name)

   827         return None

   828     

   829     # Remove a configuration from project

   830     def ProjectRemoveConfiguration(self, config_name):

   831         if self.Project is not None:

   832             self.Project.removeconfiguration(config_name)

   833             self.BufferProject()

   834     

   835     # Add a resource to a configuration of the Project

   836     def ProjectAddConfigurationResource(self, config_name, resource_name=None):

   837         if self.Project is not None:

   838             if resource_name is None:

   839                 resource_name = self.GenerateNewName(None, None, "resource%d")

   840             self.Project.addconfigurationResource(config_name, resource_name)

   841             self.BufferProject()

   842             return self.ComputeConfigurationResourceName(config_name, resource_name)

   843         return None

   844     

   845     # Remove a resource from a configuration of the project

   846     def ProjectRemoveConfigurationResource(self, config_name, resource_name):

   847         if self.Project is not None:

   848             self.Project.removeconfigurationResource(config_name, resource_name)

   849             self.BufferProject()

   850     

   851     # Add a Transition to a Project Pou

   852     def ProjectAddPouTransition(self, pou_name, transition_name, transition_type):

   853         if self.Project is not None:

   854             pou = self.Project.getpou(pou_name)

   855             if pou is not None:

   856                 pou.addtransition(transition_name, transition_type)

   857                 self.BufferProject()

   858                 return self.ComputePouTransitionName(pou_name, transition_name)

   859         return None

   860     

   861     # Remove a Transition from a Project Pou

   862     def ProjectRemovePouTransition(self, pou_name, transition_name):

   863         # Search if the pou removed is currently opened

   864         if self.Project is not None:

   865             pou = self.Project.getpou(pou_name)

   866             if pou is not None:

   867                 pou.removetransition(transition_name)

   868                 self.BufferProject()

   869     

   870     # Add an Action to a Project Pou

   871     def ProjectAddPouAction(self, pou_name, action_name, action_type):

   872         if self.Project is not None:

   873             pou = self.Project.getpou(pou_name)

   874             if pou is not None:

   875                 pou.addaction(action_name, action_type)

   876                 self.BufferProject()

   877                 return self.ComputePouActionName(pou_name, action_name)

   878         return None

   879     

   880     # Remove an Action from a Project Pou

   881     def ProjectRemovePouAction(self, pou_name, action_name):

   882         # Search if the pou removed is currently opened

   883         if self.Project is not None:

   884             pou = self.Project.getpou(pou_name)

   885             if pou is not None:

   886                 pou.removeaction(action_name)

   887                 self.BufferProject()

   888     

   889     # Change the name of a pou

   890     def ChangeDataTypeName(self, old_name, new_name):

   891         if self.Project is not None:

   892             # Found the pou corresponding to old name and change its name to new name

   893             datatype = self.Project.getdataType(old_name)

   894             if datatype is not None:

   895                 datatype.setname(new_name)

   896                 self.Project.updateElementName(old_name, new_name)

   897                 self.Project.RefreshElementUsingTree()

   898                 self.Project.RefreshDataTypeHierarchy()

   899                 self.BufferProject()

   900     

   901     # Change the name of a pou

   902     def ChangePouName(self, old_name, new_name):

   903         if self.Project is not None:

   904             # Found the pou corresponding to old name and change its name to new name

   905             pou = self.Project.getpou(old_name)

   906             if pou is not None:

   907                 pou.setname(new_name)

   908                 self.Project.updateElementName(old_name, new_name)

   909                 self.Project.RefreshElementUsingTree()

   910                 self.Project.RefreshCustomBlockTypes()

   911                 self.BufferProject()

   912     

   913     # Change the name of a pou transition

   914     def ChangePouTransitionName(self, pou_name, old_name, new_name):

   915         if self.Project is not None:

   916             # Found the pou transition corresponding to old name and change its name to new name

   917             pou = self.Project.getpou(pou_name)

   918             if pou is not None:

   919                 transition = pou.gettransition(old_name)

   920                 if transition is not None:

   921                     transition.setname(new_name)

   922                     pou.updateElementName(old_name, new_name)

   923                     self.BufferProject()

   924     

   925     # Change the name of a pou action

   926     def ChangePouActionName(self, pou_name, old_name, new_name):

   927         if self.Project is not None:

   928             # Found the pou action corresponding to old name and change its name to new name

   929             pou = self.Project.getpou(pou_name)

   930             if pou is not None:

   931                 action = pou.getaction(old_name)

   932                 if action is not None:

   933                     action.setname(new_name)

   934                     pou.updateElementName(old_name, new_name)

   935                     self.BufferProject()

   936     

   937     # Change the name of a pou variable

   938     def ChangePouVariableName(self, pou_name, old_name, new_name):

   939         if self.Project is not None:

   940             # Found the pou action corresponding to old name and change its name to new name

   941             pou = self.Project.getpou(pou_name)

   942             if pou is not None:

   943                 for type, varlist in pou.getvars():

   944                     for var in varlist.getvariable():

   945                         if var.getname() == old_name:

   946                             var.setname(new_name)

   947                 self.Project.RefreshCustomBlockTypes()

   948                 self.BufferProject()

   949         

   950     # Change the name of a configuration

   951     def ChangeConfigurationName(self, old_name, new_name):

   952         if self.Project is not None:

   953             # Found the configuration corresponding to old name and change its name to new name

   954             configuration = self.Project.getconfiguration(old_name)

   955             if configuration is not None:

   956                 configuration.setname(new_name)

   957                 self.BufferProject()

   958     

   959     # Change the name of a configuration resource

   960     def ChangeConfigurationResourceName(self, config_name, old_name, new_name):

   961         if self.Project is not None:

   962             # Found the resource corresponding to old name and change its name to new name

   963             resource = self.Project.getconfigurationResource(config_name, old_name)

   964             if resource is not None:

   965                 resource.setname(new_name)

   966                 self.BufferProject()

   967     

   968     # Return the description of the pou given by its name

   969     def GetPouDescription(self, name, debug = False):

   970         project = self.GetProject(debug)

   971         if project is not None:

   972             # Found the pou correponding to name and return its type

   973             pou = project.getpou(name)

   974             if pou is not None:

   975                 return pou.getdescription()

   976         return ""

   977     

   978     # Return the description of the pou given by its name

   979     def SetPouDescription(self, name, description, debug = False):

   980         project = self.GetProject(debug)

   981         if project is not None:

   982             # Found the pou correponding to name and return its type

   983             pou = project.getpou(name)

   984             if pou is not None:

   985                 pou.setdescription(description)

   986                 project.RefreshCustomBlockTypes()

   987                 self.BufferProject()

   988     

   989     # Return the type of the pou given by its name

   990     def GetPouType(self, name, debug = False):

   991         project = self.GetProject(debug)

   992         if project is not None:

   993             # Found the pou correponding to name and return its type

   994             pou = project.getpou(name)

   995             if pou is not None:

   996                 return pou.getpouType()

   997         return None

   998     

   999     # Return pous with SFC language

  1000     def GetSFCPous(self, debug = False):

  1001         list = []

  1002         project = self.GetProject(debug)

  1003         if project is not None:

  1004             for pou in project.getpous():

  1005                 if pou.getBodyType() == "SFC":

  1006                     list.append(pou.getname())

  1007         return list

  1008     

  1009     # Return the body language of the pou given by its name

  1010     def GetPouBodyType(self, name, debug = False):

  1011         project = self.GetProject(debug)

  1012         if project is not None:

  1013             # Found the pou correponding to name and return its body language

  1014             pou = project.getpou(name)

  1015             if pou is not None:

  1016                 return pou.getbodyType()

  1017         return None

  1018     

  1019     # Return the actions of a pou

  1020     def GetPouTransitions(self, pou_name, debug = False):

  1021         transitions = []

  1022         project = self.GetProject(debug)

  1023         if project is not None:

  1024             # Found the pou correponding to name and return its transitions if SFC

  1025             pou = project.getpou(pou_name)

  1026             if pou is not None and pou.getbodyType() == "SFC":

  1027                 for transition in pou.gettransitionList():

  1028                     transitions.append(transition.getname())

  1029         return transitions

  1030     

  1031     # Return the body language of the transition given by its name

  1032     def GetTransitionBodyType(self, pou_name, pou_transition, debug = False):

  1033         project = self.GetProject(debug)

  1034         if project is not None:

  1035             # Found the pou correponding to name

  1036             pou = project.getpou(pou_name)

  1037             if pou is not None:

  1038                 # Found the pou transition correponding to name and return its body language

  1039                 transition = pou.gettransition(pou_transition)

  1040                 if transition is not None:

  1041                     return transition.getbodyType()

  1042         return None

  1043     

  1044     # Return the actions of a pou

  1045     def GetPouActions(self, pou_name, debug = False):

  1046         actions = []

  1047         project = self.GetProject(debug)

  1048         if project is not None:

  1049             # Found the pou correponding to name and return its actions if SFC

  1050             pou = project.getpou(pou_name)

  1051             if pou.getbodyType() == "SFC":

  1052                 for action in pou.getactionList():

  1053                     actions.append(action.getname())

  1054         return actions

  1055     

  1056     # Return the body language of the pou given by its name

  1057     def GetActionBodyType(self, pou_name, pou_action, debug = False):

  1058         project = self.GetProject(debug)

  1059         if project is not None:

  1060             # Found the pou correponding to name and return its body language

  1061             pou = project.getpou(pou_name)

  1062             if pou is not None:

  1063                 action = pou.getaction(pou_action)

  1064                 if action is not None:

  1065                     return action.getbodyType()

  1066         return None

  1067     

  1068     # Extract varlists from a list of vars

  1069     def ExtractVarLists(self, vars):

  1070         varlist_list = []

  1071         current_varlist = None

  1072         current_type = None

  1073         for var in vars:

  1074             next_type = (var["Class"], 

  1075                          var["Option"], 

  1076                          var["Location"] in ["", None] or 

  1077                          # When declaring globals, located 

  1078                          # and not located variables are 

  1079                          # in the same declaration block

  1080                          var["Class"] == "Global")

  1081             if current_type != next_type:

  1082                 current_type = next_type

  1083                 infos = VAR_CLASS_INFOS.get(var["Class"], None)

  1084                 if infos is not None:

  1085                     current_varlist = infos[0]()

  1086                 else:

  1087                     current_varlist = plcopen.varList()

  1088                 varlist_list.append((var["Class"], current_varlist))

  1089                 if var["Option"] == "Constant":

  1090                     current_varlist.setconstant(True)

  1091                 elif var["Option"] == "Retain":

  1092                     current_varlist.setretain(True)

  1093                 elif var["Option"] == "Non-Retain":

  1094                     current_varlist.setnonretain(True)

  1095             # Create variable and change its properties

  1096             tempvar = plcopen.varListPlain_variable()

  1097             tempvar.setname(var["Name"])

  1098             

  1099             var_type = plcopen.dataType()

  1100             if isinstance(var["Type"], TupleType):

  1101                 if var["Type"][0] == "array":

  1102                     array_type, base_type_name, dimensions = var["Type"]

  1103                     array = plcopen.derivedTypes_array()

  1104                     for i, dimension in enumerate(dimensions):

  1105                         dimension_range = plcopen.rangeSigned()

  1106                         dimension_range.setlower(dimension[0])

  1107                         dimension_range.setupper(dimension[1])

  1108                         if i == 0:

  1109                             array.setdimension([dimension_range])

  1110                         else:

  1111                             array.appenddimension(dimension_range)

  1112                     if base_type_name in self.GetBaseTypes():

  1113                         if base_type_name == "STRING":

  1114                             array.baseType.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})

  1115                         elif base_type_name == "WSTRING":

  1116                             array.baseType.setcontent({"name" : "wstring", "value" : plcopen.wstring()})

  1117                         else:

  1118                             array.baseType.setcontent({"name" : base_type_name, "value" : None})

  1119                     else:

  1120                         derived_datatype = plcopen.derivedTypes_derived()

  1121                         derived_datatype.setname(base_type_name)

  1122                         array.baseType.setcontent({"name" : "derived", "value" : derived_datatype})

  1123                     var_type.setcontent({"name" : "array", "value" : array})

  1124             elif var["Type"] in self.GetBaseTypes():

  1125                 if var["Type"] == "STRING":

  1126                     var_type.setcontent({"name" : "string", "value" : plcopen.elementaryTypes_string()})

  1127                 elif var["Type"] == "WSTRING":

  1128                     var_type.setcontent({"name" : "wstring", "value" : plcopen.elementaryTypes_wstring()})

  1129                 else:

  1130                     var_type.setcontent({"name" : var["Type"], "value" : None})

  1131             else:

  1132                 derived_type = plcopen.derivedTypes_derived()

  1133                 derived_type.setname(var["Type"])

  1134                 var_type.setcontent({"name" : "derived", "value" : derived_type})

  1135             tempvar.settype(var_type)

  1136