1

/*

    19

 *

    20

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

    21

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

    22

 */

    23

    24

/*

    26

 *

    27

 * Based on the

    28

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

    29

 *

    30

 */

    31

    32

/*

    33

 * Stage 2

    34

 * =======

    35

 *

    36

 *  This file contains the syntax definition of the textual

    37

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

    38

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

    39

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

    40

 */

    41

    42

    43

    44

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

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

    53

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

    54

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

    55

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

    56

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

    57

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

    58

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

    59

    60

    61

    62

    63

%{

    64

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

    65

    66

    67

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

    68

int yylex(void);

    69

    70

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

    71

void yyerror (const char *error_msg);

    72

    73

/* produce a more verbose parsing error message */

    74

#define YYERROR_VERBOSE

    75

    76

/* Include debuging code.

    77

 * Printing of debug info must then be activated by setting

    78

 * the variable yydebug to 1.

    79

 */

    80

#define YYDEBUG 0

    81

    82

    83

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

    84

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

    85

    86

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

    87

#include "iec.y.hh"

    88

    89

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

    90

#include "stage1_2_priv.hh"

    91

    92

    93

/* an ugly hack!!

    94

 * We will probably not need it when we decide

    95

 *  to cut down the abstract syntax down to size.

    96

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

    97

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

    98

 *  we might just find out that we really do need

    99

 *  the abstract syntax tree to stay as it is

   100

 *  afterall!

   101

 */

   102

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

   103

 * execute the code <code>

   104

 */

   105

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

   106

  symbol_c *elem;					\

   107

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

   108

    elem = list->elements[i];				\

   109

    code;						\

   110

  }							\

   111

}

   112

   113

   114

   115

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

   116

 * creating a new object for the abstract syntax tree.

   117

 */

   118

#define locloc(foo) foo.first_line, foo.first_column, foo.last_line, foo.last_column

   119

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

   120

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

   121

   122

   123

   124

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

   125

#define ERROR error_exit(__FILE__,__LINE__)

   126

/* function defined in main.cc */

   127

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

   128

   129

   130

   131

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

   132

/* global variables...   */

   133

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

   134

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

   135

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

   136

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

   137

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

   138

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

   139

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

   140

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

   141

 */

   142

   143

   144

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

   145

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

   146

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

   147

 *       option is to use global variables! yuck!

   148

 */

   149

   150

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

   151

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

   152

 * but disallows them in user code...

   153

 */

   154

extern bool allow_function_overloading;

   155

   156

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

   157

 * when printing out error messages...

   158

 */

   159

extern bool full_token_loc;

   160

   161

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

   162

 * by bison.

   163

 */

   164

extern symbol_c *tree_root;

   165

   166

   167

   168

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

   169

/* forward declarations */

   170

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

   171

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

   172

   173

/* Convert an il_operator_c into an identifier_c */

   174

symbol_c *il_operator_c_2_identifier_c(symbol_c *il_operator);

   175

   176

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

   177

/* ERROR_CHECK_BEGIN */

   178

bool is_current_syntax_token();

   179

/* ERROR_CHECK_END */

   180

   181

/* print an error message */

   182

void print_err_msg(int first_line,

   183

                   int first_column,

   184

                   int last_line,

   185

                   int last_column,

   186

                   const char *additional_error_msg);

   187

%}

   188

   189

   190

   191

   192

// %glr-parser

   193

// %expect-rr 1

   194

   195

   196

   197

   198

%union {

   199

    symbol_c 	*leaf;

   200

    list_c	*list;

   201

    char 	*ID;	/* token value */

   202

}

   203

   204

/*

   205

 TODO: DO we need to define a destructor do free

   206

       memory when recovering from errors, or do the

   207

       class destructors already handle this?

   208

       Following is example on how to define

   209

       detructors, using the syntax:

   210

       %destructor { CODE } SYMBOLS

   211

%union

   212

      {

   213

        char *string;

   214

      }

   215

      %token <string> STRING

   216

      %type  <string> string

   217

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

   218

*/

   219

   220

   221

   222

   223

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

   224

/* Prelimenary helpful constructs... */

   225

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

   226

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

   227

 * after all includes have already been processed.

   228

 *

   229

 * Flex automatically returns the token with value 0

   230

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

   231

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

   232

 * to detect the very end of the input files.

   233

 */

   234

%token END_OF_INPUT 0

   235

   236

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

   237

/* USE 1:

   238

 * ======

   239

 * This token is currently also being used as the default

   240

 * initialisation value of the token_id member in

   241

 * the symbol_c base class.

   242

 *

   243

 * USE 2

   244

 * =====

   245

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

   246

 * mysterious reduce/reduce conflicts due to the fact

   247

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

   248

 * This means that bison cannot handle it without some

   249

 * caoxing from ourselves. We will then need this token

   250

 * to do the coaxing...

   251

 */

   252

