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

    50

    56

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

    57

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

    58

#include <stdarg.h>

    59

    60

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

    61

    va_list argptr;

    62

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

    63

    64

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

    65

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

    66

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

    67

            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 = "";

    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

   140

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

   141

  if (!allow_output) return NULL;

   142

  *out << str;

   143

  return NULL;

   144

}

   145

   146

void *stage4out_c::print_integer(int integer) {

   147

  if (!allow_output) return NULL;

   148

  *out << integer;

   149

  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

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

   167

  if (!allow_output) return NULL;

   168

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

   169

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

   170

  return NULL;

   171

}

   172

   173

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

   174

  if (!allow_output) return NULL;

   175

  *out << "__";

   176

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

   177

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

   178

      *out << '_';

   179

    else

   180

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

   181

  return NULL;

   182

}

   183

   184

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

   185

  if (!allow_output) return NULL;

   186

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

   187

  *out << ',';

   188

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

   189

  *out << ',';

   190

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

   191

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

   192

      *out << ',';

   193

    else

   194

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

   195

  return NULL;

   196

}

   197

   198

   199

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

   200

  if (!allow_output) return NULL;

   201

  *out << str;

   202

  return NULL;

   203

}

   204

   205

   206

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

   207

  if (!allow_output) return NULL;

   208

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

   209

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

   210

   */

   211

#if 0

   212

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

   213

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

   214

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

   215

#else

   216

  /* Or more simply... */

   217

    printupper(str.c_str());

   218

#endif

   219

  return NULL;

   220

}

   221

   222

   223

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

   224

  if (!allow_output) return NULL;

   225

  return printlocation(str.c_str());

   226

}

   227

   228

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

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

   239

   240

   241

   242

/* forward declarations... */

   243

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

   244

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

   245

void delete_code_generator(visitor_c *code_generator);

   246

   247

   248

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

   249

  stage4out_c s4o;

   250

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

   251

   253

   254

  tree_root->accept(*generate_code);

   255

   256

  delete_code_generator(generate_code);

   257

   258

  return 0;

   259

}

   260