bluehelp.xml

charp compiler

            So once it returns true, it will always return true.
            </remarks>
            <returns>Return true if we've had any errors since startup, false if we've had no errors.</returns>
        </member>
        <member name="T:ManualParser.Token">
            <summary>
            A single lexeme from a source file. These are produced by a <see cref="T:Blue.Public.ILexer"/>
            and consumed by a parser.
            </summary>
        </member>
        <member name="T:ManualParser.Lexer">
            <summary>
            A lexer to convert a <see cref="T:System.IO.TextReader"/> into a stream of <see cref="T:ManualParser.Token"/> objects.
            </summary>
            <remarks>
            <see cref="T:Blue.Public.ILexer"/> implementation used by the <see cref="T:ManualParser.Parser"/> to parse a source file.
            Also handles the preprocessor.
            </remarks>
        </member>
        <member name="T:ManualParser.Parser">
            <summary>
            The primary parser implementation. Convert a token stream for a source file 
            obtained by an <see cref="T:Blue.Public.ILexer"/> into a parse tree.
            Parse errors are handled by throwing <see cref="T:ManualParser.Parser.ParserErrorException"/>
            </summary>
        </member>
        <member name="T:ManualParser.Parser.ParserErrorException">
            <summary>
            ParserErrorException represents parse errors due to bad user-input.
            </summary>
        </member>
        <member name="T:ManualParser.Parser.Code">
            <summary>
            Syntax error codes specific to Parser 
            </summary>    
        </member>
        <member name="T:SymbolEngine.Scope">
            <summary>
            A scope is a low-level object to associate <see cref="T:Identifier"/> objects 
            with <see cref="T:SymbolEngine.SymEntry"/> objects.
            <seealso cref="T:SymbolEngine.ILookupController"/>      
            </summary>    
            <remarks>
            
            <para>Every scope has a lexical parent. The following list shows what type
            of scopes can be lexically nested in which other scopes:
            <list type="bullet">
            <item>block -&gt; block, method</item>
            <item>method -&gt; class</item>
            <item>class -&gt; class, interface, namespace</item>
            <item>interface -&gt; namespace </item>
            <item>namespace -&gt; namespace</item>
            </list> </para>
            
            <para> Scopes have no knowledge of either the higher level type-system nor any 
            object derived from <see cref="T:SymbolEngine.SymEntry"/>.  </para>
            
            <para> Each of the different scopes above may also inherit items from super scopes
            A class's scope inherits from its base class. An interface inherits from all of
            its base interfaces. Some scopes, such as those for blocks and methods, only have
            a lexical parent, but no logical parent to inherit from.</para>
            <para>Because a scope is a 'dumb' object, it can't be aware of its super scopes.
            So a scope uses an <see cref="T:SymbolEngine.ILookupController"/> to do smart lookups in 
            super scopes.</para> 
            </remarks>
        </member>
        <member name="M:SymbolEngine.Scope.#ctor(System.String,SymbolEngine.ILookupController,SymbolEngine.Scope)">
            <summary>
            Create a Scope object
            <seealso cref="M:SymbolEngine.Scope.CreateSharedScope(SymbolEngine.ILookupController,SymbolEngine.Scope)"/>
            </summary>
            <param name="szDebugName">A string name to identify the scope for debugging uses.</param>
            <param name="pController">An ILookupController to allow the scope to do smart lookups. (can be null)</param>
            <param name="scopeLexicalParent">The lexical parent of the scope. (may be null). </param>
        </member>
        <member name="M:SymbolEngine.Scope.CreateSharedScope(SymbolEngine.ILookupController,SymbolEngine.Scope)">
            <summary>
            Create a scope that has its own controller and lexical parent, but shares
            a set of symbols with an existing scope.
            </summary>
            <remark>
            We may want multiple Scopes with different controllers but that share 
            the same symbol set.
            <para>Ex: A namespace can be declared in multiple blocks. All sections reside
            in the same scope. However, each block has its own set of using
            directives. So we want multiple scopes that share the same set of symbols, 
            but each scope needs its own controller to handle its own set of using directives</para>        
            </remark>
            <param name="pController">The controller for the new scope</param>
            <param name="scopeLexicalParent"></param>
            <returns>A new scope with the specified lexical parent and owned by the given 
            controller, but sharing the same set of symbols as the current scope.</returns>
        </member>
        <member name="M:SymbolEngine.Scope.AddSymbol(SymbolEngine.SymEntry)">
            <summary>
            Add a symbol to this scope. (SymEntry contains the string name)        
            <seealso cref="M:SymbolEngine.Scope.AddAliasSymbol(System.String,SymbolEngine.SymEntry)"/>
            </summary>
            <remarks>
            Adds the given Symbol to this scope, and indexes it by the symbol's name.        
            </remarks>
            <param name="s">The symbol to add</param>
        </member>
        <member name="M:SymbolEngine.Scope.AddAliasSymbol(System.String,SymbolEngine.SymEntry)">
            <summary>
            Add a symbol under an aliased name.
            </summary>
            <remarks>
            Add an existing symbol entry, but indexed under a new name
            <para><example>
            [globalscope].AddAliasSymbol("int", [SymEntry for System.Int32]);
            </example></para>
            <seealso cref="M:SymbolEngine.Scope.AddSymbol(SymbolEngine.SymEntry)"/>
            </remarks>
            <param name="stAliasName">Aliased name of the symbol</param>
            <param name="s">Symbol to add</param>                
        </member>
        <member name="M:SymbolEngine.Scope.LookupSymbol(System.String)">
            <summary>
            Do a deep lookup in this scope. This includes super scopes but not lexical parents.
            </summary>
            <remarks>
            <para>If this scope does not have an ILookupController, this is equivalent to 
            just calling <see cref="M:SymbolEngine.Scope.LookupSymbolInThisScopeOnly(System.String)"/> </para>
            <para>else this calls <see cref="M:SymbolEngine.ILookupController.SmartLookup(System.String,SymbolEngine.Scope)"/></para>
            </remarks>
            <param name="strName">String name to search for</param>
            <returns>A symbol added under this name. Null if not found.</returns>
        </member>
        <member name="M:SymbolEngine.Scope.LookupSymbolInThisScopeOnly(System.String)">
            <summary>
            Lookup a SymEntry only in this scope. Don't search super scopes or lexical parents. 
            </summary>
            <remarks>This is a shallow lookup that does not invoke the ILookupController</remarks>
            <param name="strName">String name to search for.</param>
            <returns>A symbol added under this name. Null if not found.</returns>
        </member>
        <member name="P:SymbolEngine.Scope.Symbol">
            <summary><value>
            A symbol associated with this scope.
            </value></summary>
        </member>
        <member name="P:SymbolEngine.Scope.Node">
            <summary><value>
            An AST node associated with this scope.
            </value></summary>
        </member>
        <member name="P:SymbolEngine.Scope.LexicalParent">
            <summary><value>
            The lexical parent of this scope.
            </value></summary>
            <remarks>
            Scopes are identified on the source level and they can be lexically nested within
            each other. The chain of lexical parents form a context. 
            <para>Imported types have no lexical parent because they have no source.</para>
            </remarks>
        </member>
        <member name="T:SymbolEngine.ISemanticResolver">
            <summary>
            Interface used by all functions doing symbol resolution. 
            </summary>
            <remarks>
            This interface provides context for symbols, scope lookup functions,
            type-utility functions, and safe exposure to an <see cref="T:Blue.Public.ICLRtypeProvider"/>.
            It is not exposed to the driver.
            <para> The Driver starts symbol resolution via the <see cref="T:Blue.Public.ISemanticChecker"/> interface.
            Resolution is done entirely in:
            <list type="number">
            <item>ResolveXX() methods on the <see cref="T:AST.Node"/> class </item>
            <item> Helper functions on the <see cref="T:SymbolEngine.SymEntry"/> classes. </item> 
            <item> The <see cref="T:SymbolEngine.SemanticChecker"/> class, which implements the ISemanticChecker. </item>
            </list>
            An ISemanticResolver interface exposes an API to allow these code sections 
            (and no other sections) to do symbol resolution.
            </para>    
            </remarks>
        </member>
        <member name="T:SymbolEngine.SemanticChecker">
            <summary>
            This class walks the AST to resolve all symbols.
            </summary>
        </member>
        <member name="T:SymbolEngine.SymEntry">
            <summary>
            The base class for all symbols.
            </summary>
            <remarks>
            </remarks>
        </member>
        <member name="T:SymbolError">
            <summary>
            The <c>SymbolError</c> class contains the error codes for all errors occuring durring
            symbol resolution as well as type-safe static methods to provide the exceptions for
            each type of error.
            </summary>
        </member>
        <member name="T:FileRange">
            <summary>
            A <c>FileRange</c> class is a logically-immutable object to track line number information.
            It has a filename, a starting column and row, and an ending column and row. It only
            represents constructs within a single file.
            </summary>
        </member>
    </members>
</doc>