Subversion Repositories openrisc

// go.cc -- Go frontend main file for gcc.

// Copyright 2009 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

#include "go-system.h"

#include "go-c.h"

#include "lex.h"

#include "parse.h"

#include "backend.h"

#include "gogo.h"

// The unique prefix to use for exported symbols.  This is set during

// option processing.

static std::string unique_prefix;

// The data structures we build to represent the file.

static Gogo* gogo;

// Create the main IR data structure.

GO_EXTERN_C

void

go_create_gogo(int int_type_size, int pointer_size)

{

  go_assert(::gogo == NULL);

  Linemap* linemap = go_get_linemap();

  ::gogo = new Gogo(go_get_backend(), linemap, int_type_size, pointer_size);

  if (!unique_prefix.empty())

    ::gogo->set_unique_prefix(unique_prefix);

  // FIXME: This should be in the gcc dependent code.

  ::gogo->define_builtin_function_trees();

}

// Set the unique prefix we use for exported symbols.

GO_EXTERN_C

void

go_set_prefix(const char* arg)

{

  unique_prefix = arg;

  for (size_t i = 0; i < unique_prefix.length(); ++i)

    {

      char c = unique_prefix[i];

      if ((c >= 'a' && c <= 'z')

          || (c >= 'A' && c <= 'Z')

          || (c >= '0' && c <= '9')

          || c == '_')

        ;

      else

        unique_prefix[i] = '_';

    }

}

// Parse the input files.

GO_EXTERN_C

void

go_parse_input_files(const char** filenames, unsigned int filename_count,

                     bool only_check_syntax, bool require_return_statement)

{

  go_assert(filename_count > 0);

  for (unsigned int i = 0; i < filename_count; ++i)

    {

      if (i > 0)

        ::gogo->clear_file_scope();

      const char* filename = filenames[i];

      FILE* file;

      if (strcmp(filename, "-") == 0)

        file = stdin;

      else

        {

          file = fopen(filename, "r");

          if (file == NULL)

            fatal_error("cannot open %s: %m", filename);

        }

      Lex lexer(filename, file, ::gogo->linemap());

      Parse parse(&lexer, ::gogo);

      parse.program();

      if (strcmp(filename, "-") != 0)

        fclose(file);

    }

  ::gogo->linemap()->stop();

  ::gogo->clear_file_scope();

  // If the global predeclared names are referenced but not defined,

  // define them now.

  ::gogo->define_global_names();

  // Finalize method lists and build stub methods for named types.

  ::gogo->finalize_methods();

  // Now that we have seen all the names, lower the parse tree into a

  // form which is easier to use.

  ::gogo->lower_parse_tree();

  // Write out queued up functions for hash and comparison of types.

  ::gogo->write_specific_type_functions();

  // Now that we have seen all the names, verify that types are

  // correct.

  ::gogo->verify_types();

  // Work out types of unspecified constants and variables.

  ::gogo->determine_types();

  // Check types and issue errors as appropriate.

  ::gogo->check_types();

  if (only_check_syntax)

    return;

  // Check that functions have return statements.

  if (require_return_statement)

    ::gogo->check_return_statements();

  // Export global identifiers as appropriate.

  ::gogo->do_exports();

  // Turn short-cut operators (&&, ||) into explicit if statements.

  ::gogo->remove_shortcuts();

  // Use temporary variables to force order of evaluation.

  ::gogo->order_evaluations();

  // Build thunks for functions which call recover.

  ::gogo->build_recover_thunks();

  // Convert complicated go and defer statements into simpler ones.

  ::gogo->simplify_thunk_statements();

  // Dump ast, use filename[0] as the base name

  ::gogo->dump_ast(filenames[0]);

}

// Write out globals.

GO_EXTERN_C

void

go_write_globals()

{

  return ::gogo->write_globals();

}

// Return the global IR structure.  This is used by some of the

// langhooks to pass to other code.

Gogo*

go_get_gogo()

{

  return ::gogo;

}