%token BOGUS_TOKEN_ID

   253

   254

%type <leaf>	start

   255

   256

%type <leaf>	any_identifier

   257

   258

%token <ID>	prev_declared_variable_name_token

   259

%token <ID>	prev_declared_direct_variable_token

   260

%token <ID>	prev_declared_fb_name_token

   261

%type <leaf>	prev_declared_variable_name

   262

%type <leaf>	prev_declared_direct_variable

   263

%type <leaf>	prev_declared_fb_name

   264

   265

%token  <ID>	prev_declared_simple_type_name_token

   266

%token  <ID>	prev_declared_subrange_type_name_token

   267

%token  <ID>	prev_declared_enumerated_type_name_token

   268

%token  <ID>	prev_declared_array_type_name_token

   269

%token  <ID>	prev_declared_structure_type_name_token

   270

%token  <ID>	prev_declared_string_type_name_token

   271

   272

%type  <leaf>	prev_declared_simple_type_name

   273

%type  <leaf>	prev_declared_subrange_type_name

   274

%type  <leaf>	prev_declared_enumerated_type_name

   275

%type  <leaf>	prev_declared_array_type_name

   276

%type  <leaf>	prev_declared_structure_type_name

   277

%type  <leaf>	prev_declared_string_type_name

   278

   279

%token <ID>	prev_declared_derived_function_name_token

   280

%token <ID>	prev_declared_derived_function_block_name_token

   281

%token <ID>	prev_declared_program_type_name_token

   282

%type  <leaf>	prev_declared_derived_function_name

   283

%type  <leaf>	prev_declared_derived_function_block_name

   284

%type  <leaf>	prev_declared_program_type_name

   285

   286

   287

   288

   289

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

   290

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

   291

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

   292

   293

   294

/* The pragmas... */

   295

%token <ID>	pragma_token

   296

%type <leaf>	pragma

   297

   298

   299

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

   300

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

   301

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

   302

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

   303

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

   304

 */

   305

%token	EN

   306

%token	ENO

   307

%type <leaf>	en_identifier

   308

%type <leaf>	eno_identifier

   309

   310

   311

   312

   313

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

   314

/* B 0 - Programming Model */

   315

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

   316

%type <list>	library

   317

%type <leaf>	library_element_declaration

   318

   319

   320

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

   321

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

   322

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

   323

/* Done totally within flex...

   324

  letter

   325

  digit

   326

  octal_digit

   327

  hex_digit

   328

*/

   329

%token <ID>	identifier_token

   330

%type  <leaf>	identifier

   331

   332

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

   333

/* B 1.2 - Constants */

   334

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

   335

%type <leaf>	constant

   336

%type <leaf>	non_negative_constant

   337

   338

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

   339

/* B 1.2.1 - Numeric Literals */

   340

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

   341

/* Done totally within flex...

   342

  bit

   343

*/

   344

%type  <leaf> numeric_literal

   345

%type  <leaf> integer_literal

   346

%type  <leaf> signed_integer

   347

%token <ID>   integer_token

   348

%type  <leaf> integer

   349

%token <ID>   binary_integer_token

   350

%type  <leaf> binary_integer

   351

%token <ID>   octal_integer_token

   352

%type  <leaf> octal_integer

   353

%token <ID>   hex_integer_token

   354

%type  <leaf> hex_integer

   355

%token <ID>   real_token

   356

%type  <leaf> real

   357

%type  <leaf> signed_real

   358

%type  <leaf> real_literal

   359

// %type  <leaf> exponent

   360

%type  <leaf> bit_string_literal

   361

%type  <leaf> boolean_literal

   362

   363

%token safeboolean_true_literal_token

   364

%token safeboolean_false_literal_token

   365

%token boolean_true_literal_token

   366

%token boolean_false_literal_token

   367

   368

%token FALSE

   369

%token TRUE

   370

   371

   372

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

   373

/* B 1.2.2 - Character Strings */

   374

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

   375

%token <ID>   single_byte_character_string_token

   376

%token <ID>   double_byte_character_string_token

   377

   378

%type  <leaf> character_string

   379

%type  <leaf> single_byte_character_string

   380

%type  <leaf> double_byte_character_string

   381

   382

   383

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

   384

/* B 1.2.3 - Time Literals */

   385

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

   386

%type  <leaf> time_literal

   387

   388

   389

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

   390

/* B 1.2.3.1 - Duration */

   391

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

   392

%type  <leaf>	duration

   393

%type  <leaf>	interval

   394

