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

    62

    63

    64

%{

    65

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

    66

    67

    68

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

    69

int yylex(void);

    70

    71

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

    72

void yyerror (const char *error_msg);

    73

    74

/* produce a more verbose parsing error message */

    75

#define YYERROR_VERBOSE

    76

    77

/* Include debuging code.

    78

 * Printing of debug info must then be activated by setting

    79

 * the variable yydebug to 1.

    80

 */

    81

#define YYDEBUG 0

    82

    83

    84

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

    85

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

    86

    87

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

    88

#include "iec.y.hh"

    89

    90

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

    91

#include "stage1_2_priv.hh"

    92

    93

    94

/* an ugly hack!!

    95

 * We will probably not need it when we decide

    96

 *  to cut down the abstract syntax down to size.

    97

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

    98

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

    99

 *  we might just find out that we really do need

   100

 *  the abstract syntax tree to stay as it is

   101

 *  afterall!

   102

 */

   103

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

   104

 * execute the code <code>

   105

 */

   106

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

   107

  symbol_c *elem;					\

   108

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

   109

    elem = list->elements[i];				\

   110

    code;						\

   111

  }							\

   112

}

   113

   114

   115

   116

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

   117

 * creating a new object for the abstract syntax tree.

   118

 */

   119

#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

   120

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

   121

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

   122

   123

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

   124

# define YYLLOC_DEFAULT(Current, Rhs, N)                                \

   125

         do                                                                  \

   126

           if (N)                                                            \

   127

             {                                                               \

   128

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

   129

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

   130

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

   131

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

   132

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

   133

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

   134

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

   135

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

   136

             }                                                               \

   137

           else                                                              \

   138

             {                                                               \

   139

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

   140

                 YYRHSLOC(Rhs, 0).last_line;                                 \

   141

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

   142

                 YYRHSLOC(Rhs, 0).last_column;                               \

   143

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

   144

                 YYRHSLOC(Rhs, 0).last_file;                                 \

   145

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

   146

                 YYRHSLOC(Rhs, 0).last_order;                                \

   147

             }                                                               \

   148

         while (0)

   149

   150

   151

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

   152

#define ERROR error_exit(__FILE__,__LINE__)

   153

/* function defined in main.cc */

   154

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

   155

   156

   157

   158

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

   159

/* global variables...   */

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

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

   168

 */

   169

   170

   171

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

   172

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

   173

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

   174

 *       option is to use global variables! yuck!

   175

 */

   176

   177

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

   178

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

   179

 * but disallows them in user code...

   180

 */

   181

extern bool allow_function_overloading;

   182

   183

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

   184

 * when printing out error messages...

   185

 */

   186

extern bool full_token_loc;

   187

   188

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

   189

 * by bison.

   190

 */

   191

extern symbol_c *tree_root;

   192

   193

   194

   195

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

   196

/* forward declarations */

   197

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

   198

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

   199

   200

/* Convert an il_operator_c into an identifier_c */

   201

symbol_c *il_operator_c_2_identifier_c(symbol_c *il_operator);

   202

   203

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

   204

/* ERROR_CHECK_BEGIN */

   205

bool is_current_syntax_token();

   206

/* ERROR_CHECK_END */

   207

   208

/* print an error message */

   209

void print_err_msg(int first_line,

   210

                   int first_column,

   211

                   const char *first_filename,

   212

                   long int first_order,

   213

                   int last_line,

   214

                   int last_column,

   215

                   const char *last_filename,

   216

                   long int last_order,

   217

                   const char *additional_error_msg);

   218

%}

   219

   220

   221

   222

   223

// %glr-parser

   224

// %expect-rr 1

   225

   226

   227

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

   228

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

   229

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

   230

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

   231

 */

   232

