1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *

     4

 *  Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)

     5

 *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant

     6

 *

     7

 *  This program is free software: you can redistribute it and/or modify

     8

 *  it under the terms of the GNU General Public License as published by

     9

 *  the Free Software Foundation, either version 3 of the License, or

    10

 *  (at your option) any later version.

    11

 *

    12

 *  This program is distributed in the hope that it will be useful,

    13

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    14

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15

 *  GNU General Public License for more details.

    16

 *

    17

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

    18

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    19

 *

    20

 *

    21

 * This code is made available on the understanding that it will not be

    22

 * used in safety-critical situations without a full and competent review.

    23

 */

    24

    25

/*

    26

 * An IEC 61131-3 compiler.

    27

 *

    28

 * Based on the

    29

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    30

 *

    31

 */

    32

    33

/*

    34

 * Stage 2

    35

 * =======

    36

 *

    37

 *  This file contains the syntax definition of the textual

    38

 *  languages IL and ST, as well as the textual version of SFC.

    39

 *  The syntax parser, comprising the 2nd stage of the overall 

    40

 *  compiler, is generated by runing bison on this file.

    41

 */

    42

    43

    44

    45

    46

/**********************************************************************/

    47

/**********************************************************************/

    48

/**********************************************************************/

    49

/**********************************************************************/

    50

/*******                                                        *******/

    51

/*******   The following syntax does not have any conflicts.    *******/

    52

/*******                                                        *******/

    53

/*******   P L E A S E    K E E P    I T    T H A T    W A Y !  *******/

    54

/*******   ===================================================  *******/

    55

/*******                                                        *******/

    56

/**********************************************************************/

    57

/**********************************************************************/

    58

/**********************************************************************/

    59

/**********************************************************************/

    60

    61

/* NOTE: the following file contains many rules used merely for detecting errors in

    62

 * the IEC source code being parsed.

    63

 * To remove all these rules, simply execute the command (first replace all '%' with '/'):

    64

 * $sed '\:%\* ERROR_CHECK_BEGIN \*%:,\:%\* ERROR_CHECK_END \*%: d' iec_bison.yy

    65

 *

    66

 * The above command had to be edited ('/' replaced by '%') so as not to include the C syntax that closes

    67

 * comments inside this comment!

    68

 * If you place the command in a shell script, be sure to remove the backslashes '\' before each asterisk '*' !!

    69

 */

    70

    71

    72

    73

    74

    75

%{

    76

#include <string.h>	/* required for strdup()  */

    77

    78

    79

/* declare the token parser generated by flex... */

    80

int yylex(void);

    81

    82

/* declare the error handler defined at the end of this file */

    83

void yyerror (const char *error_msg);

    84

    85

/* produce a more verbose parsing error message */

    86

#define YYERROR_VERBOSE

    87

    88

/* Include debuging code.

    89

 * Printing of debug info must then be activated by setting

    90

 * the variable yydebug to 1.

    91

 */

    92

#define YYDEBUG 0

    93

    94

    95

/* file with declaration of absyntax classes... */

    96

#include "../absyntax/absyntax.hh"

    97

    98

/* file with declaration of token constants. Generated by bison! */

    99

#include "iec_bison.hh"

   100

   101

/* The interface through which bison and flex interact. */

   102

#include "stage1_2_priv.hh"

   103

#include "create_enumtype_conversion_functions.hh"

   104

   105

#include "../absyntax_utils/add_en_eno_param_decl.hh"	/* required for  add_en_eno_param_decl_c */

   106

   107

/* an ugly hack!!

   108

 * We will probably not need it when we decide

   109

 *  to cut down the abstract syntax down to size.

   110

 *  We keep it as it is until we get to write

   111

 *  stages 3 and 4 of the compiler. Who knows,

   112

 *  we might just find out that we really do need

   113

 *  the abstract syntax tree to stay as it is

   114

 *  afterall!

   115

 */

   116

/* for each element <elem> in list_c * <list>

   117

 * execute the code <code>

   118

 */

   119

#define FOR_EACH_ELEMENT(elem, list, code) {		\

   120

  symbol_c *elem;					\

   121

  for(int i = 0; i < list->n; i++) {			\

   122

    elem = list->get_element(i);			\

   123

    code;						\

   124

  }							\

   125

}

   126

   127

   128

   129

