1

"""

     2

     3

 THIS CODE GENARATES C++ CODE FOR IEC2CC COMPILER

     4

 GENERATED CODE IS :

     5

     6

function_type_decl.h - the long enumeration of std function types

     7

get_function_type_decl.c - the funct that return enumerated according function name

     8

st_code_gen.c - part of generate_cc_st_c::visit(function_invocation)

     9

                responsible to generate C code for std lib calls

    10

il_code_gen.c - part of generate_cc_il_c::visit(il_function_call)

    11

                responsible to generate C code for std lib calls

    12

search_type_code.c - called by search_expression_type_c::visit(function_invocation) 

    13

                     return type symbol for std function invocation

    14

    15

"""

    16

    17

# Get definitions

    18

from plcopen.structures import *

    19

    20

#import pprint

    21

#pp = pprint.PrettyPrinter(indent=4)

    22

    23

def ANY_to_compiler_test_type_GEN(typename, paramname):

    24

    """

    25

    Convert ANY_XXX IEC type declaration into IEC2CC's generated type test.

    26

    This tests are defined in search_expression_type.cc 

    27

    """

    28

    return {"ANY" : "",

    29

    "ANY_BIT" : "if(search_expression_type->is_binary_type(%(paramname)s_type_symbol))",

    30

    "ANY_NBIT" : "if(search_expression_type->is_nbinary_type(%(paramname)s_type_symbol))",

    31

    "ANY_NUM" : "if(search_expression_type->is_num_type(%(paramname)s_type_symbol))",

    32

    "ANY_REAL" : "if(search_expression_type->is_real_type(%(paramname)s_type_symbol))",

    33

    "ANY_INT" : "if(search_expression_type->is_integer_type(%(paramname)s_type_symbol))"

    34

    }.get(typename,

    37

                "paramname" : paramname, "typename": typename.lower()}

    38

    39

