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

 *

     6

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

     7

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

     8

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

     9

 *  (at your option) any later version.

    10

 *

    11

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

    12

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

    13

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    14

 *  GNU General Public License for more details.

    15

 *

    16

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

    17

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

    18

 *

    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

/*

    25

 * An IEC 61131-3 compiler.

    26

 *

    27

 * Based on the

    28

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

    29

 *

    30

 */

    31

    32

/*

    33

 * Stage 1

    34

 * =======

    35

 *

    36

 * This file contains the lexical tokens definitions, from which

    37

 * the flex utility will generate a lexical parser function.

    38

 */

    39

    40

    41

    42

    43

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

    44

/* Lexical Parser Options... */

    45

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

    46

    47

/* The lexical analyser will never work in interactive mode,

    48

 * i.e., it will only process programs saved to files, and never

    49

 * programs being written inter-actively by the user.

    50

 * This option saves the resulting parser from calling the

    51

 * isatty() function, that seems to be generating some compile

    52

 * errors under some (older?) versions of flex.

    53

 */

    54

%option never-interactive

    55

    56

/* Have the lexical analyser use a 'char *yytext' instead of an

    57

 * array of char 'char yytext[??]' to store the lexical token.

    58

 */

    59

%pointer

    60

    61

    62

/* Have the lexical analyser ignore the case of letters.

    63

 * This will occur for all the tokens and keywords, but

    64

 * the resulting text handed up to the syntax parser

    65

 * will not be changed, and keep the original case

    66

 * of the letters in the input file.

    67

 */

    68

%option case-insensitive

    69

    70

/* Have the generated lexical analyser keep track of the

    71

 * line number it is currently analysing.

    72

 * This is used to pass up to the syntax parser

    73

 * the number of the line on which the current

    74

 * token was found. It will enable the syntax parser

    75

 * to generate more informatve error messages...

    76

 */

    77

%option yylineno

    78

    79

/* required for the use of the yy_pop_state() and

    80

 * yy_push_state() functions

    81

 */

    82

%option stack

    83

    84

/* The '%option stack' also requests the inclusion of 

    85

 * the yy_top_state(), however this function is not

    86

 * currently being used. This means that the compiler

    87

 * is complaining about the existance of this function.

    88

 * The following option removes the yy_top_state()

    89

 * function from the resulting c code, so the compiler 

    90

 * no longer complains.

    91

 */

    92

%option noyy_top_state

    93

    94

/* We will be using unput() in our flex code, so we cannot set the following option!... */

    95

/*

    96

%option nounput

    97

*/

    98

    99

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

   100

/* External Variable and Function declarations... */

   101

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

   102

   103

   104

%{

   105

/* Define TEST_MAIN to include a main() function.

   106

 * Useful for testing the parser generated by flex.

   107

 */

   108

/*

   109

#define TEST_MAIN

   110

*/

   111

/* If lexical parser is compiled by itself, we need to define the following

   112

 * constant to some string. Under normal circumstances LIBDIRECTORY is set

   113

 * in the syntax parser header file...

   114

 */

   115

#ifdef TEST_MAIN

   116

#define DEFAULT_LIBDIR "just_testing"

   117

#endif

   118

   119

   120

   121

/* Required for strdup() */

   122

#include <string.h>

   123

   124

/* Required only for the declaration of abstract syntax classes

   125

 * (class symbol_c; class token_c; class list_c;)

   126

 * These will not be used in flex, but the token type union defined

   127

 * in iec_bison.hh contains pointers to these classes, so we must include

   128

 * it here.

   129

 */

   130

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

   131

   132

   133

/* iec_bison.hh is generated by bison.

   134

 * Contains the definition of the token constants, and the

   135

 * token value type YYSTYPE (in our case, a 'const char *')

   136

 */

   137

#include "iec_bison.hh"

   138

#include "stage1_2_priv.hh"

   139

   140

   141

/* Variable defined by the bison parser,

   142

 * where the value of the tokens will be stored

   143

 */

   144

extern YYSTYPE yylval;

   145

   146

/* The name of the file currently being parsed...

   147

 * Note that flex accesses and updates this global variable

   148

 * apropriately whenever it comes across an (*#include <filename> *) directive...

   149

 */

   150

const char *current_filename = NULL;

   151

   152

   153

   154

/* Variable defined by the bison parser.

   155

 * It must be initialised with the location

   156

 * of the token being parsed.

   157

 * This is only needed if we want to keep

   158

 * track of the locations, in order to give

   159

 * more meaningful error messages!

   160

 */

   161

/*

   162

 *extern YYLTYPE yylloc;

   163

b*/

   164

#define YY_INPUT(buf,result,max_size)  {\

   165

    result = GetNextChar(buf, max_size);\

   166

    if (  result <= 0  )\

   167

      result = YY_NULL;\

   168

    }

   169

   170

   171

