dmd.common.outbuffer

An expandable buffer in which you can write text or binary data.

Authors

Walter Bright, https://www.digitalmars.com

  • Declaration

    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.

    • Declaration

      bool doindent;

      Whether to indent

    • Declaration

      bool spaces;

      Whether to indent by 4 spaces or by tabs;

    • Declaration

      int level;

      Current indent level

    • Declaration

      nothrow this(size_t initialSize);

      Construct given size.

    • Declaration

      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.

      Parameters

      const(char)* filename

      zero-terminated name of file to map into memory

    • Declaration

      pure nothrow @trusted void dtor();

      Frees resources associated.

    • buf

      Declaration

      nothrow @system ubyte* buf();

      For porting with ease from dmd.backend.outbuf.Outbuffer

    • Declaration

      nothrow @system ubyte** bufptr();

      For porting with ease from dmd.backend.outbuf.Outbuffer

    • Declaration

      pure nothrow @nogc @trusted char* extractData();

      Transfer ownership of the allocated data to the caller.

      Return Value

      pointer to the allocated data

    • Declaration

      pure nothrow @trusted 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.

    • Declaration

      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.

      Parameters

      size_t nbytes

      the number of additional bytes to reserve

    • Declaration

      pure nothrow @nogc @safe void setsize(size_t size);

      Shrink the size of the data to size.

      Parameters

      size_t size

      new size of data, must be <= .length

    • Declaration

      nothrow @trusted void write16n(int v);

      Writes a 16 bit value, no reserve check.

    • Declaration

      nothrow void write16(int v);

      Writes a 16 bit value.

    • Declaration

      nothrow @trusted void write32(int v);

      Writes a 32 bit int.

    • Declaration

      nothrow @trusted void write64(long v);

      Writes a 64 bit int.

    • Declaration

      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);

      NOT zero-terminated

    • Declaration

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

      NOT zero-terminated, followed by newline

    • Declaration

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

      Write string to buffer, ensure it is zero terminated

    • Declaration

      pure nothrow @safe void writenl();

      strip trailing tabs or spaces, write newline

    • Declaration

      nothrow @trusted void writeByten(int b);

      Writes an 8 bit byte, no reserve check.

    • Declaration

      pure nothrow char[] allocate(size_t nbytes);

      Allocate space, but leave it uninitialized.

      Parameters

      size_t nbytes

      amount to allocate

      Return Value

      slice of the allocated space to be filled in

    • Declaration

      pure nothrow @safe void print(ulong u);

      Convert u to a string and append it to the buffer.

      Parameters

      ulong u

      integral value to append

    • Declaration

      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.

    • Declaration

      pure nothrow @system size_t insert(size_t offset, const(void)* p, size_t nbytes);

      Return Value

      offset + nbytes

    • Declaration

      const pure nothrow @nogc @safe const(char)[] opSlice();

      Return Value

      a non-owning const slice of the buffer contents

    • Declaration

      pure nothrow char[] extractSlice(bool nullTerminate = false);

      Extract the data as a slice and take ownership of it.

      Discussion

      When true is passed as an argument, this function behaves like dmd.utils.toDString(thisbuffer.extractChars()).

      Parameters

      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.

    • Declaration

      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.

      Parameters

      char* filename

      the name of the file to receive the contents

      Return Value

      true iff the operation succeeded.