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

 * Definition of the Abstract Syntax data structure components

    34

 */

    35

    36

#include <stdio.h>

    37

#include <stdlib.h>	/* required for exit() */

    38

#include <string.h>

    39

    40

#include "absyntax.hh"

    41

//#include "../stage1_2/iec.hh" /* required for BOGUS_TOKEN_ID, etc... */

    42

#include "visitor.hh"

    43

    44

#define ABORT(str) {printf("ERROR: %s\n", str); exit(0);}

    45

    46

    47

    48

    49

    50

    51

/* The base class of all symbols */

    52

symbol_c::symbol_c(

    53

                   int first_line, int first_column, const char *ffile, long int first_order,

    54

                   int last_line,  int last_column,  const char *lfile, long int last_order ) {

    55

  this->first_file   = ffile,

    56

  this->first_line   = first_line;

    57

  this->first_column = first_column;

    58

  this->first_order  = first_order;

    59

  this->last_file    = lfile,

    60

  this->last_line    = last_line;

    61

  this->last_column  = last_column;

    62

  this->last_order   = last_order;

    63

}

    64

    65

    66

    67

token_c::token_c(const char *value, 

    68

                 int fl, int fc, const char *ffile, long int forder,

    69

                 int ll, int lc, const char *lfile, long int lorder)

    70

  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {

    71

  this->value = value;

    72

//  printf("New token: %s\n", value);

    73

}

    74

    75

    76

    77

    78

    79

    80

list_c::list_c(

    81

               int fl, int fc, const char *ffile, long int forder,

    82

               int ll, int lc, const char *lfile, long int lorder)

    83

  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {

    84

  n = 0;

    85

  elements = NULL;

    86

}

    87

    88

list_c::list_c(symbol_c *elem, 

    89

               int fl, int fc, const char *ffile, long int forder,

    90

               int ll, int lc, const char *lfile, long int lorder)

    91

  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {

    92

  n = 0;

    93

  elements = NULL;

    94

  add_element(elem);

    95

}

    96

    97

/* insert a new element */

    98

void list_c::add_element(symbol_c *elem) {

    99

//printf("list_c::add_element()\n");

   100

  n++;

   101

  elements = (symbol_c **)realloc(elements, n * sizeof(symbol_c *));

   102

  if (elements == NULL)

   103

    ABORT("Out of memory");

   104

  elements[n - 1] = elem;

   105

   106

  if (elem == NULL)

   107

    return;

   108

   109

  /* adjust the location parameters, taking into account the new element. */

   110

  if ((first_line == elem->first_line) &&

   111

      (first_column > elem->first_column)) {

   112

    first_column = elem->first_column;

   113

  }

   114

  if (first_line > elem->first_line) {

   115

    first_line = elem->first_line;

   116

    first_column = elem->first_column;

   117

  }

   118

  if ((last_line == elem->last_line) &&

   119

      (last_column < elem->last_column)) {

   120

    last_column = elem->last_column;

   121

  }

   122

  if (last_line < elem->last_line) {

   123

    last_line = elem->last_line;

   124

    last_column = elem->last_column;

   125

  }

   126

}

   127

   128

   129

   130

   131

#define SYM_LIST(class_name_c)									\

   132

class_name_c::class_name_c(									\

   133

                           int fl, int fc, const char *ffile, long int forder,			\

   134

                           int ll, int lc, const char *lfile, long int lorder)			\

   135

                        :list_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {}		\

   136

class_name_c::class_name_c(symbol_c *elem, 							\

   137

                           int fl, int fc, const char *ffile, long int forder,			\

   138

                           int ll, int lc, const char *lfile, long int lorder)			\

   139

			:list_c(elem, fl, fc, ffile, forder, ll, lc, lfile, lorder) {}		\

   140

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   141

   142

#define SYM_TOKEN(class_name_c)									\

   143

class_name_c::class_name_c(const char *value, 							\

   144

                           int fl, int fc, const char *ffile, long int forder,			\

   145

                           int ll, int lc, const char *lfile, long int lorder)			\

   146

			:token_c(value, fl, fc, ffile, forder, ll, lc, lfile, lorder) {}	\

   147

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   148

   149

