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

#

     9

# See COPYING file for copyrights details.

    10

#

    11

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

    12

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

    13

# as published by the Free Software Foundation; either version 2

    14

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

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

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

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import string

    26

import re

    27

from collections import OrderedDict

    28

    29

from plcopen import LoadProject

    30

from definitions import *

    31

    32

TypeHierarchy = dict(TypeHierarchy_list)

    33

    34

    35

def IsOfType(type, reference):

    36

    """

    37

    Returns true if the given data type is the same that "reference" meta-type or one of its types.

    38

    """

    39

    if reference is None:

    40

        return True

    41

    elif type == reference:

    42

        return True

    43

    else:

    44

        parent_type = TypeHierarchy[type]

    45

        if parent_type is not None:

    46

            return IsOfType(parent_type, reference)

    47

    return False

    48

    49

    50

def GetSubTypes(type):

    51

    """

    52

    Returns list of all types that correspont to the ANY* meta type

    53

    """

    54

    return [typename for typename, _parenttype in TypeHierarchy.items() if not typename.startswith("ANY") and IsOfType(typename, type)]

    55

    56

    57

DataTypeRange = dict(DataTypeRange_list)

    58

    59

"""

    60

Ordered list of common Function Blocks defined in the IEC 61131-3

    61

Each block have this attributes:

    62

    - "name" : The block name

    63

    - "type" : The block type. It can be "function", "functionBlock" or "program"

    64

    - "extensible" : Boolean that define if the block is extensible

    65

    - "inputs" : List of the block inputs

    66

    - "outputs" : List of the block outputs

    67

    - "comment" : Comment that will be displayed in the block popup

    68

    - "generate" : Method that generator will call for generating ST block code

    69

Inputs and outputs are a tuple of characteristics that are in order:

    70

    - The name

    71

    - The data type

    72

    - The default modifier which can be "none", "negated", "rising" or "falling"

    73

"""

    74

    75

StdBlckLibs = {libname: LoadProject(tc6fname)[0]

    76

               for libname, tc6fname in StdTC6Libs}

    77

StdBlckLst = [{"name": libname, "list":

    78

               [GetBlockInfos(pous) for pous in lib.getpous()]}

    79

              for libname, lib in StdBlckLibs.iteritems()]

    80

    81

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

    82

#                             Test identifier

    83

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

    84

    85

IDENTIFIER_MODEL = re.compile(

    86

    "(?:%(letter)s|_(?:%(letter)s|%(digit)s))(?:_?(?:%(letter)s|%(digit)s))*$" %

    87

    {"letter": "[a-zA-Z]", "digit": "[0-9]"})

    88

    89

    90

def TestIdentifier(identifier):

    91

    """

    92

    Test if identifier is valid

    93

    """

    94

    return IDENTIFIER_MODEL.match(identifier) is not None

    95

    96

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

    97

#                        Standard functions list generation

    98

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

    99

   100

   101

def csv_file_to_table(file):

   102

    """

   103

    take a .csv file and translate it it a "csv_table"

   104

    """

   105

    return [map(string.strip, line.split(';')) for line in file.xreadlines()]

   106

   107

   108

def find_section(section_name, table):

   109

    """

   110

    seek into the csv table to a section ( section_name match 1st field )

   111

    return the matching row without first field

   112

    """

   113

    fields = [None]

   114

    while fields[0] != section_name:

   115

        fields = table.pop(0)

   116

    return fields[1:]

   117

   118

   119

def get_standard_funtions_input_variables(table):

   120

    """

   121

    extract the standard functions standard parameter names and types...

   122

    return a { ParameterName: Type, ...}

   123

    """

   124

    variables = find_section("Standard_functions_variables_types", table)

   125

    standard_funtions_input_variables = {}

   126

    fields = [True, True]

   127

    while fields[1]:

   128

        fields = table.pop(0)

   129

        variable_from_csv = dict([(champ, val) for champ, val in zip(variables, fields[1:]) if champ != ''])

   130

        standard_funtions_input_variables[variable_from_csv['name']] = variable_from_csv['type']

   131

    return standard_funtions_input_variables

   132

   133

   134

