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

                Function_decl_list = []

   197

            if Current_section:

   198

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

   199

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

   200

                Function_decl["baseinputnumber"] = baseinputnumber

   201

                for param, value in Function_decl.iteritems():

   202

                    if param in translate:

   203

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

   204

                Function_decl["type"] = "function"

   205

   206

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

   207

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

   208

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

   209

                else:

   210

                    input_ovrloading_types = [None]

   211

                    output_types = [None]

   212

   213

                funcdeclname_orig = Function_decl["name"]

   214

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

   215

                fdc = Function_decl["inputs"][:]

   216

                for intype in input_ovrloading_types:

   217

                    if intype is not None:

   218

                        Function_decl["inputs"] = []

   219

                        for decl_tpl in fdc:

   220

                            if IsOfType(intype, decl_tpl[1]):

   221

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

   222

                            else:

   223

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

   224

   225

                            if funcdeclname_orig.startswith('*'):

   226

                                funcdeclin = intype + '_' + funcdeclname

   227

                            else:

   228

                                funcdeclin = funcdeclname

   229

                    else:

   230

                        funcdeclin = funcdeclname

   231

   232

                    for outype in output_types:

   233

                        if outype is not None:

   234

                            decl_tpl = Function_decl["outputs"][0]

   235

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

   236

                            if funcdeclname_orig.endswith('*'):

   237

                                funcdeclout = funcdeclin + '_' + outype

   238

                            else:

   239

                                funcdeclout = funcdeclin

   240

                        else:

   241

                            funcdeclout = funcdeclin

   242

                        Function_decl["name"] = funcdeclout

   243

   244

                        # apply filter given in "filter" column

   245

                        filter_name = Function_decl["filter"]

   246

                        store = True

   247

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

   248

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

   249

                                          map(lambda testtype: IsOfType(

   250

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

   251

                                              testtype), OutTypes))

   252

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

   253

                                          map(lambda testtype: IsOfType(

   254

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

   255

                                              testtype), InTypes))

   256

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

   257

                                store = True

   258

                                break

   259

                            else:

   260

                                store = False

   261

                        if store:

   262

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

   263

                            Function_decl_copy = Function_decl.copy()

   264

                            Current_section["list"].append(Function_decl_copy)

   265

            else:

   266

                raise "First function must be in a category"

   267

   268

    return Standard_Functions_Decl

   269

   270

   271

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

   272

   273

# Dictionary to speedup block type fetching by name

   274

StdBlckDct = OrderedDict()

   275

   276

for section in StdBlckLst:

   277

    for desc in section["list"]:

   278

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

   279

        if len(words) > 1:

   280

            desc["comment"] = words[1]

   281

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

   282

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

   283

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

   284

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

   285

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

   286

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

   287

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

   288

   289

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

   290

#                            Languages Keywords

   291

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

   292

   293

# Keywords for Pou Declaration

   294

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

   295

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

   296

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

   297

for category in StdBlckLst:

   298

    for block in category["list"]:

   299

        if block["name"] not in POU_KEYWORDS:

   300

            POU_KEYWORDS.append(block["name"])

   301

   302

   303

# Keywords for Type Declaration

   304

TYPE_BLOCK_START_KEYWORDS = ["TYPE", "STRUCT"]

   305

TYPE_BLOCK_END_KEYWORDS = ["END_TYPE", "END_STRUCT"]

   306

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

   307

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

   308

   309

   310

# Keywords for Variable Declaration

   311

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

   312

VAR_BLOCK_END_KEYWORDS = ["END_VAR"]

   313

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

   314

   315

   316

# Keywords for Configuration Declaration

   317

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

   318

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

   319

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

   320

   321

# Keywords for Structured Function Chart

   322

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

   323

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

   324

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

   325

   326

   327

# Keywords for Instruction List

   328

IL_KEYWORDS = [

   329

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

   330

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

   331

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

   332

]

   333

   334

   335

# Keywords for Structured Text

   336

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

   337

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

   338

ST_KEYWORDS = [

   339

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

   340

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

   341

] + ST_BLOCK_START_KEYWORDS + ST_BLOCK_END_KEYWORDS

   342

   343

# All the keywords of IEC

   344

IEC_BLOCK_START_KEYWORDS = []

   345

IEC_BLOCK_END_KEYWORDS = []

   346

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

   347

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

   348

                                                                VAR_BLOCK_START_KEYWORDS, CONFIG_BLOCK_START_KEYWORDS,

   349

                                                                SFC_BLOCK_START_KEYWORDS, ST_BLOCK_START_KEYWORDS]),

   350

                                    (IEC_BLOCK_END_KEYWORDS, [POU_BLOCK_END_KEYWORDS, TYPE_BLOCK_END_KEYWORDS,

   351

                                                              VAR_BLOCK_END_KEYWORDS, CONFIG_BLOCK_END_KEYWORDS,

   352

                                                              SFC_BLOCK_END_KEYWORDS, ST_BLOCK_END_KEYWORDS]),

   353

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

   354

                                                    SFC_KEYWORDS, IL_KEYWORDS, ST_KEYWORDS])]:

   355

    for keywords in keywords_list:

   356

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