1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
// 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
struct sha1_ctx;
class Gogo;
class Import_init;
class Bindings;
class Type;
// 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,
SMALLEST_BUILTIN_CODE = -18
};
// 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:
// 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.
void
write_string(const std::string& s)
{ this->write_and_sum_bytes(s.data(), s.length()); }
// Write a nul terminated string.
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::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 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 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);
private:
// The section we are writing to; this is really union section
// defined in output.h.
void* section_;
};
#endif // !defined(GO_EXPORT_H)
|