def csv_input_translate(str_decl, variables, base):

   135

    """

   136

    translate .csv file input declaration into PLCOpenEditor interessting values

   137

    in : "(ANY_NUM, ANY_NUM)" and { ParameterName: Type, ...}

   138

    return [("IN1","ANY_NUM","none"),("IN2","ANY_NUM","none")]

   139

    """

   140

    decl = str_decl.replace('(', '').replace(')', '').replace(' ', '').split(',')

   141

    params = []

   142

   143

    len_of_not_predifined_variable = len([True for param_type in decl if param_type not in variables])

   144

   145

    for param_type in decl:

   146

        if param_type in variables.keys():

   147

            param_name = param_type

   148

            param_type = variables[param_type]

   149

        elif len_of_not_predifined_variable > 1:

   150

            param_name = "IN%d" % base

   151

            base += 1

   152

        else:

   153

            param_name = "IN"

   154

        params.append((param_name, param_type, "none"))

   155

    return params

   156

   157

   158

def get_standard_funtions(table):

   159

    """

   160

    Returns this kind of declaration for all standard functions

   161

   162

            [{"name" : "Numerical", 'list': [   {

   163

                'baseinputnumber': 1,

   164

                'comment': 'Addition',

   165

                'extensible': True,

   166

                'inputs': [   ('IN1', 'ANY_NUM', 'none'),

   167

                              ('IN2', 'ANY_NUM', 'none')],

   168

                'name': 'ADD',

   169

                'outputs': [('OUT', 'ANY_NUM', 'none')],

   170

                'type': 'function'}, ...... ] },.....]

   171

    """

   172

   173

    variables = get_standard_funtions_input_variables(table)

   174

   175

    fonctions = find_section("Standard_functions_type", table)

   176

   177

    Standard_Functions_Decl = []

   178

    Current_section = None

   179

   180

    translate = {

   181

            "extensible": lambda x: {"yes": True, "no": False}[x],

   182

            "inputs": lambda x: csv_input_translate(x, variables, baseinputnumber),

   183

            "outputs": lambda x: [("OUT", x, "none")]}

   184

   185

    for fields in table:

   186

        if fields[1]:

   187

            # If function section name given

   188

            if fields[0]:

   189

                words = fields[0].split('"')

   190

                if len(words) > 1:

   191

                    section_name = words[1]

   192

                else:

   193

                    section_name = fields[0]

   194

                Current_section = {"name": section_name, "list": []}

   195

                Standard_Functions_Decl.append(Current_section)

   196

            if Current_section:

   197

                Function_decl = dict([(champ, val) for champ, val in zip(fonctions, fields[1:]) if champ])

   198

                baseinputnumber = int(Function_decl.get("baseinputnumber", 1))

   199

                Function_decl["baseinputnumber"] = baseinputnumber

   200

                for param, value in Function_decl.iteritems():

   201

                    if param in translate:

   202

                        Function_decl[param] = translate[param](value)

   203

                Function_decl["type"] = "function"

   204

   205

                if Function_decl["name"].startswith('*') or Function_decl["name"].endswith('*'):

   206

                    input_ovrloading_types = GetSubTypes(Function_decl["inputs"][0][1])

   207

                    output_types = GetSubTypes(Function_decl["outputs"][0][1])

   208

                else:

   209

                    input_ovrloading_types = [None]

   210

                    output_types = [None]

   211

   212

                funcdeclname_orig = Function_decl["name"]

   213

                funcdeclname = Function_decl["name"].strip('*_')

   214

                fdc = Function_decl["inputs"][:]

   215

                for intype in input_ovrloading_types:

   216

                    if intype is not None:

   217

                        Function_decl["inputs"] = []

   218

                        for decl_tpl in fdc:

   219

                            if IsOfType(intype, decl_tpl[1]):

   220

                                Function_decl["inputs"] += [(decl_tpl[0], intype, decl_tpl[2])]

   221

                            else:

   222

                                Function_decl["inputs"] += [(decl_tpl)]

   223

   224

                            if funcdeclname_orig.startswith('*'):

   225

                                funcdeclin = intype + '_' + funcdeclname

   226

                            else:

   227

                                funcdeclin = funcdeclname

   228

                    else:

   229

                        funcdeclin = funcdeclname

   230

   231

                    for outype in output_types:

   232

                        if outype is not None:

   233

                            decl_tpl = Function_decl["outputs"][0]

   234

                            Function_decl["outputs"] = [(decl_tpl[0], outype,  decl_tpl[2])]

   235

                            if funcdeclname_orig.endswith('*'):

   236

                                funcdeclout = funcdeclin + '_' + outype

   237

                            else:

   238

                                funcdeclout = funcdeclin

   239

                        else:

   240

                            funcdeclout = funcdeclin

   241

                        Function_decl["name"] = funcdeclout

   242

   243

                        # apply filter given in "filter" column

   244

                        filter_name = Function_decl["filter"]

   245

                        store = True

   246

                        for (InTypes, OutTypes) in ANY_TO_ANY_FILTERS.get(filter_name, []):

   247

                            outs = reduce(lambda a, b: a or b,

   248

                                          map(lambda testtype: IsOfType(

   249

                                              Function_decl["outputs"][0][1],

   250

                                              testtype), OutTypes))

   251

                            inps = reduce(lambda a, b: a or b,

   252

                                          map(lambda testtype: IsOfType(

   253

                                              Function_decl["inputs"][0][1],

   254

                                              testtype), InTypes))

   255

                            if inps and outs and Function_decl["outputs"][0][1] != Function_decl["inputs"][0][1]:

   256

                                store = True

   257

                                break

   258

                            else:

   259

                                store = False

   260

                        if store:

   261

                            # create the copy of decl dict to be appended to section

   262

                            Function_decl_copy = Function_decl.copy()

   263

                            Current_section["list"].append(Function_decl_copy)

   264

            else:

   265

                raise "First function must be in a category"

   266

   267

    return Standard_Functions_Decl

   268

   269

   270

