Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.


An expandable buffer in which you can write text or binary data.
struct OutBuffer;
OutBuffer is a write-only output stream of untyped data. It is backed up by a contiguous array or a memory-mapped file.
bool doindent;
Whether to indent
bool spaces;
Whether to indent by 4 spaces or by tabs;
int level;
Current indent level
nothrow @safe this(size_t initialSize);
Construct given size.
nothrow @trusted this(const(char)* filename);
Construct from filename. Will map the file into memory (or create it anew if necessary) and start writing at the beginning of it.
const(char)* filename zero-terminated name of file to map into memory
pure nothrow @trusted void dtor();
Frees resources associated.
nothrow @system ubyte* buf();
For porting with ease from dmd.backend.outbuf.Outbuffer
nothrow @system ubyte** bufptr();
For porting with ease from dmd.backend.outbuf.Outbuffer
pure nothrow @nogc @trusted char* extractData();
Transfer ownership of the allocated data to the caller.
pointer to the allocated data
pure nothrow void destroy();
Releases all resources associated with this and resets it as an empty memory buffer. The config variables notlinehead, doindent etc. are not changed.
pure nothrow @trusted void reserve(size_t nbytes);
Reserves nbytes bytes of additional memory (or file space) in advance. The resulting capacity is at least the previous length plus nbytes.
size_t nbytes the number of additional bytes to reserve
pure nothrow @nogc @safe void setsize(size_t size);
Shrink the size of the data to size.
size_t size new size of data, must be <= .length
nothrow void write16n(int v);
Writes a 16 bit value, no reserve check.
nothrow void write16(int v);
Writes a 16 bit value.
nothrow @trusted void write32(int v);
Writes a 32 bit int.
nothrow @trusted void write64(long v);
Writes a 64 bit int.
pure nothrow @system void writestring(const(char)* s);

pure nothrow @safe void writestring(scope const(char)[] s);

pure nothrow @safe void writestring(scope string s);
Buffer will NOT be zero-terminated
pure nothrow @safe void writestringln(const(char)[] s);
Buffer will NOT be zero-terminated, followed by newline
pure nothrow @system void writeStringz(const(char)* s);

pure nothrow @safe void writeStringz(const(char)[] s);

pure nothrow @safe void writeStringz(string s);
Write C string AND null byte
pure nothrow @safe void writenl();
strip trailing tabs or spaces, write newline
nothrow @safe void writeByten(int b);
Writes an 8 bit byte, no reserve check.
pure nothrow @safe char[] allocate(size_t nbytes);
Allocate space, but leave it uninitialized.
size_t nbytes amount to allocate
slice of the allocated space to be filled in
pure nothrow @safe void print(ulong u);
Convert u to a string and append it to the buffer.
ulong u integral value to append
pure nothrow @system size_t bracket(size_t i, const(char)* left, size_t j, const(char)* right);
Insert left at i, and right at j. Return index just past right.
pure nothrow @system size_t insert(size_t offset, const(void)* p, size_t nbytes);
offset + nbytes
const pure nothrow @nogc @safe const(char)[] opSlice();
a non-owning const slice of the buffer contents
pure nothrow char[] extractSlice(bool nullTerminate = false);
Extract the data as a slice and take ownership of it.
When true is passed as an argument, this function behaves like dmd.utils.toDString(thisbuffer.extractChars()).
bool nullTerminate When true, the data will be null terminated. This is useful to call C functions or store the result in Strings. Defaults to false.
pure nothrow @safe void writeHexString(scope const(ubyte)[] data, bool upperCase);
Write an array as a string of hexadecimal digits
const(ubyte)[] data bytes to write
bool upperCase whether to upper case hex digits A-F
nothrow @system bool moveToFile(const char* filename);
Destructively saves the contents of this to filename. As an optimization, if the file already has identical contents with the buffer, no copying is done. This is because on SSD drives reading is often much faster than writing and because there's a high likelihood an identical file is written during the build process.
char* filename the name of the file to receive the contents
true iff the operation succeeded.