def recurse_and_indent(fdecls, indent, do_type_search_only = False, do_il = False):

    40

    """

    41

    This function generate visit(function_invocation) code for 

    42

        - ST code generator

    43

        - IL code generator

    44

        - search_expression_type class for ST

    45

        - search_expression_type class for IL

    46

    47

    Input data is a 

    48

    "{fname : {IN[0]paramname : {IN[0]paramtype : {IN[1]paraname : {IN[1]paramtype : {... : {IN[N]paraname : {IN[N]paramtype : (fdecl,)}}}}}}"

    49

    nested dictionary structure.

    50

    """

    51

    if type(fdecls) != type(tuple()):

    52

        res = ""

    53

        for Paramname, ParamTypes in fdecls.iteritems():

    54

            if do_il:

    55

                res += """

    56

{"""

    57

                if not do_type_search_only:

    58

                    res += """

    59

    /* Get the value from a foo(<param_name> = <param_value>) style call */

    60

    symbol_c *%(input_name)s_param_value = &this->default_variable_name;

    61

"""%{"input_name":Paramname}

    62

                res += """

    63

    symbol_c *%(input_name)s_type_symbol = param_data_type;

    64

    last_type_symbol = param_data_type;

    65

"""%{"input_name":Paramname}

    66

            else:

    67

                res += """

    68

{

    69

    identifier_c param_name("%(input_name)s");

    70

    /* Get the value from a foo(<param_name> = <param_value>) style call */

    71

    symbol_c *%(input_name)s_param_value = function_call_param_iterator.search(&param_name);

    72

    73

    /* Get the value from a foo(<param_value>) style call */

    74

    if (%(input_name)s_param_value == NULL)

    75

      %(input_name)s_param_value = function_call_param_iterator.next();

    76

    symbol_c *%(input_name)s_type_symbol = search_expression_type->get_type(%(input_name)s_param_value);

    77

    last_type_symbol = last_type_symbol && search_expression_type->is_same_type(%(input_name)s_type_symbol, last_type_symbol) ? search_expression_type->common_type(%(input_name)s_type_symbol, last_type_symbol) : %(input_name)s_type_symbol ;

    78

"""%{"input_name":Paramname}

    79

    80

            for ParamType,NextParamDecl in ParamTypes.iteritems():

    81

    82

                res += """    

    83

    %(type_test)s

    84

    {

    85

%(if_good_type_code)s

    86

    }

    87

"""%{

    88

    "type_test":ANY_to_compiler_test_type_GEN(ParamType,Paramname), 

    89

    "if_good_type_code":recurse_and_indent(NextParamDecl,indent,do_type_search_only).replace('\n','\n    ')}

    90

    91

            res += """    

    92

    ERROR;

    93

}

    94

"""

    95

    96

        return res.replace('\n','\n'+indent)

    97

    else:

    98

        res = "\n"

    99

        fdecl=fdecls[0]

   100

   101

        result_type_rule = fdecl["return_type_rule"]

   102

        res += {

   103

            "copy_input" : "symbol_c * return_type_symbol = last_type_symbol;\n",

   104

            "defined" : "symbol_c * return_type_symbol = &search_constant_type_c::%s_type_name;\n"%fdecl["outputs"][0][1].lower(),

   105

            }.get(result_type_rule, "symbol_c * return_type_symbol = %s;\n"%result_type_rule)

   106

   107

        if not do_type_search_only:

   108

            code_gen = eval(fdecl["python_eval_c_code_format"])

   109

   110

            code_gen_dic_decl = {}

   111

            for paramname,paramtype,unused in fdecl["inputs"]:

   112

                code_gen_dic_decl[paramname+"_value"] = '");\n%s_param_value->accept(*this);\ns4o.print("'%(paramname)

   113

                code_gen_dic_decl[paramname+"_type"] = '");\n%s_type_symbol->accept(*this);\ns4o.print("'%(paramname)

   114

            code_gen_dic_decl["return_type"] = '");\nreturn_type_symbol->accept(*this);\ns4o.print("'

   115

            code_gen_dic_decl["param_count"] = '");\ns4o.print_integer(nb_param);\ns4o.print("'

   116

            code_gen_dic_decl["start_bool_filter"] = '");\nif (search_expression_type->is_bool_type(last_type_symbol))\n  s4o.print("('

   117

            code_gen_dic_decl["end_bool_filter"] = '");\nif (search_expression_type->is_bool_type(last_type_symbol)) {\n  s4o.print("&1");\n  s4o.print(")");\n}\ns4o.print("'

   118

   119

            if type(code_gen) == type(tuple()):

   122

                static_param_accept_list = []

   123

                for paramname,paramtype,unused in fdecl["inputs"]:

   124

                    static_param_accept_list.append("%s_param_value->accept(*this);\n"%(paramname))

   128

            else:

   129

                code = ''

   130

                end_code = ('s4o.print("' + code_gen%code_gen_dic_decl + '");\nreturn NULL;\n').replace('s4o.print("");\n','')

   131

   132

            if fdecl["extensible"]:

   133

                res += ("""

   134

int base_num = %d;

   135

symbol_c *param_value = NULL;

   136

do{

   137

    char my_name[10];

   138

    sprintf(my_name, "IN%%d", base_num++);

   139

    identifier_c param_name(my_name);

   140

   141

    /* Get the value from a foo(<param_name> = <param_value>) style call */

   142

    param_value = function_call_param_iterator.search(&param_name);

   143

   144

    /* Get the value from a foo(<param_value>) style call */

   145

    if (param_value == NULL)

   146

      param_value = function_call_param_iterator.next();

   147

    if (param_value != NULL){

   148

        symbol_c *current_type_symbol = search_expression_type->get_type(param_value);

   149

        last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ;

   150

   151

        /*Function specific CODE */

   152

        %s

   153

    }

   154

   155

}while(param_value != NULL);

   156

%s

   157

"""%(fdecl["baseinputnumber"]+2, code.replace('\n','\n        '), end_code))

   158

            else:

   159

                #res += code + end_code

   160

                res += end_code

   161

        else:

   162

            res += "return return_type_symbol;\n"

   163

   164

   165

        return res.replace('\n','\n'+indent)

   166

   167

###################################################################

   168

###                                                             ###

   169

###                           MAIN                              ###

   170

###                                                             ###

   171

###################################################################

   172

   173

"""

   174

Reorganize std_decl from structure.py

   175

into a nested dictionnary structure (i.e. a tree):

   176

"{fname : {IN[0]paramname : {IN[0]paramtype : {IN[1]paraname : {IN[1]paramtype : {... : {IN[N]paraname : {IN[N]paramtype : (fdecl,)}}}}}}"

   177

Keep ptrack of original declaration order in a 

   178

separated list called official_order

   179

"""

   180

std_fdecls = {}

   181

official_order = []

   182