StdBlckLst.extend(get_standard_funtions(csv_file_to_table(open(StdFuncsCSV))))

   271

   272

# Dictionary to speedup block type fetching by name

   273

StdBlckDct = OrderedDict()

   274

   275

for section in StdBlckLst:

   276

    for desc in section["list"]:

   277

        words = desc["comment"].split('"')

   278

        if len(words) > 1:

   279

            desc["comment"] = words[1]

   280

        desc["usage"] = ("\n (%s) => (%s)" %

   281

                         (", ".join(["%s:%s" % (input[1], input[0])

   282

                                     for input in desc["inputs"]]),

   283

                          ", ".join(["%s:%s" % (output[1], output[0])

   284

                                     for output in desc["outputs"]])))

   285

        BlkLst = StdBlckDct.setdefault(desc["name"], [])

   286

        BlkLst.append((section["name"], desc))

   287

   288

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

   289

#                            Languages Keywords

   290

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

   291

   292

# Keywords for Pou Declaration

   293

POU_BLOCK_START_KEYWORDS = ["FUNCTION", "FUNCTION_BLOCK", "PROGRAM"]

   294

POU_BLOCK_END_KEYWORDS = ["END_FUNCTION", "END_FUNCTION_BLOCK", "END_PROGRAM"]

   295

POU_KEYWORDS = ["EN", "ENO", "F_EDGE", "R_EDGE"] + POU_BLOCK_START_KEYWORDS + POU_BLOCK_END_KEYWORDS

   296

for category in StdBlckLst:

   297

    for block in category["list"]:

   298

        if block["name"] not in POU_KEYWORDS:

   299

            POU_KEYWORDS.append(block["name"])

   300

   301

   302

# Keywords for Type Declaration

   303

TYPE_BLOCK_START_KEYWORDS = ["TYPE", "STRUCT"]

   304

TYPE_BLOCK_END_KEYWORDS = ["END_TYPE", "END_STRUCT"]

   305

TYPE_KEYWORDS = ["ARRAY", "OF", "T", "D", "TIME_OF_DAY", "DATE_AND_TIME"] + TYPE_BLOCK_START_KEYWORDS + TYPE_BLOCK_END_KEYWORDS

   306

TYPE_KEYWORDS.extend([keyword for keyword in TypeHierarchy.keys() if keyword not in TYPE_KEYWORDS])

   307

   308

   309

# Keywords for Variable Declaration

   310

VAR_BLOCK_START_KEYWORDS = ["VAR", "VAR_INPUT", "VAR_OUTPUT", "VAR_IN_OUT", "VAR_TEMP", "VAR_EXTERNAL"]

   311