%code requires {

   233

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

   234

 * the filename in which the token is expressed.

   235

 */

   236

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

   237

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

   238

 * declaring the typedef struct yyltype__local here would result in a 

   239

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

   240

 * declared twice.

   241

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

   242

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

   243

 *

   244

 * At first glance it seems that what we really should do is delcare the

   245

 * YYLTYPE directly as an anonymous struct, thus:

   246

 * #define YYLTYPE struct{ ...}

   247

 * however, this also results in compilation errors.

   248

 *

   249

 * I (Mario) think this is kind of a hack. If you know how to

   250

 * do this re-declaration of YYLTYPE properly, please let me know!

   251

 */

   252

#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED

   253

  typedef struct {

   254

    int         first_line;

   255

    int         first_column;

   256

    const char *first_file;

   257

    long int    first_order;

   258

    int         last_line;

   259

    int         last_column;

   260

    const char *last_file;

   261

    long int    last_order;

   262

  } yyltype__local;

   263

  #define YYLTYPE yyltype__local

   264

#endif

   265

}

   266

   267

   268

   269

%union {

   270

    symbol_c 	*leaf;

   271

    list_c	*list;

   272

    char 	*ID;	/* token value */

   273

}

   274

   275

/*

   276

 TODO: DO we need to define a destructor do free

   277

       memory when recovering from errors, or do the

   278

       class destructors already handle this?

   279

       Following is example on how to define

   280

       detructors, using the syntax:

   281

       %destructor { CODE } SYMBOLS

   282

%union

   283

      {

   284

        char *string;

   285

      }

   286

      %token <string> STRING

   287

      %type  <string> string

   288

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

   289

*/

   290

   291

   292

   293

   294

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

   295

/* Prelimenary helpful constructs... */

   296

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

   297

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

   298

 * after all includes have already been processed.

   299

 *

   300

 * Flex automatically returns the token with value 0

   301

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

   302

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

   303

 * to detect the very end of the input files.

   304

 */

   305

%token END_OF_INPUT 0

   306

   307

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

   308

/* USE 1:

   309

 * ======

   310

 * This token is currently also being used as the default

   311

 * initialisation value of the token_id member in

   312

 * the symbol_c base class.

   313

 *

   314

 * USE 2

   315

 * =====

   316

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

   317

 * mysterious reduce/reduce conflicts due to the fact

   318

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

   319

 * This means that bison cannot handle it without some

   320

 * caoxing from ourselves. We will then need this token

   321

 * to do the coaxing...

   322

 */

   323

%token BOGUS_TOKEN_ID

   324

   325

%type <leaf>	start

   326

   327

%type <leaf>	any_identifier

   328

   329

%token <ID>	prev_declared_variable_name_token

   330

%token <ID>	prev_declared_direct_variable_token

   331

%token <ID>	prev_declared_fb_name_token

   332

%type <leaf>	prev_declared_variable_name

   333

%type <leaf>	prev_declared_direct_variable

   334

%type <leaf>	prev_declared_fb_name

   335

   336

%token  <ID>	prev_declared_simple_type_name_token

   337

%token  <ID>	prev_declared_subrange_type_name_token

   338

%token  <ID>	prev_declared_enumerated_type_name_token

   339

%token  <ID>	prev_declared_array_type_name_token

   340

%token  <ID>	prev_declared_structure_type_name_token

   341

%token  <ID>	prev_declared_string_type_name_token

   342

   343

%type  <leaf>	prev_declared_simple_type_name

   344

%type  <leaf>	prev_declared_subrange_type_name

   345

%type  <leaf>	prev_declared_enumerated_type_name

   346

%type  <leaf>	prev_declared_array_type_name

   347

%type  <leaf>	prev_declared_structure_type_name

   348

%type  <leaf>	prev_declared_string_type_name

   349

   350

%token <ID>	prev_declared_derived_function_name_token

   351

%token <ID>	prev_declared_derived_function_block_name_token

   352

%token <ID>	prev_declared_program_type_name_token

   353

%type  <leaf>	prev_declared_derived_function_name

   354

%type  <leaf>	prev_declared_derived_function_block_name

   355

%type  <leaf>	prev_declared_program_type_name

   356

   357

   358

   359

   360

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

   361

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

   362

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

   363

   364

/* Pragmas that our compiler will accept.

   365

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

   366

 */

   367

%token          disable_code_generation_pragma_token

   368

%token          enable_code_generation_pragma_token

   369

%type <leaf>	disable_code_generation_pragma

   370

