OSDN Git Service

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