VAR_BLOCK_END_KEYWORDS = ["END_VAR"]

   312

VAR_KEYWORDS = ["AT", "CONSTANT", "RETAIN", "NON_RETAIN"] + VAR_BLOCK_START_KEYWORDS + VAR_BLOCK_END_KEYWORDS

   313

   314

   315

# Keywords for Configuration Declaration

   316

CONFIG_BLOCK_START_KEYWORDS = ["CONFIGURATION", "RESOURCE", "VAR_ACCESS", "VAR_CONFIG", "VAR_GLOBAL"]

   317

CONFIG_BLOCK_END_KEYWORDS = ["END_CONFIGURATION", "END_RESOURCE", "END_VAR"]

   318

CONFIG_KEYWORDS = ["ON", "PROGRAM", "WITH", "READ_ONLY", "READ_WRITE", "TASK"] + CONFIG_BLOCK_START_KEYWORDS + CONFIG_BLOCK_END_KEYWORDS

   319

   320

# Keywords for Structured Function Chart

   321

SFC_BLOCK_START_KEYWORDS = ["ACTION", "INITIAL_STEP", "STEP", "TRANSITION"]

   322

SFC_BLOCK_END_KEYWORDS = ["END_ACTION", "END_STEP", "END_TRANSITION"]

   323

SFC_KEYWORDS = ["FROM", "TO"] + SFC_BLOCK_START_KEYWORDS + SFC_BLOCK_END_KEYWORDS

   324

   325

   326

# Keywords for Instruction List

   327

IL_KEYWORDS = [

   328

    "TRUE", "FALSE", "LD", "LDN", "ST", "STN", "S", "R", "AND", "ANDN", "OR", "ORN",

   329

    "XOR", "XORN", "NOT", "ADD", "SUB", "MUL", "DIV", "MOD", "GT", "GE", "EQ", "NE",

   330

    "LE", "LT", "JMP", "JMPC", "JMPCN", "CAL", "CALC", "CALCN", "RET", "RETC", "RETCN"

   331

]

   332

   333

   334

# Keywords for Structured Text

   335

ST_BLOCK_START_KEYWORDS = ["IF", "ELSIF", "ELSE", "CASE", "FOR", "WHILE", "REPEAT"]

   336

ST_BLOCK_END_KEYWORDS = ["END_IF", "END_CASE", "END_FOR", "END_WHILE", "END_REPEAT"]

   337

ST_KEYWORDS = [

   338

    "TRUE", "FALSE", "THEN", "OF", "TO", "BY", "DO", "DO", "UNTIL", "EXIT",

   339

    "RETURN", "NOT", "MOD", "AND", "XOR", "OR"

   340

] + ST_BLOCK_START_KEYWORDS + ST_BLOCK_END_KEYWORDS

   341

   342

# All the keywords of IEC

   343

IEC_BLOCK_START_KEYWORDS = []

   344

IEC_BLOCK_END_KEYWORDS = []

   345

IEC_KEYWORDS = ["E", "TRUE", "FALSE"]

   346

for all_keywords, keywords_list in [(IEC_BLOCK_START_KEYWORDS, [POU_BLOCK_START_KEYWORDS, TYPE_BLOCK_START_KEYWORDS,

   347

                                                                VAR_BLOCK_START_KEYWORDS, CONFIG_BLOCK_START_KEYWORDS,

   348

                                                                SFC_BLOCK_START_KEYWORDS, ST_BLOCK_START_KEYWORDS]),

   349

                                    (IEC_BLOCK_END_KEYWORDS, [POU_BLOCK_END_KEYWORDS, TYPE_BLOCK_END_KEYWORDS,

   350

                                                              VAR_BLOCK_END_KEYWORDS, CONFIG_BLOCK_END_KEYWORDS,

   351

                                                              SFC_BLOCK_END_KEYWORDS, ST_BLOCK_END_KEYWORDS]),

   352

                                    (IEC_KEYWORDS, [POU_KEYWORDS, TYPE_KEYWORDS, VAR_KEYWORDS, CONFIG_KEYWORDS,

   353

                                                    SFC_KEYWORDS, IL_KEYWORDS, ST_KEYWORDS])]:

   354

    for keywords in keywords_list:

   355

        all_keywords.extend([keyword for keyword in keywords if keyword not in all_keywords])