/* Macro that is executed for every action.

   172

 * We use it to pass the location of the token

   173

 * back to the bison parser...

   174

 */

   175

#define YY_USER_ACTION {\

   176

	yylloc.first_line = current_tracking->lineNumber;			\

   177

	yylloc.first_column = current_tracking->currentTokenStart;		\

   178

	yylloc.first_file = current_filename;					\

   179

	yylloc.first_order = current_order;					\

   180

	yylloc.last_line = current_tracking->lineNumber;			\

   181

	yylloc.last_column = current_tracking->currentChar - 1;			\

   182

	yylloc.last_file = current_filename;					\

   183

	yylloc.last_order = current_order;					\

   184

	current_tracking->currentTokenStart = current_tracking->currentChar;	\

   185

	current_order++;							\

   186

	}

   187

   188

   189

   190

/* Since this lexical parser we defined only works in ASCII based

   191

 * systems, we might as well make sure it is being compiled on

   192

 * one...

   193

 * Lets check a few random characters...

   194

 */

   195

#if (('a' != 0x61) || ('A' != 0x41) || ('z' != 0x7A) || ('Z' != 0x5A) || \

   196

     ('0' != 0x30) || ('9' != 0x39) || ('(' != 0x28) || ('[' != 0x5B))

   197

#error This lexical analyser is not portable to a non ASCII based system.

   198

#endif

   199

   200

   201

/* Function only called from within flex, but defined

   202

 * in iec.y!

   203

 * We declare it here...

   204

 *

   205

 * Search for a symbol in either of the two symbol tables

   206

 * and return the token id of the first symbol found.

   207

 * Searches first in the variables, and only if not found

   208

 * does it continue searching in the library elements

   209

 */

   210

//token_id_t get_identifier_token(const char *identifier_str);

   211

int get_identifier_token(const char *identifier_str);

   212

%}

   213

   214

   215

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

   216

/* Forward Declaration of functions defined later. */

   217

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

   218

   219

%{

   220

/* return all the text in the current token back to the input stream. */

   221

void unput_text(unsigned int n);

   222

/* return all the text in the current token back to the input stream, 

   223

 * but first return to the stream an additional character to mark the end of the token. 

   224

 */

   225

void unput_and_mark(const char c);

   226

   227

void include_file(const char *include_filename);

   228

   229

/* The body_state tries to find a ';' before a END_PROGRAM, END_FUNCTION or END_FUNCTION_BLOCK or END_ACTION

   230

 * To do so, it must ignore comments and pragmas. This means that we cannot do this in a signle lex rule.

   231

 * However, we must store any text we consume in every rule, so we can push it back into the buffer

   232

 * once we have decided if we are parsing ST or IL code. The following functions manage that buffer used by

   233

 * the body_state.

   234

 */

   235

void  append_bodystate_buffer(const char *yytext);

   236

void   unput_bodystate_buffer(void);

   237

int  isempty_bodystate_buffer(void);

   238

   239

int GetNextChar(char *b, int maxBuffer);

   240

%}

   241

   242

   243

   244

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

   245

/* Lexical Parser States... */

   246

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

   247

   248

