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