1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *  Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)

     4

 *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant

     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

 * Declaration of the Abstract Syntax data structure components

    34

 */

    35

    36

/*

    37

 * ABSYNTAX.H

    38

 *

    39

 * This generates the parse tree structure used to bind the components

    40

 * identified by Bison in the correct syntax order. At the end of the

    41

 * Bison analysis the tree is walked in a sequential fashion generating

    42

 * the relavent code.

    43

 */

    44

    45

#ifndef _ABSYNTAX_HH

    46

#define _ABSYNTAX_HH

    47

    48

    49

#include <stdio.h> // required for NULL

    50

#include <vector>

    51

#include <string>

    52

#include <stdint.h>  // required for uint64_t, etc...

    53

#include "../main.hh" // required for uint8_t, real_64_t, ..., and the macros INT8_MAX, REAL32_MAX, ... */

    54

    55

    56

    57

    58

/* Forward declaration of the visitor interface

    59

 * declared in the visitor.hh file

    60

 * We cannot include the visitor.hh file, as it will

    61

 * include this same file first, as it too requires references

    62

 * to the abstract syntax classes defined here.

    63

 */

    64

class visitor_c; // forward declaration

    65

    66

    67

class symbol_c; // forward declaration

    68

    69

    70

    71

    72

    73

    74

    75

    76

    77

    78

    79

/* The base class of all symbols */

    80

class symbol_c {

    81

    82

  public:

    83

    /*

    84

     * Line number for the purposes of error checking.

    85

     * Annotated (inserted) by stage1_2

    86

     */

    87

    int first_line;

    88

    int first_column;

    89

    const char *first_file;  /* filename referenced by first line/column */

    90

    long int first_order;    /* relative order in which it is read by lexcial analyser */

    91

    int last_line;

    92

    int last_column;

    93

    const char *last_file;  /* filename referenced by last line/column */

    94

    long int last_order;    /* relative order in which it is read by lexcial analyser */

    95

    96

    97

    /*

    98

     * Annotations produced during stage 3

    99

     */

   100

    /*** Data type analysis ***/

   101

    std::vector <symbol_c *> candidate_datatypes; /* All possible data types the expression/literal/etc. may take. Filled in stage3 by fill_candidate_datatypes_c class */

   102

    /* Data type of the expression/literal/etc. Filled in stage3 by narrow_candidate_datatypes_c 

   103

     * If set to NULL, it means it has not yet been evaluated.

   104

     * If it points to an object of type invalid_type_name_c, it means it is invalid.

   105

     * Otherwise, it points to an object of the apropriate data type (e.g. int_type_name_c, bool_type_name_c, ...)

   106

     */

   107

    symbol_c *datatype;

   108

   109

    /*** constant folding ***/

   110

    /* During stage 3 (semantic analysis/checking) we will be doing constant folding.

   111

     * That algorithm will anotate the abstract syntax tree with the result of operations

   112

     * on literals (i.e. 44 + 55 will store the result 99).

   113

     * Since the same source code (e.g. 1 + 0) may actually be a BOOL or an ANY_INT,

   114

     * or an ANY_BIT, we need to handle all possibilities, and determine the result of the

   115

     * operation assuming each type.

   116

     * For this reason, we have one entry for each possible type, with some expressions

   117

     * having more than one entry filled in!

   118

     */

   119

    typedef enum { cs_undefined,   /* not defined/not yet evaluated --> const_value is not valid! */

   120

                   cs_non_const,   /* we have deternmined that expression is not a const value --> const_value is not valid! */

   121

                   cs_const_value, /* const value is valid */

   122

                   cs_overflow     /* result produced overflow or underflow --> const_value is not valid! */

   123

                 } const_status_t;

   124

   125

    typedef struct {const_status_t status;  real64_t  value; } const_value_real64_t;

   126

    typedef struct {const_status_t status;   int64_t  value; } const_value_int64_t;

   127

