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