1// export.h -- Export declarations in Go frontend.     -*- C++ -*-
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#ifndef GO_EXPORT_H
8#define GO_EXPORT_H
9
10#include "string-dump.h"
11
12struct sha1_ctx;
13class Gogo;
14class Import_init;
15class Bindings;
16class Type;
17class Package;
18
19// Codes used for the builtin types.  These are all negative to make
20// them easily distinct from the codes assigned by Export::write_type.
21// Note that these codes may not be changed!  Changing them would
22// break existing export data.
23
24enum Builtin_code
25{
26  BUILTIN_INT8 = -1,
27  BUILTIN_INT16 = -2,
28  BUILTIN_INT32 = -3,
29  BUILTIN_INT64 = -4,
30  BUILTIN_UINT8 = -5,
31  BUILTIN_UINT16 = -6,
32  BUILTIN_UINT32 = -7,
33  BUILTIN_UINT64 = -8,
34  BUILTIN_FLOAT32 = -9,
35  BUILTIN_FLOAT64 = -10,
36  BUILTIN_INT = -11,
37  BUILTIN_UINT = -12,
38  BUILTIN_UINTPTR = -13,
39  BUILTIN_BOOL = -15,
40  BUILTIN_STRING = -16,
41  BUILTIN_COMPLEX64 = -17,
42  BUILTIN_COMPLEX128 = -18,
43  BUILTIN_ERROR = -19,
44  BUILTIN_BYTE = -20,
45  BUILTIN_RUNE = -21,
46
47  SMALLEST_BUILTIN_CODE = -21
48};
49
50// This class manages exporting Go declarations.  It handles the main
51// loop of exporting.  A pointer to this class is also passed to the
52// various specific export implementations.
53
54class Export : public String_dump
55{
56 public:
57  // The Stream class is an interface used to output the exported
58  // information.  The caller should instantiate a child of this
59  // class.
60  class Stream
61  {
62   public:
63    Stream();
64    virtual ~Stream();
65
66    // Write a string. Implements the String_dump interface.
67    void
68    write_string(const std::string& s)
69    { this->write_and_sum_bytes(s.data(), s.length()); }
70
71    // Write a nul terminated string. Implements the String_dump interface.
72    void
73    write_c_string(const char* s)
74    { this->write_and_sum_bytes(s, strlen(s)); }
75
76    // Write some bytes.
77    void
78    write_bytes(const char* bytes, size_t length)
79    { this->write_and_sum_bytes(bytes, length); }
80
81    // Return the raw bytes of the checksum data.
82    std::string
83    checksum();
84
85    // Write a checksum string to the stream.  This will be called at
86    // the end of the other output.
87    void
88    write_checksum(const std::string&);
89
90   protected:
91    // This function is called with data to export.  This data must be
92    // made available as a contiguous stream for the importer.
93    virtual void
94    do_write(const char* bytes, size_t length) = 0;
95
96  private:
97    void
98    write_and_sum_bytes(const char*, size_t);
99
100    // The checksum.
101    sha1_ctx* checksum_;
102  };
103
104  Export(Stream*);
105
106  // The magic code for version 1 export data.
107  static const int v1_magic_len = 4;
108  static const char v1_magic[v1_magic_len];
109
110  // The length of the v1 checksum string.
111  static const int v1_checksum_len = 20;
112
113  // Register the builtin types.
114  void
115  register_builtin_types(Gogo*);
116
117  // Export the identifiers in BINDINGS which are marked for export.
118  // The exporting is done via a series of calls to THIS->STREAM_.  If
119  // is nothing to export, this->stream_->write will not be called.
120  // PREFIX is the package prefix.  PKGPATH is the package path.
121  // Only one of PREFIX and PKGPATH will be non-empty.
122  // PACKAGE_PRIORITY is the priority to use for this package.
123  // PACKAGES is all the packages we have seen.
124  // IMPORTS is the explicitly imported packages.
125  // IMPORT_INIT_FN is the name of the import initialization function
126  // for this package; it will be empty if none is needed.
127  // IMPORTED_INIT_FNS is the list of initialization functions for
128  // imported packages.
129  void
130  export_globals(const std::string& package_name,
131		 const std::string& prefix,
132		 const std::string& pkgpath,
133		 int package_priority,
134		 const std::map<std::string, Package*>& packages,
135		 const std::map<std::string, Package*>& imports,
136		 const std::string& import_init_fn,
137		 const std::set<Import_init>& imported_init_fns,
138		 const Bindings* bindings);
139
140  // Write a string to the export stream.
141  void
142  write_string(const std::string& s)
143  { this->stream_->write_string(s); }
144
145  // Write a nul terminated string to the export stream.
146  void
147  write_c_string(const char* s)
148  { this->stream_->write_c_string(s); }
149
150  // Write some bytes to the export stream.
151  void
152  write_bytes(const char* bytes, size_t length)
153  { this->stream_->write_bytes(bytes, length); }
154
155  // Write a name to the export stream.  If NAME is empty, write "?".
156  void
157  write_name(const std::string& name);
158
159  // Write out a type.  This handles references back to previous
160  // definitions.
161  void
162  write_type(const Type*);
163
164 private:
165  Export(const Export&);
166  Export& operator=(const Export&);
167
168  // Write out all known packages.
169  void
170  write_packages(const std::map<std::string, Package*>& packages);
171
172  // Write out the imported packages.
173  void
174  write_imports(const std::map<std::string, Package*>& imports);
175
176  // Write out the imported initialization functions.
177  void
178  write_imported_init_fns(const std::string& package_name, int priority,
179			  const std::string&, const std::set<Import_init>&);
180
181  // Register one builtin type.
182  void
183  register_builtin_type(Gogo*, const char* name, Builtin_code);
184
185  // Mapping from Type objects to a constant index.
186  typedef Unordered_map(const Type*, int) Type_refs;
187
188  // The stream to which we are writing data.
189  Stream* stream_;
190  // Type mappings.
191  Type_refs type_refs_;
192  // Index number of next type.
193  int type_index_;
194  // Packages we have written out.
195  Unordered_set(const Package*) packages_;
196};
197
198// An export streamer which puts the export stream in a named section.
199
200class Stream_to_section : public Export::Stream
201{
202 public:
203  Stream_to_section();
204
205 protected:
206  void
207  do_write(const char*, size_t);
208};
209
210#endif // !defined(GO_EXPORT_H)
211