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

 ****************************************************************

    34

 ****************************************************************

    35

 ****************************************************************

    36

 *********                                              *********

    37

 *********                                              *********

    38

 *********   O V E R A L L    A R C H I T E C T U R E   *********

    39

 *********                                              *********

    40

 *********                                              *********

    41

 ****************************************************************

    42

 ****************************************************************

    43

 ****************************************************************

    44

    45

 The compiler works in 4(+1) stages:

    46

 Stage 1   - Lexical analyser      - implemented with flex (iec.flex)

    47

 Stage 2   - Syntax parser         - implemented with bison (iec.y)

    48

 Stage 3   - Semantics analyser    - not yet implemented

    49

 Stage 4   - Code generator        - implemented in C++

    50

 Stage 4+1 - Binary code generator - gcc, javac, etc...

    51

    52

    53

 Data structures passed between stages, in global variables:

    54

 1->2   : tokens (int), and token values (char *)

    55

 2->1   : symbol tables (defined in symtable.hh)

    56

 2->3   : abstract syntax tree (tree of C++ classes, in absyntax.hh file)

    57

 3->4   : Same as 2->3

    58

 4->4+1 : file with program in c, java, etc...

    59

    60

    61

 The compiler works in several passes:

    62

 Pass 1: executes stages 1 and 2 simultaneously

    63

 Pass 2: executes stage 3

    64

 Pass 3: executes stage 4

    65

 Pass 4: executes stage 4+1

    66

*/

    67

    68

    69

    70

#include <stdio.h>

    71

#include <getopt.h>

    72

#include <string.h>

    73

#include <stdlib.h>

    74

#include <stdarg.h>

    75

#include <iostream>

    76

    77

    78

#include "config/config.h"

    79

#include "absyntax/absyntax.hh"

    80

#include "absyntax_utils/absyntax_utils.hh"

    81

#include "stage1_2/stage1_2.hh"

    82

#include "stage3/stage3.hh"

    83

#include "stage4/stage4.hh"

    84

#include "main.hh"

    85

    86

    87

#ifndef HGVERSION

    88

   #define HGVERSION ""

    89

#endif

    90

    91

    92

    93

void error_exit(const char *file_name, int line_no, const char *errmsg, ...) {

    94

  va_list argptr;

    95

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

    96

    97

  fprintf(stderr, "\nInternal compiler error in file %s at line %d", file_name, line_no);

    98

  if (errmsg != NULL) {

    99

    fprintf(stderr, ": ");

   100

    vfprintf(stderr, errmsg, argptr);

   101

  } else {

   102

    fprintf(stderr, ".");

   103

  }

   104

  fprintf(stderr, "\n");

   105

  va_end(argptr);

   106

   107

  exit(EXIT_FAILURE);

   108

}

   109

   110

   111

static void printusage(const char *cmd) {

   112

  printf("\nsyntax: %s [<options>] [-O <output_options>] [-I <include_directory>] [-T <target_directory>] <input_file>\n", cmd);

   113

  printf(" -h : show this help message\n");

   114

  printf(" -v : print version number\n");  

   115

  printf(" -f : display full token location on error messages\n");

   116

  printf(" -p : allow use of forward references                (a non-standard extension?)\n");  

   117

  printf(" -l : use a relaxed datatype equivalence model       (a non-standard extension?)\n");  

   118

  printf(" -s : allow use of safe datatypes (SAFEBOOL, etc.)   (defined in PLCOpen Safety)\n"); // PLCopen TC5 "Safety Software Technical Specification - Part 1" v1.0

   119

  printf(" -r : allow use of references (REF_TO, REF, ^, NULL) (an IEC 61131-3 v3 feature)\n");

   120

  printf(" -R : allow use of REF_TO ANY datatypes              (a non-standard extension!)\n");

   121

  printf("        as well as REF_TO in ARRAYs and STRUCTs      (a non-standard extension!)\n");

   122

  printf(" -c : create conversion functions for enumerated data types\n");

   123

  printf(" -O : options for output (code generation) stage. Available options for %s are...\n", cmd);

   124

  stage4_print_options();

   125

  printf("\n");

   126

  printf("%s - Copyright (C) 2003-2014 \n"

   127

         "This program comes with ABSOLUTELY NO WARRANTY!\n"

   128

         "This is free software licensed under GPL v3, and you are welcome to redistribute it under the conditions specified by this license.\n", PACKAGE_NAME);

   129

}

   130

   131

   132

/* declare the global options variable */

   133

runtime_options_t runtime_options;

   134

   135

   136