%type  <leaf>	days

   395

%type  <leaf>	fixed_point

   396

%type  <leaf>	hours

   397

%type  <leaf>	minutes

   398

%type  <leaf>	seconds

   399

%type  <leaf>	milliseconds

   400

   401

%type  <leaf>	integer_d

   402

%type  <leaf>	integer_h

   403

%type  <leaf>	integer_m

   404

%type  <leaf>	integer_s

   405

%type  <leaf>	integer_ms

   406

%type  <leaf>	fixed_point_d

   407

%type  <leaf>	fixed_point_h

   408

%type  <leaf>	fixed_point_m

   409

%type  <leaf>	fixed_point_s

   410

%type  <leaf>	fixed_point_ms

   411

   412

%token <ID>	fixed_point_token

   413

%token <ID>	fixed_point_d_token

   414

%token <ID>	integer_d_token

   415

%token <ID>	fixed_point_h_token

   416

%token <ID>	integer_h_token

   417

%token <ID>	fixed_point_m_token

   418

%token <ID>	integer_m_token

   419

%token <ID>	fixed_point_s_token

   420

%token <ID>	integer_s_token

   421

%token <ID>	fixed_point_ms_token

   422

%token <ID>	integer_ms_token

   423

   424

// %token TIME

   425

%token T_SHARP

   426

   427

   428

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

   429

/* B 1.2.3.2 - Time of day and Date */

   430

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

   431

%type  <leaf>	time_of_day

   432

%type  <leaf>	daytime

   433

%type  <leaf>	day_hour

   434

%type  <leaf>	day_minute

   435

%type  <leaf>	day_second

   436

%type  <leaf>	date

   437

%type  <leaf>	date_literal

   438

%type  <leaf>	year

   439

%type  <leaf>	month

   440

%type  <leaf>	day

   441

%type  <leaf>	date_and_time

   442

   443

// %token TIME_OF_DAY

   444

// %token DATE

   445

%token D_SHARP

   446

// %token DATE_AND_TIME

   447

   448

   449

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

   450

/* B 1.3 - Data Types */

   451

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

   452

/* Strangely, the following symbol does seem to be required! */

   453

// %type  <leaf> data_type_name

   454

%type  <leaf> non_generic_type_name

   455

   456

   457

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

   458

/* B 1.3.1 - Elementary Data Types */

   459

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

   460

/* NOTES:

   461

 *

   462

 *    - To make the definition of bit_string_literal more

   463

 *      concise, it is useful to use an extra non-terminal

   464

 *      symbol (i.e. a grouping or construct) that groups the

   465

 *      following elements (BYTE, WORD, DWORD, LWORD).

   466

 *      Note that the definition of bit_string_type_name

   467

 *      (according to the spec) includes the above elements

   468

 *      and an extra BOOL.

   469

 *      We could use an extra construct with the first four

   470

 *      elements to be used solely in the definition of

   471

 *      bit_string_literal, but with the objective of not

   472

 *      having to replicate the actions (if we ever need

   473

 *      to change them, they would need to be changed in both

   474

 *      bit_string_type_name and the extra grouping), we

   475

 *      have re-defined bit_string_type_name as only including

   476

 *      the first four elements.

   477

 *      In order to have our parser implement the specification

   478

 *      correctly we have augmented every occurence of

   479

 *      bit_string_type_name in other rules with the BOOL

   480

 *      token. Since bit_string_type_name only appears in

   481

 *      the rule for elementary_type_name, this does not

   482

 *      seem to be a big concession to make!

   483

 *

   484

 *    - We have added a helper symbol to concentrate the

   485

 *      instantiation of STRING and WSTRING into a single

   486

 *      location (elementary_string_type_name).

   487

 *      These two elements show up in several other rules,

   488

 *      but we want to create the equivalent abstract syntax

   489

 *      in a single location of this file, in order to make

   490

 *      possible future changes easier to edit...

   491

 */

   492

%type  <leaf>	elementary_type_name

   493

%type  <leaf>	numeric_type_name

   494

%type  <leaf>	integer_type_name

   495

%type  <leaf>	signed_integer_type_name

   496

%type  <leaf>	unsigned_integer_type_name

   497

%type  <leaf>	real_type_name

   498

%type  <leaf>	date_type_name

   499

%type  <leaf>	bit_string_type_name

   500

/* helper symbol to concentrate the instantiation

   501

 * of STRING and WSTRING into a single location

   502

 */

   503

%type  <leaf>	elementary_string_type_name

   504

   505

%token BYTE

   506

%token WORD

   507

%token DWORD

   508

%token LWORD

   509

   510

%token LREAL

   511

%token REAL

   512

   513

%token SINT

   514

%token INT