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

    51

#define ERROR error_exit(__FILE__,__LINE__)

    52

/* function defined in main.cc */

    53

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

    54

    55

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

    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

   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

   184

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

   185

  if (!allow_output) return NULL;

   186

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

   187

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

   188

  return NULL;

   189

}

   190

   191

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

   192

  if (!allow_output) return NULL;

   193

  *out << "__";

   194

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

   195

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

   196

      *out << '_';

   197

    else

   198

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

   199

  return NULL;

   200

}

   201

   202

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

   203

  if (!allow_output) return NULL;

   204

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

   205

  *out << ',';

   206

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

   207

  *out << ',';

   208

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

   209

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

   210

      *out << ',';

   211

    else

   212

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

   213

  return NULL;

   214

}

   215

   216

   217

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

   218

  if (!allow_output) return NULL;

   219

  *out << str;

   220

  return NULL;

   221

}

   222

   223

   224

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

   225

  if (!allow_output) return NULL;

   226

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

   227

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

   228

   */

   229

#if 0

   230

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

   231

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

   232

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

   233

#else

   234

  /* Or more simply... */

   235

    printupper(str.c_str());

   236

#endif

   237

  return NULL;

   238

}

   239

   240

   241

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

   242

  if (!allow_output) return NULL;

   243

  return printlocation(str.c_str());

   244

}

   245

   246

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

   258

   259

   260

/* forward declarations... */

   261

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

   262

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

   263

void delete_code_generator(visitor_c *code_generator);

   264

   265

   266

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

   267

  stage4out_c s4o;

   268

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

   269

   270

  if (NULL == generate_code) ERROR;

   271

   272

  tree_root->accept(*generate_code);

   273

   274

  delete_code_generator(generate_code);

   275

   276

  return 0;

   277

}

   278