int main(int argc, char **argv) {

   137

  symbol_c *tree_root, *ordered_tree_root;

   138

  char * builddir = NULL;

   139

  int optres, errflg = 0;

   140

  int path_len;

   141

   142

  /* Default values for the command line options... */

   143

  runtime_options.pre_parsing             = false; /* allow use of forward references (run pre-parsing phase before the definitive parsing phase that builds the AST) */

   144

  runtime_options.safe_extensions         = false; /* allow use of SAFExxx datatypes */

   145

  runtime_options.full_token_loc          = false; /* error messages specify full token location */

   146

  runtime_options.conversion_functions    = false; /* Create a conversion function for derived datatype */

   147

  runtime_options.nested_comments         = false; /* Allow the use of nested comments. */

   148

  runtime_options.ref_standard_extensions = false; /* Allow the use of REFerences (keywords REF_TO, REF, DREF, ^, NULL). */

   149

  runtime_options.ref_nonstand_extensions = false; /* Allow the use of non-standard extensions to REF_TO datatypes: REF_TO ANY, and REF_TO in struct elements! */

   150

  runtime_options.includedir              = NULL;  /* Include directory, where included files will be searched for... */

   151

   152

  /* Default values for the command line options... */

   153

  runtime_options.relaxed_datatype_model    = false; /* by default use the strict datatype equivalence model */

   154

   155

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

   156

  /*   Parse command line options...        */

   157

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

   158

  while ((optres = getopt(argc, argv, ":nhvfplsrRcI:T:O:")) != -1) {

   159

    switch(optres) {

   160

    case 'h':

   161

      printusage(argv[0]);

   162

      return 0;

   163

    case 'v':

   164

      fprintf(stdout, "%s version %s\n" "changeset id: %s\n", PACKAGE_NAME, PACKAGE_VERSION, HGVERSION);      

   165

      return 0;

   166

    case 'l':

   167

      runtime_options.relaxed_datatype_model = true;

   168

      break;

   169

    case 'p':

   170

      runtime_options.pre_parsing = true;

   171

      break;

   172

    case 'f':

   173

      runtime_options.full_token_loc = true;

   174

      break;

   175

    case 's':

   176

      runtime_options.safe_extensions = true;

   177

      break;

   178

    case 'R':

   179

      runtime_options.ref_standard_extensions = true; /* use of REF_TO ANY implies activating support for REF extensions! */

   180

      runtime_options.ref_nonstand_extensions = true;

   181

      break;

   182

    case 'r':

   183

      runtime_options.ref_standard_extensions = true;

   184

      break;

   185

    case 'c':

   186

      runtime_options.conversion_functions = true;

   187

      break;

   188

    case 'n':

   189

      runtime_options.nested_comments = true;

   190

      break;

   191

    case 'I':

   192

      /* NOTE: To improve the usability under windows:

   193

       *       We delete last char's path if it ends with "\".

   194

       *       In this way compiler front-end accepts paths with or without

   195

       *       slash terminator.

   196

       */

   197

      path_len = strlen(optarg) - 1;

   198

      if (optarg[path_len] == '\\') optarg[path_len]= '\0';

   199

      runtime_options.includedir = optarg;

   200

      break;

   201

    case 'T':

   202

      /* NOTE: see note above */

   203

      path_len = strlen(optarg) - 1;

   204

      if (optarg[path_len] == '\\') optarg[path_len]= '\0';

   205

      builddir = optarg;

   206

      break;

   207

    case 'O':

   208

      if (stage4_parse_options(optarg) < 0) errflg++;

   209

      break;

   210

    case ':':       /* -I, -T, or -O without operand */

   211

      fprintf(stderr, "Option -%c requires an operand\n", optopt);

   212

      errflg++;

   213

      break;

   214

    case '?':

   215

      fprintf(stderr, "Unrecognized option: -%c\n", optopt);

   216

      errflg++;

   217

      break;

   218

    default:

   219

      fprintf(stderr, "Unknown error while parsing command line options.");

   220

      errflg++;

   221

      break;

   222

    }

   223

  }

   224

   225

  if (optind == argc) {

   226

    fprintf(stderr, "Missing input file\n");

   227

    errflg++;

   228

  }

   229

   230

  if (optind > argc) {

   231

    fprintf(stderr, "Too many input files\n");

   232

    errflg++;

   233

  }

   234

   235

  if (errflg) {

   236

    printusage(argv[0]);

   237

    return EXIT_FAILURE;

   238

  }

   239

   240

   241

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

   242

  /*   Run the compiler...   */

   243

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

   244

  /* 1st Pass */

   245

  if (stage1_2(argv[optind], &tree_root) < 0)

   246

    return EXIT_FAILURE;

   247

   248

  /* 2nd Pass */

   249

    /* basically loads some symbol tables to speed up look ups later on */

   250

  absyntax_utils_init(tree_root);  

   251

    /* moved to bison, although it could perfectly well still be here instead of in bison code. */

   252

  //add_en_eno_param_decl_c::add_to(tree_root);

   253

   254

  /* Do semantic verification of code */

   255

  if (stage3(tree_root, &ordered_tree_root) < 0)

   256

    return EXIT_FAILURE;

   257

   258

  /* 3rd Pass */

   259

  if (stage4(ordered_tree_root, builddir) < 0)

   260

    return EXIT_FAILURE;

   261

   262

  /* 4th Pass */

   263

  /* Call gcc, g++, or whatever... */

   264

  /* Currently implemented in the Makefile! */

   265

   266

  return 0;

   267

}

   268

   269