#define SYM_REF0(class_name_c)									\

   150

class_name_c::class_name_c(									\

   151

                           int fl, int fc, const char *ffile, long int forder,			\

   152

                           int ll, int lc, const char *lfile, long int lorder)			\

   153

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {}		\

   154

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   155

   156

   157

#define SYM_REF1(class_name_c, ref1)								\

   158

class_name_c::class_name_c(symbol_c *ref1,							\

   159

                           int fl, int fc, const char *ffile, long int forder,			\

   160

                           int ll, int lc, const char *lfile, long int lorder)			\

   161

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\

   162

  this->ref1 = ref1;										\

   163

}												\

   164

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   165

   166

   167

#define SYM_REF2(class_name_c, ref1, ref2)							\

   168

class_name_c::class_name_c(symbol_c *ref1,							\

   169

			   symbol_c *ref2,							\

   170

                           int fl, int fc, const char *ffile, long int forder,			\

   171

                           int ll, int lc, const char *lfile, long int lorder)			\

   172

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\

   173

  this->ref1 = ref1;										\

   174

  this->ref2 = ref2;										\

   175

}												\

   176

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   177

   178

   179

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

   180

class_name_c::class_name_c(symbol_c *ref1,							\

   181

			   symbol_c *ref2,							\

   182

			   symbol_c *ref3,							\

   183

                           int fl, int fc, const char *ffile, long int forder,			\

   184

                           int ll, int lc, const char *lfile, long int lorder)			\

   185

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\

   186

  this->ref1 = ref1;										\

   187

  this->ref2 = ref2;										\

   188

  this->ref3 = ref3;										\

   189

}												\

   190

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   191

   192

   193

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

   194

class_name_c::class_name_c(symbol_c *ref1,							\

   195

			   symbol_c *ref2,							\

   196

			   symbol_c *ref3,							\

   197

			   symbol_c *ref4,							\

   198

                           int fl, int fc, const char *ffile, long int forder,			\

   199

                           int ll, int lc, const char *lfile, long int lorder)			\

   200

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\

   201

  this->ref1 = ref1;										\

   202

  this->ref2 = ref2;										\

   203

  this->ref3 = ref3;										\

   204

  this->ref4 = ref4;										\

   205

}												\

   206

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   207

   208

   209

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

   210

class_name_c::class_name_c(symbol_c *ref1,							\

   211

			   symbol_c *ref2,							\

   212

			   symbol_c *ref3,							\

   213

			   symbol_c *ref4,							\

   214

			   symbol_c *ref5,							\

   215

                           int fl, int fc, const char *ffile, long int forder,			\

   216

                           int ll, int lc, const char *lfile, long int lorder)			\

   217

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\

   218

  this->ref1 = ref1;										\

   219

  this->ref2 = ref2;										\

   220

  this->ref3 = ref3;										\

   221

  this->ref4 = ref4;										\

   222

  this->ref5 = ref5;										\

   223

}												\

   224

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   225

   226

   227

   228

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

   229

class_name_c::class_name_c(symbol_c *ref1,							\

   230

			   symbol_c *ref2,							\

   231

			   symbol_c *ref3,							\

   232

			   symbol_c *ref4,							\

   233

			   symbol_c *ref5,							\

   234

			   symbol_c *ref6,							\

   235

                           int fl, int fc, const char *ffile, long int forder,			\

   236

                           int ll, int lc, const char *lfile, long int lorder)			\

   237

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\

   238

  this->ref1 = ref1;										\

   239

  this->ref2 = ref2;										\

   240

  this->ref3 = ref3;										\

   241

  this->ref4 = ref4;										\

   242

  this->ref5 = ref5;										\

   243

  this->ref6 = ref6;										\

   244

}												\

   245

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   246

   247

   248

   249

#include "absyntax.def"

   250

   251

   252

   253

   254

#undef SYM_LIST

   255

#undef SYM_TOKEN

   256

#undef SYM_TOKEN

   257

#undef SYM_REF0

   258

#undef SYM_REF1

   259

#undef SYM_REF2

   260

#undef SYM_REF3

   261

#undef SYM_REF4

   262

#undef SYM_REF5

   263

#undef SYM_REF6

   264

   265

   266

   267

   268