From b81ff3ef968d1cc4e954b31a1812b3c391d17b02 Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Fri, 31 May 2019 13:17:34 -0400 Subject: WIP: Support for other source target language (#971) * WIP: Setting up C/Cpp source compilation targets. * WIP: Emitting C/CPP. * WIP: Split out SourceSink, and use it for source output on emit. * SourceSink -> SourceStream * * Made SourceStream use m_ prefixing of members. * Make all methods use lower camel * Removed methods from SourceStream interface that are not used externally (use _ prefixing) * Improvements to documentation * EmitContext is now effectively empty, so just use SharedEmitContext as EmitContext. * SharedEmitContext -> EmitContext * Methods to LowerCamel in emit.cpp * Split out EmitContext and ExtensionUsageTracker into separate files. * Split out EmitVisitor into slang-c-like-source-emitter files. * EmitVisitor -> CLikeSourceEmitter * Tidy up around CLikeSourceEmitter - simplify header. * Small tidy up - removing repeated comments that are in header. * Remove EmitContext paramter threading. * Small tidy up. Use prefixed macros for slang-c-like-source-emitter.h * Small tidy up in slang-c-like-source-emitter.cpp * First pass at splitting out UnmangleContext. * MangledNameParser -> MangledLexer. * WIP making EmitOp (EOp) enum available outside of cpp * Generating EmitOpInfo from macro. * Split out emit precedence handling. Don't use kOp_ style anymore, just use an array indexed by EmitOp. * Disable C simple test for now. * Keep g++/clang happy with token pasting. * Fix win32 narrowing warning. --- source/slang/slang-source-stream.h | 113 +++++++++++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+) create mode 100644 source/slang/slang-source-stream.h (limited to 'source/slang/slang-source-stream.h') diff --git a/source/slang/slang-source-stream.h b/source/slang/slang-source-stream.h new file mode 100644 index 000000000..8dcd29c8d --- /dev/null +++ b/source/slang/slang-source-stream.h @@ -0,0 +1,113 @@ +// slang-source-stream.h +#ifndef SLANG_SOURCE_STREAM_H_INCLUDED +#define SLANG_SOURCE_STREAM_H_INCLUDED + +#include "../core/basic.h" + +#include "compiler.h" + +namespace Slang +{ + +/* Class that encapsulates a stream of source. Facilities provided... + +* Management of the buffer that holds the source content as it is constructed +* output line directives + + Supports GLSL as well as C/CPP/HLSL style directives +* Support for line indention */ +class SourceStream +{ +public: + /// Emits without span without any extra processing + void emitRawTextSpan(char const* textBegin, char const* textEnd); + void emitRawText(char const* text); + + /// Emit different types into the stream + void emit(char const* textBegin, char const* textEnd); + void emit(char const* text); + void emit(const String& text); + void emit(const UnownedStringSlice& text); + void emit(Name* name); + void emit(const NameLoc& nameAndLoc); + void emit(IntegerLiteralValue value); + void emit(UInt value); + void emit(int value); + void emit(double value); + + /// Emit names (doing so can also advance to a new source location) + void emitName(const NameLoc& nameAndLoc); + void emitName(Name* name, const SourceLoc& loc); + void emitName(Name* name); + + /// Indent the text + void indent(); + /// Dedent (the opposite of indenting) the text + void dedent(); + + /// Move the current source location to that specified + void advanceToSourceLocation(const SourceLoc& sourceLocation); + void advanceToSourceLocation(const HumaneSourceLoc& sourceLocation); + + /// Get the content as a string + String getContent() { return m_builder.ProduceString(); } + /// Clear the content + void clearContent() { m_builder.Clear(); } + /// Get the content as a string and clear the internal representation + String getContentAndClear(); + + /// Get the line directive mode used + LineDirectiveMode getLineDirectiveMode() const { return m_lineDirectiveMode; } + /// Get the source manager user + SourceManager* getSourceManager() const { return m_sourceManager; } + + /// Ctor + SourceStream(SourceManager* sourceManager, LineDirectiveMode lineDirectiveMode); + +protected: + void _emitTextSpan(char const* textBegin, char const* textEnd); + void _flushSourceLocationChange(); + + // Emit a `#line` directive to the output, and also + // ensure that source location tracking information + // is correct based on the directive we just output. + void _emitLineDirectiveAndUpdateSourceLocation(const HumaneSourceLoc& sourceLocation); + + void _emitLineDirectiveIfNeeded(const HumaneSourceLoc& sourceLocation); + + // Emit a `#line` directive to the output. + // Doesn't update state of source-location tracking. + void _emitLineDirective(const HumaneSourceLoc& sourceLocation); + + // The string of code we've built so far. + // TODO(JS): We could store the text in chunks, and then only sew together into one buffer + // when we are done. Doing so would not require copies/reallocs until the full buffer has been + // produced. A downside to doing this is that it won't be so simple to debug by trying to + // look at the current contents of the buffer + StringBuilder m_builder; + + // Current source position for tracking purposes... + HumaneSourceLoc m_loc; + HumaneSourceLoc m_nextSourceLocation; + bool m_needToUpdateSourceLocation = false; + + // Are we at the start of a line, so that we should indent + // before writing any other text? + bool m_isAtStartOfLine = true; + + // How far are we indented? + Int m_indentLevel = 0; + + SourceManager* m_sourceManager = nullptr; + + // For GLSL output, we can't emit traditional `#line` directives + // with a file path in them, so we maintain a map that associates + // each path with a unique integer, and then we output those + // instead. + Dictionary m_mapGLSLSourcePathToID; + int m_glslSourceIDCount = 0; + + LineDirectiveMode m_lineDirectiveMode; +}; + +} +#endif -- cgit v1.2.3