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(void) {

    53

  this->first_line   = 0;

    54

  this->first_column = 0;

    55

  this->last_line    = 0;

    56

  this->last_column  = 0;

    57

}

    58

    59

symbol_c::symbol_c(int first_line, int first_column, int last_line, int last_column) {

    60

  this->first_line   = first_line;

    61

  this->first_column = first_column;

    62

  this->last_line    = last_line;

    63

  this->last_column  = last_column;

    64

}

    65

    66

    67

    68

token_c::token_c(const char *value, int fl, int fc, int ll, int lc)

    69

  :symbol_c(fl, fc, ll, lc) {

    70

  this->value = value;

    71

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

    72

}

    73

    74

    75

    76

    77

    78

    79

list_c::list_c(int fl, int fc, int ll, int lc)

    80

  :symbol_c(fl, fc, ll, lc) {

    81

  n = 0;

    82

  elements = NULL;

    83

}

    84

    85

list_c::list_c(symbol_c *elem, int fl, int fc, int ll, int lc)

    86

  :symbol_c(fl, fc, ll, lc) {

    87

  n = 0;

    88

  elements = NULL;

    89

  add_element(elem);

    90

}

    91

    92

/* insert a new element */

    93

void list_c::add_element(symbol_c *elem) {

    94

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

    95

  n++;

    96

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

    97

  if (elements == NULL)

    98

    ABORT("Out of memory");

    99

  elements[n - 1] = elem;

   100

   101

  if (elem == NULL)

   102

    return;

   103

   104

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

   105

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

   106

      (first_column > elem->first_column)) {

   107

    first_column = elem->first_column;

   108

  }

   109

  if (first_line > elem->first_line) {

   110

    first_line = elem->first_line;

   111

    first_column = elem->first_column;

   112

  }

   113

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

   114

      (last_column < elem->last_column)) {

   115

    last_column = elem->last_column;

   116

  }

   117

  if (last_line < elem->last_line) {

   118

    last_line = elem->last_line;

   119

    last_column = elem->last_column;

   120

  }

   121

}

   122

   123

   124

   125

   126

#define SYM_LIST(class_name_c)							\

   127

class_name_c::class_name_c(int fl, int fc, int ll, int lc)			\

   128

			:list_c(fl, fc, ll, lc) {}				\

   129

class_name_c::class_name_c(symbol_c *elem, int fl, int fc, int ll, int lc)	\

   130

			:list_c(elem, fl, fc, ll, lc) {}			\

   131

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

   132

   133

#define SYM_TOKEN(class_name_c)							\

   134

class_name_c::class_name_c(const char *value, int fl, int fc, int ll, int lc)	\

   135

			:token_c(value, fl, fc, ll, lc) {}			\

   136

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

   137

   138

#define SYM_REF0(class_name_c)					\

   139

class_name_c::class_name_c(int fl, int fc,			\

   140

			   int ll, int lc			\

   141

			  ): symbol_c(fl, fc, ll, lc) {}	\

   142

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

   143

   144

   145

#define SYM_REF1(class_name_c, ref1)			\

   146

class_name_c::class_name_c(symbol_c *ref1,		\

   147

			   int fl, int fc,		\

   148

			   int ll, int lc		\

   149

			  ): symbol_c(fl, fc, ll, lc) {	\

   150

  this->ref1 = ref1;					\

   151

}							\

   152

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

   153

   154

   155

#define SYM_REF2(class_name_c, ref1, ref2)		\

   156

class_name_c::class_name_c(symbol_c *ref1,		\

   157

			   symbol_c *ref2,		\

   158

			   int fl, int fc,		\

   159

			   int ll, int lc		\

   160

			  ): symbol_c(fl, fc, ll, lc) {	\

   161

  this->ref1 = ref1;					\

   162

  this->ref2 = ref2;					\

   163

}							\

   164

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

   165

   166

   167

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

   168

class_name_c::class_name_c(symbol_c *ref1,		\

   169

			   symbol_c *ref2,		\

   170

			   symbol_c *ref3,		\

   171

			   int fl, int fc,		\

   172

			   int ll, int lc		\

   173

			  ): symbol_c(fl, fc, ll, lc) {	\

   174

  this->ref1 = ref1;					\

   175

  this->ref2 = ref2;					\

   176

  this->ref3 = ref3;					\

   177

}							\

   178

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

   179

   180

   181

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

   182

class_name_c::class_name_c(symbol_c *ref1,		\

   183

			   symbol_c *ref2,		\

   184

			   symbol_c *ref3,		\

   185

			   symbol_c *ref4,		\

   186

			   int fl, int fc,		\

   187

			   int ll, int lc		\

   188

			  ): symbol_c(fl, fc, ll, lc) {	\

   189

  this->ref1 = ref1;					\

   190

  this->ref2 = ref2;					\

   191

  this->ref3 = ref3;					\

   192

  this->ref4 = ref4;					\

   193

}							\

   194

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

   195

   196

   197

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

   198

class_name_c::class_name_c(symbol_c *ref1,				\

   199

			   symbol_c *ref2,				\

   200

			   symbol_c *ref3,				\

   201

			   symbol_c *ref4,				\

   202

			   symbol_c *ref5,				\

   203

			   int fl, int fc,				\

   204

			   int ll, int lc				\

   205

			  ): symbol_c(fl, fc, ll, lc) {			\

   206

  this->ref1 = ref1;							\

   207

  this->ref2 = ref2;							\

   208

  this->ref3 = ref3;							\

   209

  this->ref4 = ref4;							\

   210

  this->ref5 = ref5;							\

   211

}									\

   212

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

   213

   214

   215

   216

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

   217

class_name_c::class_name_c(symbol_c *ref1,				\

   218

			   symbol_c *ref2,				\

   219

			   symbol_c *ref3,				\

   220

			   symbol_c *ref4,				\

   221

			   symbol_c *ref5,				\

   222

			   symbol_c *ref6,				\

   223

			   int fl, int fc,				\

   224

			   int ll, int lc				\

   225

			  ): symbol_c(fl, fc, ll, lc) {			\

   226

  this->ref1 = ref1;							\

   227

  this->ref2 = ref2;							\

   228

  this->ref3 = ref3;							\

   229

  this->ref4 = ref4;							\

   230

  this->ref5 = ref5;							\

   231

  this->ref6 = ref6;							\

   232

}									\

   233

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

   234

   235

   236

   237

#include "absyntax.def"

   238

   239

   240

   241

   242

#undef SYM_LIST

   243

#undef SYM_TOKEN

   244

#undef SYM_TOKEN

   245

#undef SYM_REF0

   246

#undef SYM_REF1

   247

#undef SYM_REF2

   248

#undef SYM_REF3

   249

#undef SYM_REF4

   250

#undef SYM_REF5

   251

#undef SYM_REF6

   252

   253

   254

   255

   256