%type <leaf>	enable_code_generation_pragma

   371

   372

   373

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

   374

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

   375

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

   376

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

   377

 */

   378

%token <ID>	pragma_token

   379

%type <leaf>	pragma

   380

   381

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

   382

%type <leaf>	any_pragma

   383

   384

   385

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

   386

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

   387

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

   388

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

   389

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

   390

 */

   391

%token	EN

   392

%token	ENO

   393

%type <leaf>	en_identifier

   394

%type <leaf>	eno_identifier

   395

   396

   397

   398

   399

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

   400

/* B 0 - Programming Model */

   401

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

   402

%type <list>	library

   403

%type <leaf>	library_element_declaration

   404

   405

   406

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

   407

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

   408

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

   409

/* Done totally within flex...

   410

  letter

   411

  digit

   412

  octal_digit

   413

  hex_digit

   414

*/

   415

%token <ID>	identifier_token

   416

%type  <leaf>	identifier

   417

   418

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

   419

/* B 1.2 - Constants */

   420

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

   421

%type <leaf>	constant

   422

%type <leaf>	non_negative_constant

   423

   424

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

   425

/* B 1.2.1 - Numeric Literals */

   426

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

   427

/* Done totally within flex...

   428

  bit

   429

*/

   430

%type  <leaf> numeric_literal

   431

%type  <leaf> integer_literal

   432

%type  <leaf> signed_integer

   433

%token <ID>   integer_token

   434

%type  <leaf> integer

   435

%token <ID>   binary_integer_token

   436

%type  <leaf> binary_integer

   437

%token <ID>   octal_integer_token

   438

%type  <leaf> octal_integer

   439

%token <ID>   hex_integer_token

   440

%type  <leaf> hex_integer

   441

%token <ID>   real_token

   442

%type  <leaf> real

   443

%type  <leaf> signed_real

   444

%type  <leaf> real_literal

   445

// %type  <leaf> exponent

   446

%type  <leaf> bit_string_literal

   447

%type  <leaf> boolean_literal

   448

   449

%token safeboolean_true_literal_token

   450

%token safeboolean_false_literal_token

   451

%token boolean_true_literal_token

   452

%token boolean_false_literal_token

   453

   454

%token FALSE

   455

%token TRUE

   456

   457

   458

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

   459

/* B 1.2.2 - Character Strings */

   460

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

   461

%token <ID>   single_byte_character_string_token

   462

%token <ID>   double_byte_character_string_token

   463

   464

%type  <leaf> character_string

   465

%type  <leaf> single_byte_character_string

   466

%type  <leaf> double_byte_character_string

   467

   468

   469

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

   470

/* B 1.2.3 - Time Literals */

   471

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

   472

%type  <leaf> time_literal

   473

   474

   475

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

   476

/* B 1.2.3.1 - Duration */

   477

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

   478

%type  <leaf>	duration

   479

%type  <leaf>	interval

   480

%type  <leaf>	days

   481

%type  <leaf>	fixed_point

   482

%type  <leaf>	hours

   483

%type  <leaf>	minutes

   484

%type  <leaf>	seconds

   485

%type  <leaf>	milliseconds

   486

   487

%type  <leaf>	integer_d

   488

%type  <leaf>	integer_h

   489

%type  <leaf>	integer_m

   490

%type  <leaf>	integer_s

   491

%type  <leaf>	integer_ms

   492

%type  <leaf>	fixed_point_d

   493

%type  <leaf>	fixed_point_h

   494

%type  <leaf>	fixed_point_m

   495

%type  <leaf>	fixed_point_s

   496

%type  <leaf>	fixed_point_ms

   497

   498

%token <ID>	fixed_point_token

   499

%token <ID>	fixed_point_d_token

   500

%token <ID>	integer_d_token

   501

%token <ID>	fixed_point_h_token

   502

%token <ID>	integer_h_token

   503

%token <ID>	fixed_point_m_token

   504

%token <ID>	integer_m_token

   505

%token <ID>	fixed_point_s_token

   506

%token <ID>	integer_s_token

   507

%token <ID>	fixed_point_ms_token