/* Macros used to pass the line and column locations when

   130

 * creating a new object for the abstract syntax tree.

   131

 */

   132

#define locloc(foo) foo.first_line, foo.first_column, foo.first_file, foo.first_order, foo.last_line, foo.last_column, foo.last_file, foo.last_order

   133

#define   locf(foo) foo.first_line, foo.first_column, foo.first_file, foo.first_order

   134

#define   locl(foo) foo.last_line,  foo.last_column,  foo.last_file,  foo.last_order

   135

   136

/* Redefine the default action to take for each rule, so that the filenames are correctly processed... */

   137

# define YYLLOC_DEFAULT(Current, Rhs, N)                                \

   138

         do                                                                  \

   139

           if (N)                                                            \

   140

             {                                                               \

   141

               (Current).first_line   = YYRHSLOC(Rhs, 1).first_line;         \

   142

               (Current).first_column = YYRHSLOC(Rhs, 1).first_column;       \

   143

               (Current).first_file   = YYRHSLOC(Rhs, 1).first_file;         \

   144

               (Current).first_order  = YYRHSLOC(Rhs, 1).first_order;        \

   145

               (Current).last_line    = YYRHSLOC(Rhs, N).last_line;          \

   146

               (Current).last_column  = YYRHSLOC(Rhs, N).last_column;        \

   147

               (Current).last_file    = YYRHSLOC(Rhs, 1).last_file;          \

   148

               (Current).last_order   = YYRHSLOC(Rhs, 1).last_order;         \

   149

             }                                                               \

   150

           else                                                              \

   151

             {                                                               \

   152

               (Current).first_line   = (Current).last_line   =              \

   153

                 YYRHSLOC(Rhs, 0).last_line;                                 \

   154

               (Current).first_column = (Current).last_column =              \

   155

                 YYRHSLOC(Rhs, 0).last_column;                               \

   156

               (Current).first_file   = (Current).last_file   =              \

   157

                 YYRHSLOC(Rhs, 0).last_file;                                 \

   158

               (Current).first_order  = (Current).last_order  =              \

   159

                 YYRHSLOC(Rhs, 0).last_order;                                \

   160

             }                                                               \

   161

         while (0)

   162

   163

   164

#include "../main.hh" // required for ERROR() and ERROR_MSG() macros.

   165

   166

   167

   168

/*************************/

   169

/* global variables...   */

   170

/*************************/

   171

/* NOTE: For some strange reason bison ver 2.3 is including these declarations

   172

 *       in the iec_bison.hh file, which is in turn included by flex.

   173

 *       We cannot therefore define any variables over here, but merely declare 

   174

 *       their existance (otherwise we get errors when linking the code, since we

   175

 *       would get a new variable defined each time iec_bison.hh is included!).

   176

 *       Even though the variables are declared 'extern' over here, they will in

   177

 *       fact be defined towards the end of this same file (i.e. in the prologue)

   178

 */

   179

   180

   181

/* NOTE: These variable are really parameters we would like the stage2__ function to pass

   182

 *       to the yyparse() function. However, the yyparse() function is created automatically

   183

 *       by bison, so we cannot add parameters to this function. The only other

   184

 *       option is to use global variables! yuck!

   185

 */

   186

   187

/* A global flag used to tell the parser if overloaded funtions should be allowed.

   188

 * The IEC 61131-3 standard allows overloaded funtions in the standard library,

   189

 * but disallows them in user code...

   190

 */

   191

extern bool allow_function_overloading;

   192

   193

/* A flag to tell the compiler whether to allow the declaration

   194

 * of extensible function (i.e. functions that may have a variable number of

   195

 * input parameters, such as AND(word#33, word#44, word#55, word#66).

   196

 * This is an extension to the standard syntax.

   197

 * See comments below for details why we support this!

   198

 */

   199

extern bool allow_extensible_function_parameters;

   200

   201

/* A global flag used to tell the parser whether to allow use of DREF and '^' operators (defined in IEC 61131-3 v3) */

   202