/* NOTE: Our psrser can parse st or il code, intermixed

   249

 *       within the same file.

   250

 *       With IL we come across the issue of the EOL (end of line) token.

   251

 *       ST, and the declaration parts of IL do not use this token!

   252

 *       If the lexical analyser were to issue this token during ST

   253

 *       language parsing, or during the declaration of data types,

   254

 *       function headers, etc. in IL, the syntax parser would crash.

   255

 *

   256

 *       We can solve this issue using one of three methods:

   257

 *        (1) Augment all the syntax that does not accept the EOL

   258

 *            token to simply ignore it. This makes the syntax

   259

 *            definition (in iec.y) very cluttered!

   260

 *        (2) Let the lexical parser figure out which language

   261

 *            it is parsing, and decide whether or not to issue

   262

 *            the EOL token. This requires the lexical parser

   263

 *            to have knowledge of the syntax!, making for a poor

   264

 *            overall organisation of the code. It would also make it

   265

 *            very difficult to understand the lexical parser as it

   266

 *            would use several states, and a state machine to transition

   267

 *            between the states. The state transitions would be

   268

 *            intermingled with the lexical parser defintion!

   269

 *        (3) Use a mixture of (1) and (2). The lexical analyser

   270

 *            merely distinguishes between function headers and function

   271

 *            bodies, but no longer makes a distinction between il and

   272

 *            st language bodies. When parsing a body, it will return

   273

 *            the EOL token. In other states '\n' will be ignored as

   274

 *            whitespace.

   275

 *            The ST language syntax has been augmented in the syntax

   276

 *            parser configuration to ignore any EOL tokens that it may

   277

 *            come across!

   278

 *            This option has both drawbacks of option (1) and (2), but

   279

 *            much less intensely.

   280

 *            The syntax that gets cluttered is limited to the ST statements

   281

 *            (which is rather limited, compared to the function headers and

   282

 *            data type declarations, etc...), while the state machine in

   283

 *            the lexical parser becomes very simple. All state transitions

   284

 *            can be handled within the lexical parser by itself, and can be

   285

 *            easily identified. Thus knowledge of the syntax required by

   286

 *            the lexical parser is very limited!

   287

 *

   288

 * Amazingly enough, I (Mario) got to implement option (3)

   289

 * at first, requiring two basic states, decl and body.

   290

 * The lexical parser will enter the body state when

   291

 * it is parsing the body of a function/program/function block. The

   292

 * state transition is done when we find a VAR_END that is not followed

   293

 * by a VAR! This is the syntax knowledge that gets included in the

   294

 * lexical analyser with this option!

   295

 * Unfortunately, getting the st syntax parser to ignore EOL anywhere

   296

 * where they might appear leads to conflicts. This is due to the fact

   297

 * that the syntax parser uses the single look-ahead token to remove

   298

 * possible conflicts. When we insert a possible EOL, the single

   299

 * look ahead token becomes the EOL, which means the potential conflicts

   300

 * could no longer be resolved.

   301

 * Removing these conflicts would make the st syntax parser very convoluted,

   302

 * and adding the extraneous EOL would make it very cluttered.

   303

 * This option was therefore dropped in favour of another!

   304

 *

   305

 * I ended up implementing (2). Unfortunately the lexical analyser can

   306

 * not easily distinguish between il and st code, since function

   307

 * calls in il are very similar to function block calls in st.

   308

 * We therefore use an extra 'body' state. When the lexical parser

   309

 * finds that last END_VAR, it enters the body state. This state

   310

 * must figure out what language is being parsed from the first few

   311

 * tokens, and switch to the correct state (st, il or sfc) according to the

   312

 * language. This means that we insert quite a bit of knowledge of the

   313

 * syntax of the languages into the lexical parser. This is ugly, but it

   314

 * works, and at least it is possible to keep all the state changes together

   315

 * to make it easier to remove them later on if need be.

   316

 * Once the language being parsed has been identified, 

   317

 * the body state returns any matched text back to the buffer with unput(),

   318

 * to be later matched correctly by the apropriate language parser (st, il or sfc).

   319

 *

   320

 * Aditionally, in sfc state it may further recursively enter the body state

   321

 * once again. This is because an sfc body may contain ACTIONS, which are then

   322

 * written in one of the three languages (ST, IL or SFC), so once again we need

   323

 * to figure out which language the ACTION in the SFC was written in. We already

   324

 * ahve all that done in the body state, so we recursively transition to the body 

   325

 * state once again.

   326

 * Note that in this case, when coming out of the st/il state (whichever language

   327

 * the action was written in) the sfc state will become active again. This is done by

   328

 * pushing and poping the previously active state!

   329

 *

   330

 * The sfc_qualifier_state is required because when parsing actions within an

   331

 * sfc, we will be expecting action qualifiers (N, P, R, S, DS, SD, ...). In order

   332

 * to bison to work correctly, these qualifiers must be returned as tokens. However,

   333

 * these tokens are not reserved keywords, which means it should be possible to

   334

 * define variables/functions/FBs with any of these names (including 

   335

 * S and R which are special because they are also IL operators). So, when we are not

   336

 * expecting any action qualifiers, flex does not return these tokens, and is free

   337

 * to interpret them as previously defined variables/functions/... as the case may be.

   338

 *

   339

 * The time_literal_state is required because TIME# literals are decomposed into 

   340

 * portions, and wewant to send these portions one by one to bison. Each poertion will 

   341

 * represent the value in days/hours/minutes/seconds/ms.

   342

 * Unfortunately, some of these portions may also be lexically analysed as an identifier. So,

   343

 * we need to disable lexical identification of identifiers while parsing TIME# literals!

   344

 * e.g.:  TIME#55d_4h_56m

   345

 *       We would like to return to bison the tokens 'TIME' '#' '55d' '_' '4h' '_' '56m'

   346

 *       Unfortunately, flex will join '_' and '4h' to create a legal {identifier} '_4h',

   347

 *       and return that identifier instead! So, we added this state!

   348

 *

   349

 * The ignore_pou_state state is only used when bison says it is doing the pre-parsing.

   350

 * During pre-parsing, the main state machine will only transition between

   351

 * INITIAL and ignore_pou_state, and from here back to INITIAL. All other

   352

 * transitions are inhibited. This inhibition is actually just enforced by making

   353

 * sure that the INITIAL ---> ignore_pou_state transition is tested before all other

   354

 * transitions coming out of INITIAL state. All other transitions are unaffected, as they

   355

 * never get a chance to be evaluated when bison is doing pre-parsing.

   356

 * Pre-parsing is a first quick scan through the whole input source code simply

   357

 * to determine the list of POUs and datatypes that will be defined in that

   358

 * code. Basically, the objective is to fill up the previously_declared_xxxxx

   359

 * maps, without processing the code itself. Once these maps have been filled up,

   360

 * bison will throw away the AST (abstract syntax tree) created up to that point, 

   361

 * and scan through the same source code again, but this time creating a correct AST.

   362

 * This pre-scan allows the source code to reference POUs and datatypes that are

   363

 * only declared after they are used!

   364

 * 

   365

 *

   366

 * Here is a main state machine...

   367

 *                                                                         --+  

   368

 *                                                                           |  these states are

   369

 *              +------------> get_pou_name_state  ----> ignore_pou_state    |  only active 

   370

 *              |                                            |               |  when bison is 

   371

 *              |  ------------------------------------------+               |  doing the 

   372

 *              |  |                                                         |  pre-parsing!!

   373

 *              |  v                                                       --+

   374

 *       +---> INITIAL <-------> config

   375

 *       |        \

   376

 *       |        V

   377

 *       |   header_state

   378

 *       |        |

   379

 *       |        V

   380

 *     vardecl_list_state <------> var_decl

   381

 *       ^        | 

   382

 *       |        | [using push()]

   383

 *       |        |

   384

 *       |        V

   385

 *       |       body, 

   386

 *       |        |

   387

 *       |        | 

   388

 *       |   -------------------

   389

 *       |   |       |         |

   390

 *       |   v       v         v

   391

 *       |  st      il        sfc

   392

 *       |   |       |         |  [using pop() when leaving st/il/sfc => goes to vardecl_list_state]

   393

 *       |   |       |         |

   394

 *       -----------------------

   395

 *

   396

 * NOTE:- When inside sfc, and an action or transition in ST/IL is found, then 

   397

 *        we also push() to the body state. This means that sometimes, when pop()ing

   398

 *        from st and il, the state machine may return to the sfc state!

   399

 *      - The transitions form sfc to body will be decided by bison, which will

   400

 *        tell flex to do the transition by calling cmd_goto_body_state().

   401

 *   

   402

 * 

   403

 * Possible state changes are:

   404

 *   INITIAL -> goto(ignore_pou_state)

   405

 *               (This transition state is only used when bison says it is doing the pre-parsing.)

   406

 *               (This transition takes precedence over all other transitions!)

   407

 *               (when a FUNCTION, FUNCTION_BLOCK, PROGRAM or CONFIGURATION is found)

   408

 * 

   409

 *   INITIAL -> goto(config_state)

   410

 *                (when a CONFIGURATION is found)

   411

 * 

   412

 *   INITIAL -> goto(header_state)

   413

 *               (when a FUNCTION, FUNCTION_BLOCK, or PROGRAM is found)

   414

 * 

   415

 *   header_state -> goto(vardecl_list_state)

   416

 *               (When the first VAR token is found, i.e. at begining of first VAR .. END_VAR declaration)

   417

 * 

   418

 *  vardecl_list_state -> push current state (vardecl_list_state), and goto(vardecl_state) 

   419

 *                (when a VAR token is found)

   420

 *   vardecl_state -> pop() to (vardecl_list_state) 

   421

 *                (when a END_VAR token is found)

   422

 * 

   423

 *   vardecl_list_state -> push current state (vardecl_list_state), and goto(body_state) 

   424

 *                (when the last END_VAR is found!)

   425

 *

   426

 *   body_state    -> goto(sfc_state)

   427

 *                     (when it figures out it is parsing sfc language)

   428

 *   body_state    -> goto(st_state)

   429

 *                     (when it figures out it is parsing st language)

   430

 *   body_state    -> goto(il_state)

   431

 *                     (when it figures out it is parsing il language)

   432

 *   st_state      -> pop() to vardecl_list_state

   433

 *                     (when a END_FUNCTION, END_FUNCTION_BLOCK, END_PROGRAM,

   434

 *                      END_ACTION or END_TRANSITION is found)

   435

 *   il_state      -> pop() to vardecl_list_state

   436

 *                     (when a END_FUNCTION, END_FUNCTION_BLOCK, END_PROGRAM,

   437

 *                      END_ACTION or END_TRANSITION is found)

   438

 *   sfc_state     -> pop() to vardecl_list_state

   439

 *                     (when a END_FUNCTION, END_FUNCTION_BLOCK, or END_PROGRAM is found)

   440

 * 

   441

 *   ignore_pou_state   -> goto(INITIAL)

   442

 *                         (when a END_FUNCTION, END_FUNCTION_BLOCK, END_PROGRAM or END_CONFIGURATION is found)

   443

 *   vardecl_list_state -> goto(INITIAL)

   444

 *                         (when a END_FUNCTION, END_FUNCTION_BLOCK, or END_PROGRAM is found)

   445

 *   config_state       -> goto(INITIAL)

   446

 *                         (when a END_CONFIGURATION is found)

   447

 * 

   448

 *  

   449

 *   sfc_state     -> push current state(sfc_state); goto(body_state)

   450

 *                     (when parsing an action. This transition is requested by bison)

   451

 *   sfc_state     -> push current state(sfc_state); goto(sfc_qualifier_state)

   452

 *                     (when expecting an action qualifier. This transition is requested by bison)

   453

 *   sfc_qualifier_state -> pop() to sfc_state

   454

 *                     (when no longer expecting an action qualifier. This transition is requested by bison)

   455

 *

   456

 *   config_state  -> push(config_state); goto(task_init_state)

   457

 *                     (when parsing a task initialisation. This transition is requested by bison)

   458

 *   task_init_state -> pop()

   459

 *                     (when no longer parsing task initialisation parameters. This transition is requested by bison)

   460

 *

   461

 * 

   462

 * There is another secondary state machine for parsing comments, another for file_includes, 

   463

 * and yet another for time literals.

   464

 */

   465

   466

   467

