1

/*

     2

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

     3

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

     4

 *

     5

 *  This program is free software: you can redistribute it and/or modify

     6

 *  it under the terms of the GNU General Public License as published by

     7

 *  the Free Software Foundation, either version 3 of the License, or

     8

 *  (at your option) any later version.

     9

 *

    10

 *  This program is distributed in the hope that it will be useful,

    11

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    12

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    13

 *  GNU General Public License for more details.

    14

 *

    15

 *  You should have received a copy of the GNU General Public License

    16

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    17

 *

    18

 *

    19

 * This code is made available on the understanding that it will not be

    20

 * used in safety-critical situations without a full and competent review.

    21

 */

    22

    23

/*

    24

 * An IEC 61131-3 compiler.

    25

 *

    26

 * Based on the

    27

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    28

 *

    29

 */

    30

    31

    32

/*

    33

 * This file contains the code that stores the output generated

    34

 * by each specific version of the 4th stage.

    35

 */

    36

    37

    38

    39

    40

    41

    42

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

    43

#include <string>

    44

#include <iostream>

    45

#include <fstream>

    46

#include <stdlib.h>

    47

    48

#include "stage4.hh"

    49

#include "../main.hh" // required for ERROR() and ERROR_MSG() macros.

    50

    51

    52

    53

    54

#define FIRST_(symbol1, symbol2) (((symbol1)->first_order < (symbol2)->first_order)   ? (symbol1) : (symbol2))

    55

#define  LAST_(symbol1, symbol2) (((symbol1)->last_order  > (symbol2)->last_order)    ? (symbol1) : (symbol2))

    56

#include <stdarg.h>

    57

    58

void stage4err(const char *stage4_generator_id, symbol_c *symbol1, symbol_c *symbol2, const char *errmsg, ...) {

    59

    va_list argptr;

    60

    va_start(argptr, errmsg); /* second argument is last fixed pamater of stage4err() */

    61

    62

    if ((symbol1 != NULL) && (symbol2 != NULL))

    63

      fprintf(stderr, "%s:%d-%d..%d-%d: ",

    64

              FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column,

    65

                                                   LAST_(symbol1,symbol2) ->last_line,  LAST_(symbol1,symbol2) ->last_column);

    66

    67

    fprintf(stderr, "error %s: ", stage4_generator_id);

    68

    vfprintf(stderr, errmsg, argptr);

    69

    fprintf(stderr, "\n");

    70

    // error_count++;

    71

    va_end(argptr);

    72

}

    73

    74

    75

    76

stage4out_c::stage4out_c(std::string indent_level):

    77

	m_file(NULL) {

    78

  out = &std::cout;

    79

  this->indent_level = indent_level;

    80

  this->indent_spaces = "";

    81

  allow_output = true;

    82

}

    83

    84

stage4out_c::stage4out_c(const char *dir, const char *radix, const char *extension, std::string indent_level) {	

    85

  std::string filename(radix);

    86

  filename += ".";

    87

  filename += extension;

    88

  std::string filepath("");

    89

  if (dir != NULL) {

    90

    filepath += dir;

    91

    filepath += "/";

    92

  }

    93

  filepath += filename;

    94

  std::fstream *file = new std::fstream(filepath.c_str(), std::fstream::out);

    95

  if(file->fail()){

    96

    std::cerr << "Cannot open " << filename << " for write access \n";

    97

    exit(EXIT_FAILURE);

    98

  }else{

    99

    std::cout << filename << "\n";

   100

  }

   101

  out = file;

   102

  m_file = file;

   103

  this->indent_level = indent_level;

   104

  this->indent_spaces = "";

   105

  allow_output = true;

   106

}

   107

   108

stage4out_c::~stage4out_c(void) {

   109

  if(m_file)

   110

  {

   111

    m_file->close();

   112

    delete m_file;

   113

  }

   114

}

   115

   116

void stage4out_c::flush(void) {

   117

  out->flush();

   118

}

   119

   120

void stage4out_c::enable_output(void) {

   121

  allow_output = true;

   122

}

   123

   124

void stage4out_c::disable_output(void) {

   125

  allow_output = false;

   126

}

   127

   128

void stage4out_c::indent_right(void) {

   129

  indent_spaces+=indent_level;

   130

}

   131

   132

void stage4out_c::indent_left(void) {

   133

  if (indent_spaces.length() >= indent_level.length())

   134

    indent_spaces.erase(indent_spaces.length() - indent_level.length(), indent_level.length());

   135

  else

   136

    indent_spaces.erase();

   137

}

   138

   139