for section in std_decl:

   183

    for fdecl in section["list"]:

   184

        if len(official_order)==0 or official_order[-1] != fdecl["name"]:

   185

            official_order.append(fdecl["name"])

   186

        # store all func by name in a dict

   187

        std_fdecls_fdecl_name = std_fdecls.get(fdecl["name"], {})

   188

        current = std_fdecls_fdecl_name

   189

        for i in fdecl["inputs"]:

   190

            current[i[0]] = current.get(i[0], {})

   191

            current = current[i[0]]

   192

            last = current

   193

            current[i[1]] = current.get(i[1], {})

   194

            current = current[i[1]]

   195

        last[i[1]]=(fdecl,)

   196

        std_fdecls[fdecl["name"]] = std_fdecls_fdecl_name

   197

   198

###################################################################

   199

   200

"""

   201

Generate the long enumeration of std function types

   202

"""

   203

function_type_decl =  """

   204

/****

   205

 * IEC 61131-3 standard function lib

   206

 * generated code, do not edit by hand

   207

 */

   208

typedef enum {

   209

"""

   210

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   211

    function_type_decl += "    function_"+fname.lower()+",\n"

   212

   213

function_type_decl += """    function_none

   214

} function_type_t;

   215

"""

   216

###################################################################

   217

"""

   218

Generate the funct that return enumerated according function name

   219

"""

   220

get_function_type_decl = """

   221

/****

   222

 * IEC 61131-3 standard function lib

   223

 * generated code, do not edit by hand

   224

 */

   225

function_type_t get_function_type(identifier_c *function_name) {

   226

"""

   227

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   228

    get_function_type_decl += """

   229

if (!strcasecmp(function_name->value, "%s"))

   230

    return function_%s;

   231

"""%(fname,fname.lower())

   232

   233

get_function_type_decl += """

   234

    else return function_none;

   235

}

   236

   237

"""

   238

###################################################################

   239

"""

   240

Generate the part of generate_cc_st_c::visit(function_invocation)

   241

that is responsible to generate C code for std lib calls.

   242

"""

   243

st_code_gen = """

   244

/****

   245

 * IEC 61131-3 standard function lib

   246

 * generated code, do not edit by hand

   247

 */

   248

switch(current_function_type){

   249

"""

   250

   251

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   252

    st_code_gen += """

   253

/****

   254

 *%s

   255

 */

   256

    case function_%s :

   257

    {

   258

        symbol_c *last_type_symbol = NULL;

   259

"""    %(fname, fname.lower())

   260

    indent =  "    "

   261

   262

    st_code_gen += recurse_and_indent(fdecls, indent).replace('\n','\n    ')

   263

   264

    st_code_gen += """

   265

    }/*function_%s*/

   266

    break;

   267

"""    %(fname.lower())

   268

st_code_gen +=  """

   269

    case function_none :

   270

    ERROR;

   271

}

   272

return NULL;

   273

"""

   274

   275

###################################################################

   276

"""

   277

Generate the part of generate_cc_il_c::visit(il_function_call)

   278

that is responsible to generate C code for std lib calls.

   279

"""

   280

il_code_gen = """

   281

/****

   282

 * IEC 61131-3 standard function lib

   283

 * generated code, do not edit by hand

   284

 */

   285

switch(current_function_type){

   286

"""

   287

   288

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   289

    il_code_gen += """

   290

/****

   291

 *%s

   292

 */

   293

    case function_%s :

   294

    {

   295

        symbol_c *last_type_symbol = NULL;

   296

"""    %(fname, fname.lower())

   297

    indent =  "    "

   298

   299

    il_code_gen += recurse_and_indent(fdecls, indent, do_il=True).replace('\n','\n    ')

   300

   301

    il_code_gen += """

   302

    }/*function_%s*/

   303

    break;

   304

"""    %(fname.lower())

   305

il_code_gen +=  """

   306

    case function_none :

   307

    ERROR;

   308

}

   309

return NULL;

   310

"""

   311

   312

###################################################################

   313

"""

   314

Generate the part of search_expression_type_c::visit(function_invocation)

   315

that is responsible of returning type symbol for function invocation.

   316

"""

   317