extern bool allow_ref_dereferencing;

   203

   204

/* A global flag used to tell the parser whether to allow use of REF_TO ANY datatypes (non-standard extension to IEC 61131-3 v3) */

   205

extern bool allow_ref_to_any;

   206

   207

/* A global flag used to tell the parser whether to allow use of REF_TO as a struct or array element (non-standard extension) */

   208

extern bool allow_ref_to_in_derived_datatypes;

   209

   210

/* A pointer to the root of the parsing tree that will be generated  by bison. */

   211

extern symbol_c *tree_root;

   212

   213

   214

   215

/************************/

   216

/* forward declarations */

   217

/************************/

   218

/* The functions declared here are defined at the end of this file... */

   219

   220

/* Convert an il_operator_c into an identifier_c */

   221

identifier_c         *il_operator_c_2_identifier_c        (symbol_c *il_operator);

   222

/* Convert an il_operator_c into an poutype_identifier_c */

   223

poutype_identifier_c *il_operator_c_2_poutype_identifier_c(symbol_c *il_operator);

   224

   225

   226

/* return if current token is a syntax element */

   227

/* ERROR_CHECK_BEGIN */

   228

bool is_current_syntax_token();

   229

/* ERROR_CHECK_END */

   230

   231

/* print an error message */

   232

void print_err_msg(int first_line,

   233

                   int first_column,

   234

                   const char *first_filename,

   235

                   long int first_order,

   236

                   int last_line,

   237

                   int last_column,

   238

                   const char *last_filename,

   239

                   long int last_order,

   240

                   const char *additional_error_msg);    

   241

%}

   242

   243

   244

   245

   246

// %glr-parser

   247

// %expect-rr 1

   248

   249

   250

/* The following definitions need to be inside a '%code requires' 

   251

 * so that they are also included in the header files. If this were not the case,

   252

 * YYLTYPE would be delcared as something in the iec.cc file, and another thing

   253

 * (actually the default value of YYLTYPE) in the iec_bison.hh heder file.

   254

 */

   255

%code requires {

   256

/* define a new data type to store the locations, so we can also store

   257

 * the filename in which the token is expressed.

   258

 */

   259

/* NOTE: since this code will be placed in the iec_bison.hh header file,

   260

 * as well as the iec.cc file that also includes the iec_bison.hh header file,

   261

 * declaring the typedef struct yyltype__local here would result in a 

   262

 * compilation error when compiling iec.cc, as this struct would be

   263

 * declared twice.

   264

 * We therefore use the #if !defined YYLTYPE ...

   265

 * to make sure only the first declaration is parsed by the C++ compiler.

   266

 */

   267

#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED

   268

typedef struct YYLTYPE {

   269

    int         first_line;

   270

    int         first_column;

   271

    const char *first_file;

   272

    long int    first_order;

   273

    int         last_line;

   274

    int         last_column;

   275

    const char *last_file;

   276

    long int    last_order;

   277

} YYLTYPE;

   278

#define YYLTYPE_IS_DECLARED 1

   279

#define YYLTYPE_IS_TRIVIAL 0

   280

#endif

   281

   282

}

   283

   284

   285

   286

%union {

   287

    symbol_c 	*leaf;

   288

    list_c	*list;

   289

    char 	*ID;	/* token value */

   290

}

   291

   292

/*

   293

 TODO: DO we need to define a destructor do free

   294

       memory when recovering from errors, or do the

   295

       class destructors already handle this?

   296

       Following is example on how to define

   297

       detructors, using the syntax:

   298

       %destructor { CODE } SYMBOLS

   299

%union

   300

      {

   301

        char *string;

   302

      }

   303

      %token <string> STRING

   304

      %type  <string> string

   305

      %destructor { free ($$); } STRING string

   306

*/

   307

   308

   309

   310

   311

/*************************************/

   312

/* Prelimenary helpful constructs... */

   313

/*************************************/

   314

/* A token used to identify the very end of the input file

   315

 * after all includes have already been processed.

   316

 *

   317

 * Flex automatically returns the token with value 0

   318

 * at the end of the file. We therefore specify here

   319

 * a token with that exact same value here, so we can use it

   320

 * to detect the very end of the input files.

   321

 */

   322