void *stage4out_c::print(           std::string value) {if (!allow_output) return NULL; *out << value; return NULL;}

   140

void *stage4out_c::print(           const char *value) {if (!allow_output) return NULL; *out << value; return NULL;}

   141

//void *stage4out_c::print(               int64_t value) {if (!allow_output) return NULL; *out << value; return NULL;}

   142

//void *stage4out_c::print(              uint64_t value) {if (!allow_output) return NULL; *out << value; return NULL;}

   143

void *stage4out_c::print(              real64_t value) {if (!allow_output) return NULL; *out << value; return NULL;}

   144

void *stage4out_c::print(                   int value) {if (!allow_output) return NULL; *out << value; return NULL;}

   145

void *stage4out_c::print(              long int value) {if (!allow_output) return NULL; *out << value; return NULL;}

   146

void *stage4out_c::print(         long long int value) {if (!allow_output) return NULL; *out << value; return NULL;}

   147

void *stage4out_c::print(unsigned           int value) {if (!allow_output) return NULL; *out << value; return NULL;}

   148

void *stage4out_c::print(unsigned      long int value) {if (!allow_output) return NULL; *out << value; return NULL;}

   149

void *stage4out_c::print(unsigned long long int value) {if (!allow_output) return NULL; *out << value; return NULL;}

   150

   151

   152

void *stage4out_c::print_long_integer(unsigned long l_integer, bool suffix) {

   153

  if (!allow_output) return NULL;

   154

  *out << l_integer;

   155

  if (suffix) *out << "UL";

   156

  return NULL;

   157

}

   158

   159

void *stage4out_c::print_long_long_integer(unsigned long long ll_integer, bool suffix) {

   160

  if (!allow_output) return NULL;

   161

  *out << ll_integer;

   162

  if (suffix) *out << "ULL";

   163

  return NULL;

   164

}

   165

   166

   167

void *stage4out_c::printupper(const char *str) {

   168

  if (!allow_output) return NULL;

   169

  for (int i = 0; str[i] != '\0'; i++)

   170

    *out << (unsigned char)toupper(str[i]);

   171

  return NULL;

   172

}

   173

   174

void *stage4out_c::printlocation(const char *str) {

   175

  if (!allow_output) return NULL;

   176

  *out << "__";

   177

  for (int i = 0; str[i] != '\0'; i++)

   178

    if(str[i] == '.')

   179

      *out << '_';

   180

    else

   181

      *out << (unsigned char)toupper(str[i]);

   182

  return NULL;

   183

}

   184

   185

void *stage4out_c::printlocation_comasep(const char *str) {

   186

  if (!allow_output) return NULL;

   187

  *out << (unsigned char)toupper(str[0]);

   188

  *out << ',';

   189

  *out << (unsigned char)toupper(str[1]);

   190

  *out << ',';

   191

  for (int i = 2; str[i] != '\0'; i++)

   192

    if(str[i] == '.')

   193

      *out << ',';

   194

    else

   195

      *out << (unsigned char)toupper(str[i]);

   196

  return NULL;

   197

}

   198

   199

   200

   201

void *stage4out_c::printupper(std::string str) {

   202

  if (!allow_output) return NULL;

   203

  /* The string standard class does not have a converter member function to upper case.

   204

   * We have to do it ourselves, a character at a time...

   205

   */

   206

#if 0

   207

  /* The C++ way of doint things... */

   208

  for (string::const_iterator p = str.begin(); p != str.end(); ++p)

   209

    *out << (unsigned char)toupper(*p);

   210

#else

   211

  /* Or more simply... */

   212

    printupper(str.c_str());

   213

#endif

   214

  return NULL;

   215

}

   216

   217

   218

void *stage4out_c::printlocation(std::string str) {

   219

  if (!allow_output) return NULL;

   220

  return printlocation(str.c_str());

   221

}

   222

   223

   224

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

   225

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

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

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

   234

   235

   236

   237

/* forward declarations... */

   238

/* These functions will be implemented in generate_XXX.cc */

   239

visitor_c *new_code_generator(stage4out_c *s4o, const char *builddir);

   240

void delete_code_generator(visitor_c *code_generator);

   241

   242

   243

int stage4(symbol_c *tree_root, const char *builddir) {

   244

  stage4out_c s4o;

   245

  visitor_c *generate_code = new_code_generator(&s4o, builddir);

   246

   247

  if (NULL == generate_code) ERROR;

   248

   249

  tree_root->accept(*generate_code);

   250

   251

  delete_code_generator(generate_code);

   252

   253

  return 0;

   254

}

   255