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

    89

    90

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

    91

#include "stage1_2_priv.hh"

    92

    93

    94

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

    95

    96

/* an ugly hack!!

    97

 * We will probably not need it when we decide

    98

 *  to cut down the abstract syntax down to size.

    99

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

   100

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

   101

 *  we might just find out that we really do need

   102

 *  the abstract syntax tree to stay as it is

   103

 *  afterall!

   104

 */

   105

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

   106

 * execute the code <code>

   107

 */

   108

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

   109

  symbol_c *elem;					\

   110

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

   111

    elem = list->elements[i];				\

   112

    code;						\

   113

  }							\

   114

}

   115

   116

   117

   118

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

   119

 * creating a new object for the abstract syntax tree.

   120

 */

   121

#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

   122

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

   123

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

   124

   125

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

   126

# define YYLLOC_DEFAULT(Current, Rhs, N)                                \

   127

         do                                                                  \

   128

           if (N)                                                            \

   129

             {                                                               \

   130

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

   131

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

   132

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

   133

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

   134

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

   135

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

   136

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

   137

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

   138

             }                                                               \

   139

           else                                                              \

   140

             {                                                               \

   141

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

   142

                 YYRHSLOC(Rhs, 0).last_line;                                 \

   143

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

   144

                 YYRHSLOC(Rhs, 0).last_column;                               \

   145

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

   146

                 YYRHSLOC(Rhs, 0).last_file;                                 \

   147

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

   148

                 YYRHSLOC(Rhs, 0).last_order;                                \

   149

             }                                                               \

   150

         while (0)

   151

   152

   153

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

   154

#define ERROR error_exit(__FILE__,__LINE__)

   155

/* function defined in main.cc */

   156

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

   157

   158

   159

   160

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

   161

/* global variables...   */

   162

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

   163

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

   164

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

   165

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

   166

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

   167

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

   168

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

   169

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

   170

 */

   171

   172

   173

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

   174

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

   175

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

   176

 *       option is to use global variables! yuck!

   177

 */

   178

   179

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

   180

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

   181

 * but disallows them in user code...

   182

 */

   183

extern bool allow_function_overloading;

   184

   185

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

   186

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

   187

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

   188

 * This is an extension to the standard syntax.

   189

 * See comments below for details why we support this!

   190

 */

   191

extern bool allow_extensible_function_parameters;

   192

   193

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

   194

 * when printing out error messages...

   195

 */

   196

extern bool full_token_loc;

   197

   198

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

   199

 * by bison.

   200

 */

   201

extern symbol_c *tree_root;

   202

   203

   204

   205

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

   206

/* forward declarations */

   207

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

   208

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

   209

   210

/* Convert an il_operator_c into an identifier_c */

   211

symbol_c *il_operator_c_2_identifier_c(symbol_c *il_operator);

   212

   213

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

   214

/* ERROR_CHECK_BEGIN */

   215

bool is_current_syntax_token();

   216

/* ERROR_CHECK_END */

   217

   218

/* print an error message */

   219

void print_err_msg(int first_line,

   220

                   int first_column,

   221

                   const char *first_filename,

   222

                   long int first_order,

   223

                   int last_line,

   224

                   int last_column,

   225

                   const char *last_filename,

   226

                   long int last_order,

   227

                   const char *additional_error_msg);

   228

%}

   229

   230

   231

   232

   233

// %glr-parser

   234

// %expect-rr 1

   235

   236

   237

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

   238

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

   239

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

   240

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

   241

 */

   242

%code requires {

   243

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

   244

 * the filename in which the token is expressed.

   245

 */

   246

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

   247

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

   248

 * declaring the typedef struct yyltype__local here would result in a 

   249

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

   250

 * declared twice.

   251

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

   252

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

   253

 */

   254

#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED

   256

    int         first_line;

   257

    int         first_column;

   258

    const char *first_file;

   259

    long int    first_order;

   260

    int         last_line;

   261

    int         last_column;

   262

    const char *last_file;

   263

    long int    last_order;

   267

#endif

   269

}

   270

   271

   272

   273

%union {

   274

    symbol_c 	*leaf;

   275

    list_c	*list;

   276

    char 	*ID;	/* token value */

   277

}

   278

   279

/*

   280

 TODO: DO we need to define a destructor do free

   281

       memory when recovering from errors, or do the

   282

       class destructors already handle this?

   283

       Following is example on how to define

   284

       detructors, using the syntax:

   285

       %destructor { CODE } SYMBOLS

   286

%union

   287

      {

   288

        char *string;

   289

      }

   290

      %token <string> STRING

   291

      %type  <string> string

   292

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

   293

*/

   294

   295

   296

   297

   298

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

   299

/* Prelimenary helpful constructs... */

   300

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

   301

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

   302

 * after all includes have already been processed.

   303

 *

   304

 * Flex automatically returns the token with value 0

   305

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

   306

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

   307

 * to detect the very end of the input files.

   308

 */

   309

%token END_OF_INPUT 0

   310

   311

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

   312

/* USE 1:

   313

 * ======

   314

 * This token is currently also being used as the default

   315

 * initialisation value of the token_id member in

   316

 * the symbol_c base class.

   317

 *

   318

 * USE 2

   319

 * =====

   320

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

   321

 * mysterious reduce/reduce conflicts due to the fact

   322

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

   323

 * This means that bison cannot handle it without some

   324

 * caoxing from ourselves. We will then need this token

   325

 * to do the coaxing...

   326

 */

   327

%token BOGUS_TOKEN_ID

   328

   329

%type <leaf>	start

   330

   331