%token END_OF_INPUT 0

   323

   324

/* A bogus token that, in principle, flex MUST NEVER generate */

   325

/* USE 1:

   326

 * ======

   327

 * This token is currently also being used as the default

   328

 * initialisation value of the token_id member in

   329

 * the symbol_c base class.

   330

 *

   331

 * USE 2

   332

 * =====

   333

 * This token may also be used in the future to remove

   334

 * mysterious reduce/reduce conflicts due to the fact

   335

 * that our grammar may not be LALR(1) but merely LR(1).

   336

 * This means that bison cannot handle it without some

   337

 * caoxing from ourselves. We will then need this token

   338

 * to do the coaxing...

   339

 */

   340

%token BOGUS_TOKEN_ID

   341

   342

%type <leaf>	start

   343

   344

%type <leaf>	any_identifier

   345

   346

%token <ID>	prev_declared_variable_name_token

   347

%token <ID>	prev_declared_direct_variable_token

   348

%token <ID>	prev_declared_fb_name_token

   349

%type <leaf>	prev_declared_variable_name

   350

%type <leaf>	prev_declared_direct_variable

   351

%type <leaf>	prev_declared_fb_name

   352

   353

%token  <ID>	prev_declared_simple_type_name_token

   354

%token  <ID>	prev_declared_subrange_type_name_token

   355

%token  <ID>	prev_declared_enumerated_type_name_token

   356

%token  <ID>	prev_declared_array_type_name_token

   357

%token  <ID>	prev_declared_structure_type_name_token

   358

%token  <ID>	prev_declared_string_type_name_token

   359

%token  <ID>	prev_declared_ref_type_name_token  /* defined in IEC 61131-3 v3 */

   360

   361

%type  <leaf>	prev_declared_simple_type_name

   362

%type  <leaf>	prev_declared_subrange_type_name

   363

%type  <leaf>	prev_declared_enumerated_type_name

   364

%type  <leaf>	prev_declared_array_type_name

   365

%type  <leaf>	prev_declared_structure_type_name

   366

%type  <leaf>	prev_declared_string_type_name

   367

%type  <leaf>	prev_declared_ref_type_name  /* defined in IEC 61131-3 v3 */

   368

   369

%token <ID>	prev_declared_derived_function_name_token

   370

%token <ID>	prev_declared_derived_function_block_name_token

   371

%token <ID>	prev_declared_program_type_name_token

   372

%type  <leaf>	prev_declared_derived_function_name

   373

%type  <leaf>	prev_declared_derived_function_block_name

   374

%type  <leaf>	prev_declared_program_type_name

   375

   376

/* Tokens used to help resolve a reduce/reduce conflict */

   377

/* The mentioned conflict only arises due to a non-standard feature added to matiec.

   378

 * Namely, the permission to call functions returning VOID as an ST statement.

   379

 *   e.g.:   FUNCTION foo: VOID

   380

 *             VAR_INPUT i: INT; END_VAR;

   381

 *             ...

   382

 *           END_FUNCTION

   383

 *

   384

 *           FUNCTION BAR: BOOL

   385

 *             VAR b: bool; END_VAR

   386

 *             foo(i:=42);   <--- Calling foo outside an expression. Function invocation is considered an ST statement!!

   387

 *           END_FUNCTION

   388

 *

   389

 *  The above function invocation may also be reduced to a formal IL function invocation, so we get a 

   390

 *  reduce/reduce conflict to st_statement_list/instruction_list  (or something equivalent).

   391

 *

   392

 *  We solve this by having flex determine if it is ST or IL invocation (ST ends with a ';' !!).

   393

 *  At the start of a function/FB/program body, flex will tell bison whether to expect ST or IL code!

   394

 *  This is why we need the following two tokens!

   395

 *

   396

 *  NOTE: flex was already determing whther it was parsing ST or IL code as it can only send 

   397

 *        EOL tokens when parsing IL. However, did this silently without telling bison about this.

   398

 *        Now, it does

   399

 */

   400

%token          start_ST_body_token

   401

