Subversion Repositories openrisc

// export.h -- Export declarations in Go frontend.     -*- C++ -*-

// 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.

#ifndef GO_EXPORT_H

#define GO_EXPORT_H

#include "string-dump.h"

struct sha1_ctx;

class Gogo;

class Import_init;

class Bindings;

class Type;

class Package;

// Codes used for the builtin types.  These are all negative to make

// them easily distinct from the codes assigned by Export::write_type.

// Note that these codes may not be changed!  Changing them would

// break existing export data.

enum Builtin_code

{

  BUILTIN_INT8 = -1,

  BUILTIN_INT16 = -2,

  BUILTIN_INT32 = -3,

  BUILTIN_INT64 = -4,

  BUILTIN_UINT8 = -5,

  BUILTIN_UINT16 = -6,

  BUILTIN_UINT32 = -7,

  BUILTIN_UINT64 = -8,

  BUILTIN_FLOAT32 = -9,

  BUILTIN_FLOAT64 = -10,

  BUILTIN_INT = -11,

  BUILTIN_UINT = -12,

  BUILTIN_UINTPTR = -13,

  BUILTIN_BOOL = -15,

  BUILTIN_STRING = -16,

  BUILTIN_COMPLEX64 = -17,

  BUILTIN_COMPLEX128 = -18,

  BUILTIN_ERROR = -19,

  BUILTIN_BYTE = -20,

  BUILTIN_RUNE = -21,

  SMALLEST_BUILTIN_CODE = -21

};

// This class manages exporting Go declarations.  It handles the main

// loop of exporting.  A pointer to this class is also passed to the

// various specific export implementations.

class Export : public String_dump

{

 public:

  // The Stream class is an interface used to output the exported

  // information.  The caller should instantiate a child of this

  // class.

  class Stream

  {

   public:

    Stream();

    virtual ~Stream();

    // Write a string. Implements the String_dump interface.

    void

    write_string(const std::string& s)

    { this->write_and_sum_bytes(s.data(), s.length()); }

    // Write a nul terminated string. Implements the String_dump interface.

    void

    write_c_string(const char* s)

    { this->write_and_sum_bytes(s, strlen(s)); }

    // Write some bytes.

    void

    write_bytes(const char* bytes, size_t length)

    { this->write_and_sum_bytes(bytes, length); }

    // Return the raw bytes of the checksum data.

    std::string

    checksum();

    // Write a checksum string to the stream.  This will be called at

    // the end of the other output.

    void

    write_checksum(const std::string&);

   protected:

    // This function is called with data to export.  This data must be

    // made available as a contiguous stream for the importer.

    virtual void

    do_write(const char* bytes, size_t length) = 0;

  private:

    void

    write_and_sum_bytes(const char*, size_t);

    // The checksum.

    sha1_ctx* checksum_;

  };

  Export(Stream*);

  // The magic code for version 1 export data.

  static const int v1_magic_len = 4;

  static const char v1_magic[v1_magic_len];

  // The length of the v1 checksum string.

  static const int v1_checksum_len = 20;

  // Register the builtin types.

  void

  register_builtin_types(Gogo*);

  // Export the identifiers in BINDINGS which are marked for export.

  // The exporting is done via a series of calls to THIS->STREAM_.  If

  // is nothing to export, this->stream_->write will not be called.

  // UNIQUE_PREFIX is a prefix for all global symbols.

  // PACKAGE_PRIORITY is the priority to use for this package.

  // IMPORT_INIT_FN is the name of the import initialization function

  // for this package; it will be empty if none is needed.

  // IMPORTED_INIT_FNS is the list of initialization functions for

  // imported packages.

  void

  export_globals(const std::string& package_name,

                 const std::string& unique_prefix,

                 int package_priority,

                 const std::map<std::string, Package*>& imports,

                 const std::string& import_init_fn,

                 const std::set<Import_init>& imported_init_fns,

                 const Bindings* bindings);

  // Write a string to the export stream.

  void

  write_string(const std::string& s)

  { this->stream_->write_string(s); }

  // Write a nul terminated string to the export stream.

  void

  write_c_string(const char* s)

  { this->stream_->write_c_string(s); }

  // Write some bytes to the export stream.

  void

  write_bytes(const char* bytes, size_t length)

  { this->stream_->write_bytes(bytes, length); }

  // Write a name to the export stream.  If NAME is empty, write "?".

  void

  write_name(const std::string& name);

  // Write out a type.  This handles references back to previous

  // definitions.

  void

  write_type(const Type*);

 private:

  Export(const Export&);

  Export& operator=(const Export&);

  // Write out the imported packages.

  void

  write_imports(const std::map<std::string, Package*>& imports);

  // Write out the imported initialization functions.

  void

  write_imported_init_fns(const std::string& package_name, int priority,

                          const std::string&, const std::set<Import_init>&);

  // Register one builtin type.

  void

  register_builtin_type(Gogo*, const char* name, Builtin_code);

  // Mapping from Type objects to a constant index.

  typedef Unordered_map(const Type*, int) Type_refs;

  // The stream to which we are writing data.

  Stream* stream_;

  // Type mappings.

  Type_refs type_refs_;

  // Index number of next type.

  int type_index_;

};

// An export streamer which puts the export stream in a named section.

class Stream_to_section : public Export::Stream

{

 public:

  Stream_to_section();

 protected:

  void

  do_write(const char*, size_t);

};

#endif // !defined(GO_EXPORT_H)