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

/*

    35

 * The private interface to stage1_2.cc 

    36

 */

    37

    38

    39

    40

/* !!! WARNING !!!

    41

 *

    42

 *       Whoever includes this file (stage1_2_priv.hh) will need

    43

 *       to first inlcude iec_bison.hh !!

    44

 *

    45

 *       Read other comments further down to understand why we don't

    46

 *       include iec_bison.hh in this file.

    47

 */

    48

    49

    50

    51

/* file with the declarations of symbol tables... */

    52

#include "../util/symtable.hh"

    53

#include "stage1_2.hh"

    54

    55

    56

/*

    57

 * This file includes the interface through which the lexical parser (stage 1 - flex)

    58

 * and the syntax analyser (stage 2 - bison) interact between themselves.

    59

 *

    60

 * This is mostly through direct access to shared global variables, however some

    61

 * of the global variables will only be accessed through some accessor functions.

    62

 *

    63

 * This file also includes the interface between the main stage1_2() functions and 

    64

 * the flex lexical parser.

    65

 *

    66

 * This file also includes some utility functions (strdupX() ) that are both used

    67

 * in the lexical and syntax analysers.

    68

 */

    69

    70

    71

    72

    73

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

    74

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

    75

/****                                                    *****/

    76

/****  I n t e r f a c e    B e t w e e n                *****/

    77

/****           F l e x    a n d     s t a g e 1 _ 2 ()  *****/

    78

/****                                                    *****/

    79

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

    80

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

    81

    82

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

    83

/* whether we are suporting safe extensions           */

    84

/* as defined in PLCopen - Technical Committee 5      */

    85

/* Safety Software Technical Specification,           */

    86

/* Part 1: Concepts and Function Blocks,              */

    87

/* Version 1.0 – Official Release                     */

    88

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

    89

bool get_opt_safe_extensions();

    90

    91

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

    92

/* whether to allow nested comments */

    93

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

    94

bool get_opt_nested_comments();

    95

    96

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

    97

/* whether to allow REF(), DREF(), REF_TO, NULL and ^ operators/keywords  */

    98

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

    99

bool get_opt_ref_standard_extensions();

   100

   101

   102

   103

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

   104

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

   105

/****                                                    *****/

   106

/****  I n t e r f a c e    B e t w e e n                *****/

   107

/****           F l e x    a n d     B i s o n           *****/

   108

/****                                                    *****/

   109

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

   110

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

   111

   112

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

   113

/* print the include file stack to stderr... */

   114

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

   115

/* This is a service that flex provides to bison... */

   116

void print_include_stack(void);

   117

   118

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

   119

/* Ask flex to include the source code in the string */

   120

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

   121

/* This is a service that flex provides to bison... */

   122

/* The string should contain valid IEC 61131-3 source code. Bison will ask flex to insert source 

   123

 * code into the input stream of IEC code being parsed. The code to be inserted is typically

   124

 * generated automatically.

   125

 * Currently this is used to insert conversion functions ***_TO_*** (as defined by the standard)

   126

 * between user defined (i.e. derived) enumerated datatypes, and some basic datatypes 

   127

 * (e.g. INT, STRING, etc...)

   128

 */

   129

void include_string(const char *source_code);

   130

   131

   132

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

   133

/* Tell flex which file to parse. */

   134

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

   135

/* This is a service that flex provides to bison... */

   136

/* Tell flex which file to parse. This function will not imediately start parsing the file.

   137

 * To parse the file, you then need to call yyparse()

   138

 *

   139

 * Returns NULL on error opening the file (and a valid errno), or 0 on success.

   140

 * Caller must close the file!

   141

 */

   142

FILE *parse_file(const char *filename);

   143

   144

   145

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

   146

/* whether bison is doing the pre-parsing, where POU bodies and var declarations are ignored! */

   147

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

   148

void set_preparse_state(void);

   149

void rst_preparse_state(void);

   150

bool get_preparse_state();  // returns true if bison is in preparse state

   151

   152

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

   153

/* Controlling the entry to the body_state in flex. */

   154

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

   155

void cmd_goto_body_state(void);

   156

