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

    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.h"

   100

   101

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

   102

#include "stage1_2_priv.hh"

   103

   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->elements[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

/* A macro for printing out internal parser errors... */

   165

#define ERROR error_exit(__FILE__,__LINE__)

   166

/* function defined in main.cc */

   167

extern void error_exit(const char *file_name, int line_no);

   168

   169

   170

   171

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

   172

/* global variables...   */

   173

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

   174

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

   175

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

   176

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

   177

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

   178

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

   179

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

   180

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

   181

 */

   182

   183

   184

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

   185

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

   186

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

   187

 *       option is to use global variables! yuck!

   188

 */

   189

   190

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

   191

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

   192

 * but disallows them in user code...

   193

 */

   194

extern bool allow_function_overloading;

   195

   196

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

   197

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

   198

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

   199

 * This is an extension to the standard syntax.

   200

 * See comments below for details why we support this!

   201

 */

   202

extern bool allow_extensible_function_parameters;

   203

   204

/* A global flag used to tell the parser whether to include the full variable location

   205

 * when printing out error messages...

   206

 */

   207

extern bool full_token_loc;

   208

   209

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

   210

 * by bison.

   211

 */

   212

extern symbol_c *tree_root;

   213

   214

   215

   216

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

   217

/* forward declarations */

   218

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

   219

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

   220

   221

/* Convert an il_operator_c into an identifier_c */

   222

symbol_c *il_operator_c_2_identifier_c(symbol_c *il_operator);

   223

   224

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

   225

/* ERROR_CHECK_BEGIN */

   226

bool is_current_syntax_token();

   227

/* ERROR_CHECK_END */

   228

   229

/* print an error message */

   230

void print_err_msg(int first_line,

   231

                   int first_column,

   232

                   const char *first_filename,

   233

                   long int first_order,

   234

                   int last_line,

   235

                   int last_column,

   236

                   const char *last_filename,

   237

                   long int last_order,

   238

                   const char *additional_error_msg);

   239

%}

   240

   241

   242

   243

   244

// %glr-parser

   245

// %expect-rr 1

   246

   247

   248

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

   249

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

   250

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

   251

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

   252

 */

   253

%code requires {

   254

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

   255

 * the filename in which the token is expressed.

   256

 */

   257

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

   258

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

   259

 * declaring the typedef struct yyltype__local here would result in a 

   260

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

   261

 * declared twice.

   262

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

   263

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

   264

 */

   265

#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED

   266

typedef struct YYLTYPE {

   267

    int         first_line;

   268

    int         first_column;

   269

    const char *first_file;

   270

    long int    first_order;

   271

    int         last_line;

   272

    int         last_column;

   273

    const char *last_file;

   274

    long int    last_order;

   275

} YYLTYPE;

   276

#define YYLTYPE_IS_DECLARED 1

   277

#define YYLTYPE_IS_TRIVIAL 1

   278

#endif

   279

   280

}

   281

   282

   283

   284

%union {

   285

    symbol_c 	*leaf;

   286

    list_c	*list;

   287

    char 	*ID;	/* token value */

   288

}

   289

   290

/*

   291

 TODO: DO we need to define a destructor do free

   292

       memory when recovering from errors, or do the

   293

       class destructors already handle this?

   294

       Following is example on how to define

   295

       detructors, using the syntax:

   296

       %destructor { CODE } SYMBOLS

   297

%union

   298

      {

   299

        char *string;

   300

      }

   301

      %token <string> STRING

   302

      %type  <string> string

   303

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

   304

*/

   305

   306

   307

   308

   309

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

   310

/* Prelimenary helpful constructs... */

   311

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

   312

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

   313

 * after all includes have already been processed.

   314

 *

   315

 * Flex automatically returns the token with value 0

   316

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

   317

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

   318

 * to detect the very end of the input files.

   319

 */

   320

%token END_OF_INPUT 0

   321

   322

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

   323

/* USE 1:

   324

 * ======

   325

 * This token is currently also being used as the default

   326

 * initialisation value of the token_id member in

   327

 * the symbol_c base class.

   328

 *

   329

 * USE 2

   330

 * =====

   331

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

   332

 * mysterious reduce/reduce conflicts due to the fact

   333

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

   334

 * This means that bison cannot handle it without some

   335

 * caoxing from ourselves. We will then need this token

   336

 * to do the coaxing...

   337

 */

   338

%token BOGUS_TOKEN_ID

   339

   340

%type <leaf>	start

   341

   342

%type <leaf>	any_identifier

   343

   344

%token <ID>	prev_declared_variable_name_token

   345

%token <ID>	prev_declared_direct_variable_token

   346

%token <ID>	prev_declared_fb_name_token

   347

%type <leaf>	prev_declared_variable_name

   348

%type <leaf>	prev_declared_direct_variable

   349

