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

#define ERROR error_exit(__FILE__,__LINE__)

    79

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

    80

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

    81

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

    82

  exit(EXIT_FAILURE);

    83

}

    84

    85

    86

    87

    88

#include "stage1_2/stage1_2.hh"

    89

#include "absyntax_utils/absyntax_utils.hh"

    90

    91

int stage3(symbol_c *tree_root);

    92

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

    93

    94

    95

static void printusage(const char *cmd) {

    96

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

    97

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

    98

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

    99

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

   100

      /* whether we are suporting safe extensions           */

   101

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

   102

      /* Safety Software Technical Specification,           */

   103

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

   104

      /* Version 1.0 – Official Release                     */

   105

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

   106

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

   107

  printf("\n");

   108

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

   109

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

   110

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

   111

}

   112

   113

   114

   115

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

   116

  symbol_c *tree_root;

   117

  char * builddir = NULL;

   118

  stage1_2_options_t stage1_2_options = {false, false, NULL};

   119

  int optres, errflg = 0;

   120

/*

   121

  extern char *optarg;

   122

  extern int optind, optopt;

   123

*/

   124

   125

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

   126

  /*   Parse command line options...        */

   127

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

   128

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

   129

    switch(optres) {

   130

    case 'h':

   131

      printusage(argv[0]);

   132

      return 0;

   133

      break;

   134

    case 'f':

   135

      stage1_2_options.full_token_loc = true;

   136

      break;

   137

    case 's':

   138

      stage1_2_options.safe_extensions = true;

   139

      break;

   140

    case 'I':

   141

      stage1_2_options.includedir = optarg;

   142

      break;

   143

    case 'T':

   144

      builddir = optarg;

   145

      break;

   146

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

   147

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

   148

      errflg++;

   149

      break;

   150

    case '?':

   151

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

   152

      errflg++;

   153

      break;

   154

    default:

   155

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

   156

      errflg++;

   157

      break;

   158

    }

   159

  }

   160

   161

  if (optind == argc) {

   162

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

   163

    errflg++;

   164

  }

   165

   166

  if (optind > argc) {

   167

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

   168

    errflg++;

   169

  }

   170

   171

  if (errflg) {

   172

      printusage(argv[0]);

   173

      return EXIT_FAILURE;

   174

  }

   175

   176

   177

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

   178

  /*   Run the compiler...   */

   179

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

   180

  /* 1st Pass */

   181

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

   182

    return EXIT_FAILURE;

   183

   184

  /* 2nd Pass */

   191

  if (stage3(tree_root) < 0)

   192

    return EXIT_FAILURE;

   193

   194

   195

  /* 3rd Pass */

   196

  if (stage4(tree_root, builddir) < 0)

   197

    return EXIT_FAILURE;

   198

   199

  /* 4th Pass */

   201

  /* Currently implemented in the Makefile! */

   202

   203

  return 0;

   204

}

   205

   206