%type <leaf>	any_identifier

   332

   333

%token <ID>	prev_declared_variable_name_token

   334

%token <ID>	prev_declared_direct_variable_token

   335

%token <ID>	prev_declared_fb_name_token

   336

%type <leaf>	prev_declared_variable_name

   337

%type <leaf>	prev_declared_direct_variable

   338

%type <leaf>	prev_declared_fb_name

   339

   340

%token  <ID>	prev_declared_simple_type_name_token

   341

%token  <ID>	prev_declared_subrange_type_name_token

   342

%token  <ID>	prev_declared_enumerated_type_name_token

   343

%token  <ID>	prev_declared_array_type_name_token

   344

%token  <ID>	prev_declared_structure_type_name_token

   345

%token  <ID>	prev_declared_string_type_name_token

   346

   347

%type  <leaf>	prev_declared_simple_type_name

   348

%type  <leaf>	prev_declared_subrange_type_name

   349

%type  <leaf>	prev_declared_enumerated_type_name

   350

%type  <leaf>	prev_declared_array_type_name

   351

%type  <leaf>	prev_declared_structure_type_name

   352

%type  <leaf>	prev_declared_string_type_name

   353

   354

%token <ID>	prev_declared_derived_function_name_token

   355

%token <ID>	prev_declared_derived_function_block_name_token

   356

%token <ID>	prev_declared_program_type_name_token

   357

%type  <leaf>	prev_declared_derived_function_name

   358

%type  <leaf>	prev_declared_derived_function_block_name

   359

%type  <leaf>	prev_declared_program_type_name

   360

   361

   362

   363

   364

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

   365

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

   366

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

   367

   368

/* Pragmas that our compiler will accept.

   369

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

   370

 */

   371

%token          disable_code_generation_pragma_token

   372

%token          enable_code_generation_pragma_token

   373

%type <leaf>	disable_code_generation_pragma

   374

%type <leaf>	enable_code_generation_pragma

   375

   376

   377

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

   378

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

   379

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

   380

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

   381

 */

   382

%token <ID>	pragma_token

   383

%type <leaf>	pragma

   384

   385

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

   386

%type <leaf>	any_pragma

   387

   388

   389

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

   390

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

   391

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

   392

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

   393

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

   394

 *

   395

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

   396

 */

   397

%token	EN

   398

%token	ENO

   399

%type <leaf>	en_identifier

   400

%type <leaf>	eno_identifier

   401

   402

   403

   404

   405

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

   406

/* B 0 - Programming Model */

   407

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

   408

%type <list>	library

   409

%type <leaf>	library_element_declaration

   410

   411

   412

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

   413

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

   414

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

   415

/* Done totally within flex...

   416

  letter

   417

  digit

   418

  octal_digit

   419

  hex_digit

   420

*/

   421

%token <ID>	identifier_token

   422

%type  <leaf>	identifier

   423

   424

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

   425

/* B 1.2 - Constants */

   426

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

   427

%type <leaf>	constant

   428

%type <leaf>	non_negative_constant

   429

   430

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

   431

/* B 1.2.1 - Numeric Literals */

   432

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

   433

/* Done totally within flex...

   434

  bit

   435

*/

   436

%type  <leaf> numeric_literal

   437

%type  <leaf> integer_literal

   438

%type  <leaf> signed_integer

   439

%token <ID>   integer_token

   440

%type  <leaf> integer

   441

%token <ID>   binary_integer_token

   442

%type  <leaf> binary_integer

   443

%token <ID>   octal_integer_token

   444

%type  <leaf> octal_integer

   445

%token <ID>   hex_integer_token

   446

%type  <leaf> hex_integer

   447

%token <ID>   real_token

   448

%type  <leaf> real

   449

%type  <leaf> signed_real

   450

%type  <leaf> real_literal

   451

// %type  <leaf> exponent

   452

%type  <leaf> bit_string_literal

   453

%type  <leaf> boolean_literal

   454

   455

%token safeboolean_true_literal_token

   456

%token safeboolean_false_literal_token

   457

%token boolean_true_literal_token

   458

%token boolean_false_literal_token

   459

   460

%token FALSE

   461

%token TRUE

   462

   463

   464

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

   465

/* B 1.2.2 - Character Strings */

   466

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

   467

%token <ID>   single_byte_character_string_token

   468

%token <ID>   double_byte_character_string_token

   469

   470

%type  <leaf> character_string

   471

%type  <leaf> single_byte_character_string

   472

%type  <leaf> double_byte_character_string

   473

   474

   475

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

   476

/* B 1.2.3 - Time Literals */

   477

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

   478

%type  <leaf> time_literal

   479

   480

   481

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

   482

/* B 1.2.3.1 - Duration */

   483

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

   484

%type  <leaf>	duration

   485

%type  <leaf>	interval

   486

%type  <leaf>	days

   487

%type  <leaf>	fixed_point

   488

%type  <leaf>	hours

   489

%type  <leaf>	minutes

   490

%type  <leaf>	seconds

   491

%type  <leaf>	milliseconds

   492

   493

%type  <leaf>	integer_d

   494

%type  <leaf>	integer_h

   495

%type  <leaf>	integer_m

   496

%type  <leaf>	integer_s

   497

%type  <leaf>	integer_ms

   498

%type  <leaf>	fixed_point_d

   499

%type  <leaf>	fixed_point_h

   500

%type  <leaf>	fixed_point_m

   501

%type  <leaf>	fixed_point_s

   502

%type  <leaf>	fixed_point_ms

   503

   504

%token <ID>	fixed_point_token

   505

%token <ID>	fixed_point_d_token

   506