%type <leaf>	prev_declared_fb_name

   350

   351

%token  <ID>	prev_declared_simple_type_name_token

   352

%token  <ID>	prev_declared_subrange_type_name_token

   353

%token  <ID>	prev_declared_enumerated_type_name_token

   354

%token  <ID>	prev_declared_array_type_name_token

   355

%token  <ID>	prev_declared_structure_type_name_token

   356

%token  <ID>	prev_declared_string_type_name_token

   357

   358

%type  <leaf>	prev_declared_simple_type_name

   359

%type  <leaf>	prev_declared_subrange_type_name

   360

%type  <leaf>	prev_declared_enumerated_type_name

   361

%type  <leaf>	prev_declared_array_type_name

   362

%type  <leaf>	prev_declared_structure_type_name

   363

%type  <leaf>	prev_declared_string_type_name

   364

   365

%token <ID>	prev_declared_derived_function_name_token

   366

%token <ID>	prev_declared_derived_function_block_name_token

   367

%token <ID>	prev_declared_program_type_name_token

   368

%type  <leaf>	prev_declared_derived_function_name

   369

%type  <leaf>	prev_declared_derived_function_block_name

   370

%type  <leaf>	prev_declared_program_type_name

   371

   372

   373

   374

   375

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

   376

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

   377

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

   378

   379

/* Pragmas that our compiler will accept.

   380

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

   381

 */

   382

%token          disable_code_generation_pragma_token

   383

%token          enable_code_generation_pragma_token

   384

%type <leaf>	disable_code_generation_pragma

   385

%type <leaf>	enable_code_generation_pragma

   386

   387

   388

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

   389

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

   390

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

   391

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

   392

 */

   393

%token <ID>	pragma_token

   394

%type <leaf>	pragma

   395

   396

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

   397

%type <leaf>	any_pragma

   398

   399

   400

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

   401

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

   402

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

   403

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

   404

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

   405

 *

   406

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

   407

 */

   408

%token	EN

   409

%token	ENO

   410

%type <leaf>	en_identifier

   411

%type <leaf>	eno_identifier

   412

   413

   414

   415

   416

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

   417

/* B 0 - Programming Model */

   418

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

   419

%type <list>	library

   420

%type <leaf>	library_element_declaration

   421

   422

   423

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

   424

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

   425

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

   426

/* Done totally within flex...

   427

  letter

   428

  digit

   429

  octal_digit

   430

  hex_digit

   431

*/

   432

%token <ID>	identifier_token

   433

%type  <leaf>	identifier

   434

   435

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

   436

/* B 1.2 - Constants */

   437

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

   438

%type <leaf>	constant

   439

%type <leaf>	non_negative_constant

   440

   441

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

   442

/* B 1.2.1 - Numeric Literals */

   443

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

   444

/* Done totally within flex...

   445

  bit

   446

*/

   447

%type  <leaf> numeric_literal

   448

%type  <leaf> integer_literal

   449

%type  <leaf> signed_integer

   450

%token <ID>   integer_token

   451

%type  <leaf> integer

   452

%token <ID>   binary_integer_token

   453

%type  <leaf> binary_integer

   454

%token <ID>   octal_integer_token

   455

%type  <leaf> octal_integer

   456

%token <ID>   hex_integer_token

   457

%type  <leaf> hex_integer

   458

%token <ID>   real_token

   459

%type  <leaf> real

   460

%type  <leaf> signed_real

   461

%type  <leaf> real_literal

   462

// %type  <leaf> exponent

   463

%type  <leaf> bit_string_literal

   464

%type  <leaf> boolean_literal

   465

   466

%token safeboolean_true_literal_token

   467

%token safeboolean_false_literal_token

   468

%token boolean_true_literal_token

   469

%token boolean_false_literal_token

   470

   471

%token FALSE

   472

%token TRUE

   473

   474

   475

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

   476

/* B 1.2.2 - Character Strings */

   477

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

   478

%token <ID>   single_byte_character_string_token

   479

%token <ID>   double_byte_character_string_token

   480

   481

%type  <leaf> character_string

   482

%type  <leaf> single_byte_character_string

   483

%type  <leaf> double_byte_character_string

   484

   485

   486

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

   487

/* B 1.2.3 - Time Literals */

   488

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

   489

%type  <leaf> time_literal

   490

   491

   492

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

   493

/* B 1.2.3.1 - Duration */

   494

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

   495

%type  <leaf>	duration

   496

%type  <leaf>	interval

   497

%type  <leaf>	days

   498

%type  <leaf>	fixed_point

   499

%type  <leaf>	hours

   500

%type  <leaf>	minutes

   501

%type  <leaf>	seconds

   502

%type  <leaf>	milliseconds

   503

   504

%token <ID>	fixed_point_token

   505