int  get_goto_body_state(void);

   157

void rst_goto_body_state(void);

   158

   159

   160

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

   161

/* Controlling the entry to the sfc_qualifier_state in flex. */

   162

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

   163

void cmd_goto_sfc_qualifier_state(void);

   164

int  get_goto_sfc_qualifier_state(void);

   165

void rst_goto_sfc_qualifier_state(void);

   166

   167

   168

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

   169

/* Controlling the entry to the sfc_priority_state in flex.  */

   170

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

   171

void cmd_goto_sfc_priority_state(void);

   172

int  get_goto_sfc_priority_state(void);

   173

void rst_goto_sfc_priority_state(void);

   174

   175

   176

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

   177

/* Controlling the entry to the task_init_state in flex. */

   178

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

   179

void cmd_goto_task_init_state(void);

   180

int  get_goto_task_init_state(void);

   181

void rst_goto_task_init_state(void);

   182

   183

   184

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

   185

/* Returning to state in flex previously pushed onto the stack. */

   186

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

   187

void cmd_pop_state(void);

   188

int  get_pop_state(void);

   189

void rst_pop_state(void);

   190

   191

   192

   193

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

   194

/* The global symbol tables...   */

   195

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

   196

/* NOTE: only accessed indirectly by the lexical parser (flex)

   197

 *       through the function get_identifier_token()

   198

 *

   199

 *       Bison accesses these data structures directly.

   200

 *

   201

 *       In essence, they are a data passing mechanism between Bison and Flex.

   202

 */

   203

/* NOTE: BOGUS_TOKEN_ID is defined in the bison generated file iec_bison.hh.

   204

 *       We need this constant defined before we can declare the symbol tables.

   205

 *       However, we cannot #include "iec_bison.hh" in this file (stage1_2_priv.hh) directly

   206

 *       because of the way bison ver. 2.3 is copying all declarations in the prologue

   207

 *       of iec.y to the iec_bison.hh file (including an #include stage1_2_priv.hh).

   208

 *       So, if we were to include "iec_bison.hh" here, we would get a circular include.

   209

 *       All this means that whoever includes this file (stage1_2_priv.hh) will need

   210

 *       to take care to first inlcude iec_bison.hh !!

   211

 */ 

   212

/* A symbol table to store all the library elements */

   213

/* e.g.: <function_name , function_decl>

   214

 *       <fb_name , fb_decl>

   215

 *       <type_name , type_decl>

   216

 *       <program_name , program_decl>

   217

 *       <configuration_name , configuration_decl>

   218

 */

   219

extern symtable_c<int, BOGUS_TOKEN_ID> library_element_symtable;

   220

   221

/* A symbol table to store the declared variables of

   222

 * the function currently being parsed...

   223

 */

   224

extern symtable_c<int, BOGUS_TOKEN_ID> variable_name_symtable;

   225

   226

/* A symbol table to store the declared direct variables of

   227

 * the function currently being parsed...

   228

 */

   229

extern symtable_c<int, BOGUS_TOKEN_ID> direct_variable_symtable;

   230

   231

/* Function only called from within flex!

   232

 *

   233

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

   234

 * declared above, and return the token id of the first

   235

 * symbol found.

   236

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

   237

 * does it continue searching in the library elements

   238

 */

   239

int get_identifier_token(const char *identifier_str);

   240

   241

/* Function only called from within flex!

   242

 *

   243

 * search for a symbol in direct variables symbol table

   244

 * declared above, and return the token id of the first

   245

 * symbol found.

   246

 */

   247

int get_direct_variable_token(const char *direct_variable_str);

   248

   249

   250

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

   251

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

   252

/****                                                    *****/

   253

/****  U t i l i t y   F u n c t i o n s ...             *****/

   254

/****                                                    *****/

   255

/****                                                    *****/

   256

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

   257

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

   258

   259

/* Join two strings together. Allocate space with malloc(3). */

   260

char *strdup2(const char *a, const char *b);

   261

   262

/* Join three strings together. Allocate space with malloc(3). */

   263

char *strdup3(const char *a, const char *b, const char *c);

   264

   265

   266