    typedef struct {const_status_t status;  uint64_t  value; } const_value_uint64_t;

   128

    typedef struct {const_status_t status;      bool  value; } const_value_bool_t;

   129

   130

    typedef struct {

   131

      const_value_real64_t _real64; /* status is initialised to UNDEFINED */

   132

      const_value_int64_t   _int64; /* status is initialised to UNDEFINED */

   133

      const_value_uint64_t _uint64; /* status is initialised to UNDEFINED */

   134

      const_value_bool_t     _bool; /* status is initialised to UNDEFINED */

   135

    } const_value_t;

   136

    const_value_t const_value;

   137

   138

   139

  public:

   140

    /* default constructor */

   141

    symbol_c(int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0, /* order in which it is read by lexcial analyser */

   142

             int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0  /* order in which it is read by lexcial analyser */

   143

            );

   144

   145

    /* default destructor */

   146

    /* must be virtual so compiler does not complain... */ 

   147

    virtual ~symbol_c(void) {return;};

   148

   149

    virtual void *accept(visitor_c &visitor) {return NULL;};

   150

};

   151

   152

   153

class token_c: public symbol_c {

   154

  public:

   155

    /* the value of the symbol. */

   156

    const char *value;

   157

   158

  public:

   159

    token_c(const char *value, 

   160

            int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0, /* order in which it is read by lexcial analyser */

   161

            int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0  /* order in which it is read by lexcial analyser */

   162

           );

   163

};

   164

   165

   166

 /* a list of symbols... */

   167

class list_c: public symbol_c {

   168

  public:

   170

    symbol_c **elements;

   171

   172

  public:

   173

    list_c(int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0, /* order in which it is read by lexcial analyser */

   174

           int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0  /* order in which it is read by lexcial analyser */

   175

          );

   176

   177

    list_c(symbol_c *elem, 

   178

           int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0, /* order in which it is read by lexcial analyser */

   179

           int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0  /* order in which it is read by lexcial analyser */

   180

          );

   181

     /* append a new element to the end of the list */

   182

    virtual void add_element(symbol_c *elem);

   183

     /* insert a new element before position pos. */

   184

     /* To insert into the begining of list, call with pos=0  */

   185

     /* To insert into the end of list, call with pos=list->n */

   186

    virtual void insert_element(symbol_c *elem, int pos = 0);

   187

     /* remove element at position pos. */

   188

    virtual void remove_element(int pos = 0);

   189

};

   190

   191

   192

   193

   194

#define SYM_LIST(class_name_c, ...)											\

   195

class class_name_c:	public list_c {											\

   196

  public:														\

   197

    __VA_ARGS__														\

   198

  public:														\

   199