%token          start_IL_body_token

   402

   403

   404

   405

/**********************************************************************************/

   406

/* B XXX - Things that are missing from the standard, but should have been there! */

   407

/**********************************************************************************/

   408

   409

/* Pragmas that our compiler will accept.

   410

 * See the comment in iec.flex for why these pragmas exist. 

   411

 */

   412

%token          disable_code_generation_pragma_token

   413

%token          enable_code_generation_pragma_token

   414

%type <leaf>	disable_code_generation_pragma

   415

%type <leaf>	enable_code_generation_pragma

   416

   417

   418

/* All other pragmas that we do not support... */

   419

/* In most stage 4, the text inside the pragmas will simply be copied to the output file.

   420

 * This allows us to insert C code (if using stage 4 generating C code) 

   421

 * inside/interningled with the IEC 61131-3 code!

   422

 */

   423

%token <ID>	pragma_token

   424

%type <leaf>	pragma

   425

   426

/* The joining of all previous pragmas, i.e. any possible pragma */

   427

%type <leaf>	any_pragma

   428

   429

   430

/* Where do these tokens belong?? They are missing from the standard! */

   431

/* NOTE: There are other tokens related to these 'EN' ENO', that are also 

   432

 * missing from the standard. However, their location in the annex B is 

   433

 * relatively obvious, so they have been inserted in what seems to us their 

   434

 * correct place in order to ease understanding of the parser...

   435

 *

   436

 * please read the comment above the definition of 'variable' in section B1.4 for details.

   437

 */

   438

%token	EN

   439

%token	ENO

   440

%type <leaf>	en_identifier

   441

%type <leaf>	eno_identifier

   442

   443

/* Keywords in IEC 61131-3 v3 */

   444

%token	REF

   445

%token	DREF

   446

%token	REF_TO

   447

%token	NULL_token  /* cannot use simply 'NULL', as it conflicts with the NULL keyword in C++ */

   448

   449

   450

   451

/***************************/

   452

/* B 0 - Programming Model */

   453

/***************************/

   454

%type <list>	library

   455

%type <leaf>	library_element_declaration

   456

   457

   458

/*******************************************/

   459

/* B 1.1 - Letters, digits and identifiers */

   460

/*******************************************/

   461

/* Done totally within flex...

   462

  letter

   463

  digit

   464

  octal_digit

   465

  hex_digit

   466

*/

   467

%token <ID>	identifier_token

   468

%type  <leaf>	identifier

   469

   470

/*********************/

   471

/* B 1.2 - Constants */

   472

/*********************/

   473

%type <leaf>	constant

   474

%type <leaf>	non_int_or_real_constant

   475

   476

/*********************************/

   477

/* B 1.2.XX - Reference Literals */

   478

/*********************************/

   479

/* NOTE: The following syntax was added by MJS in order to add support for the NULL keyword, defined in  IEC 61131-3 v3

   480

 *       In v3 expressions that reduce to a reference datatype (REF_TO) are handled explicitly in the syntax 

   481

 *       (e.g., any variable that is a of reference datatpe falls under the 'ref_name' rule), which means 

   482

 *       that we would need to keep track of which variables are declared as REF_TO. 

   483

 *       In order to reduce the changes to the current IEC 61131-3 v2 syntax, I have opted not to do this,

   484

 *       and simply let the ref_expressions (Ref_Assign, Ref_Compare) be interpreted as all other standard expressions 

   485

 *       in v2. However, ref_expressions allow the use of the 'NULL' constant, which is handled explicitly

   486

 *       in the ref_expressions syntax of v3.

   487

 *       To allow the use of the 'NULL' constant in this extended v2, I have opted to interpret this 'NULL' constant 

   488

 *       as a literal.

   489

 */

   490

%type  <leaf>	ref_value_null_literal  /* defined in IEC 61131-3 v3 - Basically the 'NULL' keyword! */

   491

   492

   493

/******************************/

   494

/* B 1.2.1 - Numeric Literals */

   495

/******************************/

   496

/* Done totally within flex...

   497

  bit

   498

*/

   499

%type  <leaf> numeric_literal

   500

%type  <leaf> integer_literal