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 ERROR error_exit(__FILE__,__LINE__)

    45

/* function defined in main.cc */

    46

extern void error_exit(const char *file_name, int line_no);

    47

    48

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

    49

    50

    51

    52

/* The base class of all symbols */

    53

symbol_c::symbol_c(

    54

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

    55

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

    56

  this->first_file   = ffile,

    57

  this->first_line   = first_line;

    58

  this->first_column = first_column;

    59

  this->first_order  = first_order;

    60

  this->last_file    = lfile,

    61

  this->last_line    = last_line;

    62

  this->last_column  = last_column;

    63

  this->last_order   = last_order;

    64

  this->datatype     = NULL;

    65

  this->const_value_real64   = NULL;

    66

  this->const_value_int64    = NULL;

    67

  this->const_value_uint64   = NULL;

    68

  this->const_value_bool     = NULL;

    69

}

    70

    71

    72

    73

token_c::token_c(const char *value, 

    74

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

    75

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

    76

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

    77

  this->value = value;

    78

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

    79

}

    80

    81

    82

    83

    84

    85

    86

list_c::list_c(

    87

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

    88

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

    89

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

    90

  n = 0;

    91

  elements = NULL;

    92

}

    93

    94

list_c::list_c(symbol_c *elem, 

    95

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

    96

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

    97

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

    98

  n = 0;

    99

  elements = NULL;

   100

  add_element(elem);

   101

}

   102

   103

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

   104

void list_c::add_element(symbol_c *elem) {

   105

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

   106

  n++;

   107

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

   108

  if (elements == NULL)

   109

    ABORT("Out of memory");

   110

  elements[n - 1] = elem;

   111

   112

  if (elem == NULL)

   113

    return;

   114

   115

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

   116

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

   117

      (first_column > elem->first_column)) {

   118

    first_column = elem->first_column;

   119

  }

   120

  if (first_line > elem->first_line) {

   121

    first_line = elem->first_line;

   122

    first_column = elem->first_column;

   123

  }

   124

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

   125

      (last_column < elem->last_column)) {

   126

    last_column = elem->last_column;

   127

  }

   128

  if (last_line < elem->last_line) {

   129

    last_line = elem->last_line;

   130

    last_column = elem->last_column;

   131

  }

   132

}

   133

   134

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

   135

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

   136

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

   137

void list_c::insert_element(symbol_c *elem, int pos) {

   138

  if (pos > n) ERROR;

   139

   140

  /* add new element to end of list. Basically alocate required memory... */

   141

  /* will also increment n by 1 ! */

   142

  add_element(elem);

   143

  /* if not inserting into end position, shift all elements up one position, to open up a slot in pos for new element */

   144

  if (pos < (n-1)) for (int i = n-2; i >= pos; i--) elements[i+1] = elements[i];

   145

  elements[pos] = elem;

   146

}

   147

   148

   149

/* remove element at position pos. */

   150

void list_c::remove_element(int pos) {

   151

  if (pos > n) ERROR;

   152

   153

  /* Shift all elements down one position, starting at the entry to delete. */

   154

  for (int i = pos; i < n-1; i++) elements[i] = elements[i+1];

   155

  /* corrent the new size, and free unused memory */

   156

  n--;

   157

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

   158

}

   159

   160

#define SYM_LIST(class_name_c, ...)								\

   161

class_name_c::class_name_c(									\

   162

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

   163

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

   164

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

   165

class_name_c::class_name_c(symbol_c *elem, 							\

   166

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

   167

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

   168

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

   169

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

   170

   171

#define SYM_TOKEN(class_name_c, ...)								\

   172

class_name_c::class_name_c(const char *value, 							\

   173

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

   174

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

   175

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

   176

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

   177

   178

#define SYM_REF0(class_name_c, ...)								\

   179

class_name_c::class_name_c(									\

   180

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

   181

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

   182

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

   183

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

   184

   185

   186

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

   187

class_name_c::class_name_c(symbol_c *ref1,							\

   188

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

   189

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

   190

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

   191

  this->ref1 = ref1;										\

   192

}												\

   193

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

   194

   195

   196

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

   197

class_name_c::class_name_c(symbol_c *ref1,							\

   198

			   symbol_c *ref2,							\

   199

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

   200

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

   201

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

   202

  this->ref1 = ref1;										\

   203

  this->ref2 = ref2;										\

   204

}												\

   205

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

   206

   207

   208

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

   209

class_name_c::class_name_c(symbol_c *ref1,							\

   210

			   symbol_c *ref2,							\

   211

			   symbol_c *ref3,							\

   212

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

   213

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

   214

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

   215

  this->ref1 = ref1;										\

   216

  this->ref2 = ref2;										\

   217

  this->ref3 = ref3;										\

   218

}												\

   219

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

   220

   221

   222

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

   223

class_name_c::class_name_c(symbol_c *ref1,							\

   224

			   symbol_c *ref2,							\

   225

			   symbol_c *ref3,							\

   226

			   symbol_c *ref4,							\

   227

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

   228

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

   229

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

   230

  this->ref1 = ref1;										\

   231

  this->ref2 = ref2;										\

   232

  this->ref3 = ref3;										\

   233

  this->ref4 = ref4;										\

   234

}												\

   235

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

   236

   237

   238

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

   239

class_name_c::class_name_c(symbol_c *ref1,							\

   240

			   symbol_c *ref2,							\

   241

			   symbol_c *ref3,							\

   242

			   symbol_c *ref4,							\

   243

			   symbol_c *ref5,							\

   244

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

   245

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

   246

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

   247

  this->ref1 = ref1;										\

   248

  this->ref2 = ref2;										\

   249

  this->ref3 = ref3;										\

   250

  this->ref4 = ref4;										\

   251

  this->ref5 = ref5;										\

   252

}												\

   253

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

   254

   255

   256

   257

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

   258

class_name_c::class_name_c(symbol_c *ref1,							\

   259

			   symbol_c *ref2,							\

   260

			   symbol_c *ref3,							\

   261

			   symbol_c *ref4,							\

   262

			   symbol_c *ref5,							\

   263

			   symbol_c *ref6,							\

   264

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

   265

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

   266

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

   267

  this->ref1 = ref1;										\

   268

  this->ref2 = ref2;										\

   269

  this->ref3 = ref3;										\

   270

  this->ref4 = ref4;										\

   271

  this->ref5 = ref5;										\

   272

  this->ref6 = ref6;										\

   273

}												\

   274

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

   275

   276

   277

   278

#include "absyntax.def"

   279

   280

   281

   282

   283

#undef SYM_LIST

   284

#undef SYM_TOKEN

   285

#undef SYM_TOKEN

   286

#undef SYM_REF0

   287

#undef SYM_REF1

   288

#undef SYM_REF2

   289

#undef SYM_REF3

   290

#undef SYM_REF4

   291

#undef SYM_REF5

   292

#undef SYM_REF6

   293

   294

   295

   296

   297