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>   // printf()

    71

#include <getopt.h>

    72

#include <string.h>

    73

#include <stdlib.h>  // EXIT_FAILURE

    74

#include "absyntax/absyntax.hh"  // symbol_c type

    75

    76

/* A macro for printing out internal parser errors... */

    77

#include <iostream> // required for std::cerr

    78

    79

    80

#define ERROR          error_exit(__FILE__,__LINE__)

    81

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

    82

  std::cerr << "\nInternal compiler error in file " << file_name

    83

            << " at line " << line_no << "\n";

    84

//   if (msg != NULL) std::cerr << message << "\n\n";

    85

  exit(EXIT_FAILURE);

    86

}

    87

    88

    89

    90

#include "config/config.h"

    91

#include "stage1_2/stage1_2.hh"

    92

#include "absyntax_utils/absyntax_utils.hh"

    93

    94

int stage3(symbol_c *tree_root);

    95

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

    96

    97

    98

static void printusage(const char *cmd) {

    99

  printf("syntax: %s [-h] [-v] [-f] [-s] [-I <include_directory>] [-T <target_directory>] <input_file>\n", cmd);

   100

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

   101

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

   102

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

   103

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

   104

      /* whether we are suporting safe extensions           */

   105

      /* as defined in PLCopen - Technical Committee 5      */

   106

      /* Safety Software Technical Specification,           */

   107

      /* Part 1: Concepts and Function Blocks,              */

   108

      /* Version 1.0 – Official Release                     */

   109

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

   110

  printf("  s : allow use of safe extensions\n");

   111

  printf("\n");

   112

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

   113

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

   114

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

   115

}

   116

   117

   118

   119

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

   120

  symbol_c *tree_root;

   121

  char * builddir = NULL;

   122

  stage1_2_options_t stage1_2_options = {false, false, NULL};

   123

  int optres, errflg = 0;

   124

/*

   125

  extern char *optarg;

   126

  extern int optind, optopt;

   127

*/

   128

   129

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

   130

  /*   Parse command line options...        */

   131

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

   132

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

   133

    switch(optres) {

   134

    case 'h':

   135

      printusage(argv[0]);

   136

      return 0;

   137

    case 'v':

   138

      fprintf(stdout, "%s version %s\n", PACKAGE_NAME, PACKAGE_VERSION);      

   139

      return 0;        

   140

    case 'f':

   141

      stage1_2_options.full_token_loc = true;

   142

      break;

   143

    case 's':

   144

      stage1_2_options.safe_extensions = true;

   145

      break;

   146

    case 'I':

   147

      stage1_2_options.includedir = optarg;

   148

      break;

   149

    case 'T':

   150

      builddir = optarg;

   151

      break;

   152

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

   153

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

   154

      errflg++;

   155

      break;

   156

    case '?':

   157

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

   158

      errflg++;

   159

      break;

   160

    default:

   161

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

   162

      errflg++;

   163

      break;

   164

    }

   165

  }

   166

   167

  if (optind == argc) {

   168

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

   169

    errflg++;

   170

  }

   171

   172

  if (optind > argc) {

   173

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

   174

    errflg++;

   175

  }

   176

   177

  if (errflg) {

   178

      printf("\n");

   179

      printusage(argv[0]);

   180

      return EXIT_FAILURE;

   181

  }

   182

   183

   184

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

   185

  /*   Run the compiler...   */

   186

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

   187

  /* 1st Pass */

   188

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

   189

    return EXIT_FAILURE;

   190

   191

  /* 2nd Pass */

   192

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

   193

  absyntax_utils_init(tree_root);  

   194

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

   195

  //add_en_eno_param_decl_c::add_to(tree_root);

   196

   197

  /* Only very simple (not yet complete) data type checking currently implemented... */

   198

  if (stage3(tree_root) < 0)

   199

    return EXIT_FAILURE;

   200

   201

   202

  /* 3rd Pass */

   203

  if (stage4(tree_root, builddir) < 0)

   204

    return EXIT_FAILURE;

   205

   206

  /* 4th Pass */

   207

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

   208

  /* Currently implemented in the Makefile! */

   209

   210

  return 0;

   211

}

   212

   213