gcc/go/gofrontend/go.cc

   1 // go.cc -- Go frontend main file for gcc.
   2
   3 // Copyright 2009 The Go Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 #include "go-system.h"
   8
   9 #include "go-c.h"
  10
  11 #include "lex.h"
  12 #include "parse.h"
  13 #include "backend.h"
  14 #include "gogo.h"
  15
  16 // The data structures we build to represent the file.
  17 static Gogo* gogo;
  18
  19 // Create the main IR data structure.
  20
  21 GO_EXTERN_C
  22 void
  23 go_create_gogo(int int_type_size, int pointer_size, const char *pkgpath,
  24                const char *prefix, const char *relative_import_path)
  25 {
  26   go_assert(::gogo == NULL);
  27   Linemap* linemap = go_get_linemap();
  28   ::gogo = new Gogo(go_get_backend(), linemap, int_type_size, pointer_size);
  29
  30   if (pkgpath != NULL)
  31     ::gogo->set_pkgpath(pkgpath);
  32   else if (prefix != NULL)
  33     ::gogo->set_prefix(prefix);
  34
  35   if (relative_import_path != NULL)
  36     ::gogo->set_relative_import_path(relative_import_path);
  37 }
  38
  39 // Parse the input files.
  40
  41 GO_EXTERN_C
  42 void
  43 go_parse_input_files(const char** filenames, unsigned int filename_count,
  44                      bool only_check_syntax, bool)
  45 {
  46   go_assert(filename_count > 0);
  47
  48   for (unsigned int i = 0; i < filename_count; ++i)
  49     {
  50       if (i > 0)
  51         ::gogo->clear_file_scope();
  52
  53       const char* filename = filenames[i];
  54       FILE* file;
  55       if (strcmp(filename, "-") == 0)
  56         file = stdin;
  57       else
  58         {
  59           file = fopen(filename, "r");
  60           if (file == NULL)
  61             fatal_error("cannot open %s: %m", filename);
  62         }
  63
  64       Lex lexer(filename, file, ::gogo->linemap());
  65
  66       Parse parse(&lexer, ::gogo);
  67       parse.program();
  68
  69       if (strcmp(filename, "-") != 0)
  70         fclose(file);
  71     }
  72
  73   ::gogo->linemap()->stop();
  74
  75   ::gogo->clear_file_scope();
  76
  77   // If the global predeclared names are referenced but not defined,
  78   // define them now.
  79   ::gogo->define_global_names();
  80
  81   // Finalize method lists and build stub methods for named types.
  82   ::gogo->finalize_methods();
  83
  84   // Check that functions have a terminating statement.
  85   ::gogo->check_return_statements();
  86
  87   // Now that we have seen all the names, lower the parse tree into a
  88   // form which is easier to use.
  89   ::gogo->lower_parse_tree();
  90
  91   // Create function descriptors as needed.
  92   ::gogo->create_function_descriptors();
  93
  94   // Write out queued up functions for hash and comparison of types.
  95   ::gogo->write_specific_type_functions();
  96
  97   // Now that we have seen all the names, verify that types are
  98   // correct.
  99   ::gogo->verify_types();
 100
 101   // Work out types of unspecified constants and variables.
 102   ::gogo->determine_types();
 103
 104   // Check types and issue errors as appropriate.
 105   ::gogo->check_types();
 106
 107   if (only_check_syntax)
 108     return;
 109
 110   // Export global identifiers as appropriate.
 111   ::gogo->do_exports();
 112
 113   // Turn short-cut operators (&&, ||) into explicit if statements.
 114   ::gogo->remove_shortcuts();
 115
 116   // Use temporary variables to force order of evaluation.
 117   ::gogo->order_evaluations();
 118
 119   // Convert named types to backend representation.
 120   ::gogo->convert_named_types();
 121
 122   // Flatten the parse tree.
 123   ::gogo->flatten();
 124
 125   // Build thunks for functions which call recover.
 126   ::gogo->build_recover_thunks();
 127
 128   // Convert complicated go and defer statements into simpler ones.
 129   ::gogo->simplify_thunk_statements();
 130
 131   // Dump ast, use filename[0] as the base name
 132   ::gogo->dump_ast(filenames[0]);
 133 }
 134
 135 // Write out globals.
 136
 137 GO_EXTERN_C
 138 void
 139 go_write_globals()
 140 {
 141   return ::gogo->write_globals();
 142 }
 143
 144 // Return the global IR structure.  This is used by some of the
 145 // langhooks to pass to other code.
 146
 147 Gogo*
 148 go_get_gogo()
 149 {
 150   return ::gogo;
 151 }