/* Bison is in the pre-parsing stage, and we are parsing a POU. Ignore everything up to the end of the POU! */

   468

%x ignore_pou_state

   469

%x get_pou_name_state

   470

   471

/* we are parsing a configuration. */

   472

%s config_state

   473

   474

/* Inside a configuration, we are parsing a task initialisation parameters */

   475

/* This means that PRIORITY, SINGLE and INTERVAL must be handled as

   476

 * tokens, and not as possible identifiers. Note that the above words

   477

 * are not keywords.

   478

 */

   479

%s task_init_state

   480

   481

/* we are looking for the first VAR inside a function's, program's or function block's declaration */

   482

/* This is not exclusive (%x) as we must be able to parse the identifier and data types of a function/FB */

   483

%s header_state

   484

   485

/* we are parsing a function, program or function block sequence of VAR..END_VAR delcarations */

   486

%x vardecl_list_state 

   487

/* a substate of the vardecl_list_state: we are inside a specific VAR .. END_VAR */

   488

%s vardecl_state

   489

   490

/* we will be parsing a function body/action/transition. Whether il/st/sfc remains to be determined */

   491

%x body_state

   492

   493

/* we are parsing il code -> flex must return the EOL tokens!       */

   494

%s il_state

   495

   496

/* we are parsing st code -> flex must not return the EOL tokens!   */

   497

%s st_state

   498

   499

/* we are parsing sfc code -> flex must not return the EOL tokens!  */

   500

%s sfc_state

   501

   502

/* we are parsing sfc code, and expecting an action qualifier.      */

   503

%s sfc_qualifier_state

   504

   505

/* we are parsing sfc code, and expecting the priority token.       */