    class_name_c(													\

   200

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   201

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   202

    class_name_c(symbol_c *elem, 											\

   203

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   204

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   205

    virtual void *accept(visitor_c &visitor);										\

   206

};

   207

   208

   209

#define SYM_TOKEN(class_name_c, ...)											\

   210

class class_name_c: 	public token_c {										\

   211

  public:														\

   212

    __VA_ARGS__														\

   213

  public:														\

   214

    class_name_c(const char *value, 											\

   215

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   216

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   217

    virtual void *accept(visitor_c &visitor);										\

   218

};

   219

   220

   221

#define SYM_REF0(class_name_c, ...)											\

   222

class class_name_c: public symbol_c {											\

   223

  public:														\

   224

    __VA_ARGS__														\

   225

  public:														\

   226

    class_name_c(		 											\

   227

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   228

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   229

    virtual void *accept(visitor_c &visitor);										\

   230

};

   231

   232

   233

#define SYM_REF1(class_name_c, ref1, ...)										\

   234

class class_name_c: public symbol_c {											\

   235

  public:														\

   236

    symbol_c *ref1;													\

   237

    __VA_ARGS__														\

   238

  public:														\

   239

    class_name_c(symbol_c *ref1,											\

   240

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   241

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   242

    virtual void *accept(visitor_c &visitor);										\

   243

};

   244

   245

   246

#define SYM_REF2(class_name_c, ref1, ref2, ...)										\

   247

class class_name_c: public symbol_c {											\

   248

  public:														\

   249

    symbol_c *ref1;													\

   250

    symbol_c *ref2;													\

   251

    __VA_ARGS__														\

   252

  public:														\

   253

    class_name_c(symbol_c *ref1,											\

   254

		 symbol_c *ref2 = NULL,											\

   255

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   256

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   257

    virtual void *accept(visitor_c &visitor);										\

   258

};

   259

   260

   261

#define SYM_REF3(class_name_c, ref1, ref2, ref3, ...)									\

   262

class class_name_c: public symbol_c {											\

   263

  public:														\

   264

    symbol_c *ref1;													\

   265

    symbol_c *ref2;													\

   266

    symbol_c *ref3;													\

   267

    __VA_ARGS__														\

   268

  public:														\

   269

    class_name_c(symbol_c *ref1,											\

   270

		 symbol_c *ref2,											\

   271

		 symbol_c *ref3,											\

   272

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   273

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   274

    virtual void *accept(visitor_c &visitor);										\

   275

};

   276

   277

   278

#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4, ...)								\

   279

class class_name_c: public symbol_c {											\

   280

  public:														\

   281

    symbol_c *ref1;													\

   282

    symbol_c *ref2;													\

   283

    symbol_c *ref3;													\

   284

    symbol_c *ref4;													\

   285

    __VA_ARGS__														\

   286

  public:														\

   287

    class_name_c(symbol_c *ref1,											\

   288

		 symbol_c *ref2,											\

   289

		 symbol_c *ref3,											\

   290

		 symbol_c *ref4 = NULL,											\

   291

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   292

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   293

    virtual void *accept(visitor_c &visitor);										\

   294

};

   295

   296

   297

#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5, ...)							\

   298

class class_name_c: public symbol_c {											\

   299

  public:														\

   300

    symbol_c *ref1;													\

   301

    symbol_c *ref2;													\

   302

    symbol_c *ref3;													\

   303

    symbol_c *ref4;													\

   304

    symbol_c *ref5;													\

   305

    __VA_ARGS__														\

   306

  public:														\

   307

    class_name_c(symbol_c *ref1,											\

   308

		 symbol_c *ref2,											\

   309

		 symbol_c *ref3,											\

   310

		 symbol_c *ref4,											\

   311

		 symbol_c *ref5,											\

   312

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   313

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   314

    virtual void *accept(visitor_c &visitor);										\

   315

};

   316

   317

   318

#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6, ...)							\

   319

class class_name_c: public symbol_c {											\

   320

  public:														\

   321

    symbol_c *ref1;													\

   322

    symbol_c *ref2;													\

   323

    symbol_c *ref3;													\

   324

    symbol_c *ref4;													\

   325

    symbol_c *ref5;													\

   326

    symbol_c *ref6;													\

   327

    __VA_ARGS__														\

   328

  public:														\

   329

    class_name_c(symbol_c *ref1,											\

   330

		 symbol_c *ref2,											\

   331

		 symbol_c *ref3,											\

   332

		 symbol_c *ref4,											\

   333

		 symbol_c *ref5,											\

   334

		 symbol_c *ref6 = NULL,											\

   335

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   336

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   337

    virtual void *accept(visitor_c &visitor);										\

   338

};

   339

   340

   341

#include "absyntax.def"

   342

   343

   344

   345

#undef SYM_LIST

   346

#undef SYM_TOKEN

   347

#undef SYM_REF0

   348

#undef SYM_REF1

   349

#undef SYM_REF2

   350

#undef SYM_REF3

   351

#undef SYM_REF4

   352

#undef SYM_REF5

   353

#undef SYM_REF6

   354

   355

#endif /*  _ABSYNTAX_HH */