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 the License, 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

/*

    34

 * The private interface to stage1_2.cc 

    35

 */

    36

    37

    38

    39

/* !!! WARNING !!!

    40

 *

    41

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

    42

 *       to first inlcude iec.y.hh !!

    43

 *

    44

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

    45

 *       include iec.y.hh in this file.

    46

 */

    47

    48

    49

    50

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

    51

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

    52

#include "stage1_2.hh"

    53

    54

    55

/*

    56

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

    57

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

    58

 *

    59

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

    60

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

    61

 *

    62

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

    63

 * the flex lexical parser.

    64

 *

    65

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

    66

 * in the lexical and syntax analysers.

    67

 */

    68

    69

    70

    71

    72

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

    73

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

    74

/****                                                    *****/

    75

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

    76

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

    77

/****                                                    *****/

    78

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

    79

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

    80

    81

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

    82

/* whether we are suporting safe extensions           */

    83

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

    84

/* Safety Software Technical Specification,           */

    85

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

    86

/* Version 1.0 – Official Release                     */

    87

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

    88

bool get_opt_safe_extensions();

    89

    90

    91

    92

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

    93

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

    94

/****                                                    *****/

    95

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

    96

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

    97

/****                                                    *****/

    98

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

    99

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

   100

   101

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

   102

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

   103

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

   104

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

   105

void print_include_stack(void);

   106

   107

   108

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

   109

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

   110

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

   111

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

   112

 * Note that flex accesses and updates this global variable

   113

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

   114

 * directive...

   115

 * ... and bison will use it when producing error messages.

   116

 * Note that bison also sets this variable correctly to the first

   117

 * file being parsed.

   118

 */

   119

extern const char *current_filename;

   120

   121

   122

#define MAX_BUFFER_LENGTH 1000

   123

   124

typedef struct {

   125

    int eof;

   126

    int lineNumber;

   127

    int currentChar;

   128

    int lineLength;

   129

    int currentTokenStart;

   130

    char* buffer;

   131

    FILE *in_file;

   132

  } tracking_t;

   133

   134

int GetNextChar(char *b, int maxBuffer);

   135

tracking_t* GetNewTracking(FILE* in_file);

   136

   137

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

   138

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

   139

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

   140

void cmd_goto_body_state(void);

   141

int  get_goto_body_state(void);

   142

void rst_goto_body_state(void);

   143

   144

   145

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

   146

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

   147

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

   148

void cmd_goto_sfc_qualifier_state(void);

   149

int  get_goto_sfc_qualifier_state(void);

   150

void rst_goto_sfc_qualifier_state(void);

   151

   152

   153

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

   154

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

   155

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

   156

void cmd_goto_sfc_priority_state(void);

   157

int  get_goto_sfc_priority_state(void);

   158

void rst_goto_sfc_priority_state(void);

   159

   160

   161

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

   162

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

   163

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

   164

void cmd_goto_task_init_state(void);

   165

int  get_goto_task_init_state(void);

   166

void rst_goto_task_init_state(void);

   167

   168

   169

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

   170

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

   171

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

   172

void cmd_pop_state(void);

   173

int  get_pop_state(void);

   174

void rst_pop_state(void);

   175

   176

   177

   178

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

   179

/* The global symbol tables...   */

   180

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

   181

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

   182

 *       through the function get_identifier_token()

   183

 *

   184

 *       Bison accesses these data structures directly.

   185

 *

   186

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

   187

 */

   188

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

   189

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

   190

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

   191

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

   192

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

   193

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

   194

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

   195

 *       to take care to first inlcude iec.y.hh !!

   196

 */ 

   197

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

   198

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

   199

 *       <fb_name , fb_decl>

   200

 *       <type_name , type_decl>

   201

 *       <program_name , program_decl>

   202

 *       <configuration_name , configuration_decl>

   203

 */

   204

extern symtable_c<int, BOGUS_TOKEN_ID> library_element_symtable;

   205

   206

/* A symbol table to store the declared variables of

   207

 * the function currently being parsed...

   208

 */

   209

extern symtable_c<int, BOGUS_TOKEN_ID> variable_name_symtable;

   210

   211

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

   212

 * the function currently being parsed...

   213

 */

   214

extern symtable_c<int, BOGUS_TOKEN_ID> direct_variable_symtable;

   215

   216

/* Function only called from within flex!

   217

 *

   218

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

   219

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

   220

 * symbol found.

   221

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

   222

 * does it continue searching in the library elements

   223

 */

   224

int get_identifier_token(const char *identifier_str);

   225

   226

/* Function only called from within flex!

   227

 *

   228

 * search for a symbol in direct variables symbol table

   229

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

   230

 * symbol found.

   231

 */

   232

int get_direct_variable_token(const char *direct_variable_str);

   233

   234

   235

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

   236

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

   237

/****                                                    *****/

   238

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

   239

/****                                                    *****/

   240

/****                                                    *****/

   241

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

   242

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

   243

   244

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

   245

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

   246

   247

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

   248

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

   249

   250

   251