search_type_code =  """

   318

/****

   319

 * IEC 61131-3 standard function lib

   320

 * generated code, do not edit by hand

   321

 */

   322

   323

void *compute_standard_function_st(function_invocation_c *symbol) {

   324

   325

  function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);

   326

  function_call_param_iterator_c function_call_param_iterator(symbol);

   327

  search_expression_type_c* search_expression_type = this;

   328

   329

  switch(current_function_type){

   330

"""

   331

   332

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   333

    search_type_code += """

   334

/****

   335

 *%s

   336

 */

   337

    case function_%s :

   338

    {

   339

        symbol_c *last_type_symbol = NULL;

   340

"""    %(fname, fname.lower())

   341

    indent =  "    "

   342

   343

    search_type_code += recurse_and_indent(fdecls, indent, True).replace('\n','\n    ')

   344

   345

    search_type_code += """

   346

    }/*function_%s*/

   347

    break;

   348

"""    %(fname.lower())

   349

search_type_code += """

   350

    case function_none :

   351

    ERROR;

   352

  }

   353

  return NULL;

   354

}

   355

   356

void *compute_standard_function_il(il_function_call_c *symbol, symbol_c *param_data_type) {

   357

   358

  function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);

   359

  function_call_param_iterator_c function_call_param_iterator(symbol);  

   360

  search_expression_type_c* search_expression_type = this;

   361

   362

  switch(current_function_type){

   363

"""

   364

   365

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   366

    search_type_code += """

   367

/****

   368

 *%s

   369

 */

   370

    case function_%s :

   371

    {

   372

        symbol_c *last_type_symbol = NULL;

   373

"""    %(fname, fname.lower())

   374

    indent =  "    "

   375

   376

    search_type_code += recurse_and_indent(fdecls, indent, True, True).replace('\n','\n    ')

   377

   378

    search_type_code += """

   379

    }/*function_%s*/

   380

    break;

   381

"""    %(fname.lower())

   382

search_type_code += """

   383

    case function_none :

   384

    ERROR;

   385

  }

   386

  return NULL;

   387

}

   388

"""

   389

   390

###################################################################

   391

###################################################################

   392

###################################################################

   393

"""

   394

Generate the standard_function_names[] for inclusion in bizon generated code

   395

"""

   396

standard_function_names = """

   397

/****

   398

 * IEC 61131-3 standard function lib

   399

 * generated code, do not edit by hand

   400

 */

   401

   402

const char *standard_function_names[] = {

   403

"""

   404

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   405

    standard_function_names += "\""+fname+"\",\n"

   406

standard_function_names += """

   407

/* end of array marker! Do not remove! */

   408

NULL

   409

};

   410

   411

"""

   412

   413

###################################################################

   414

###################################################################

   415

###################################################################

   416

"""

   417

Generate the C implementation of the IEC standard function library.

   418

"""

   419

iec_std_lib_generated =  """

   420

/****

   421

 * IEC 61131-3 standard function lib

   422

 * generated code, do not edit by hand

   423

 */

   424

   425

/* Macro that expand to subtypes */

   426

"""

   427

for typename, parenttypename in TypeHierarchy_list:

   428

    if (typename.startswith("ANY")):

   429

        iec_std_lib_generated += "#define " + typename + "(DO)"

   430

        for typename2, parenttypename2 in TypeHierarchy_list:

   431

            if(parenttypename2 == typename):

   432

                if(typename2.startswith("ANY")):

   433

                    iec_std_lib_generated +=  " " + typename2 + "(DO)"

   434

                else:

   435

                    iec_std_lib_generated +=  " DO(" + typename2 + ")"

   436

        iec_std_lib_generated +=  "\n"

   437

    else:

   438

        break

   439

   440

if len(sys.argv) != 2 :

   441

    print "Usage: " + sys.argv[0] + "path_name\n -> create files in path_name"

   442

    sys.exit(0)

   443

   444

# Now, print that out, or write to files from sys.argv

   445

for path, name, ext in [

   446

        ('stage4/generate_cc','function_type_decl','h'),

   447

        ('stage4/generate_cc','get_function_type_decl','c'),

   448

        ('stage4/generate_cc','st_code_gen','c'),

   449

        ('stage4/generate_cc','il_code_gen','c'),

   450

        ('stage4/generate_cc','search_type_code','c'),

   451

        ('stage1_2','standard_function_names','c'),

   452

        ('lib', 'iec_std_lib_generated','h')

   453

        ]:

   454

    fd = open(os.path.join(sys.argv[1], path, name+'.'+ext),'w')

   455

    fd.write(eval(name))

   456

    fd.close()

   457

   458

#print "/* Code to eventually paste in iec_std_lib.h if type hierarchy changed */"

   459

#print "/* you also have to change iec_std_lib.h according to new types        */\n\n"

   460

#print iec_std_lib_generated