bluehelp.xml

charp compiler

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>BlueLib</name>
    </assembly>
    <members>
        <member name="T:Identifier">
            <summary>
            <c>Identifier</c> is a helper class to associate a string with a <c>FileRange</c>.
            All AST references to a string-data should refer to an Identifier.
            </summary>
        </member>
        <member name="T:AST.Node">
            <summary>
            <c>Node</c> is the base class for all nodes in the Abstract Syntax tree.
            </summary>
            <remarks>
            <list type="bullet">
            <item>It is associated with a <c>FileRange</c> object to guarantee that all nodes 
            can provide line number information. </item>
            <item>It also provides some standard utility functions to serialize a subtree to
            XML or strings.</item>
            </list>
            Nodes are split into the following major categories: 
            Declarations, Members, Statements, Expressions
            </remarks>
        </member>
        <member name="T:AST.ProgramDecl">
            <summary>
            The root AST node for an entire multi-file program.
            </summary>
            <remarks>
            A ProgramDecl node contains all global namespace decls.
            </remarks>
        </member>
        <member name="T:SymbolEngine.ILookupController">
             <summary>
             IScopeLookup is used by a <see cref="T:SymbolEngine.Scope"/> to do a smart lookup.
             <seealso cref="T:SymbolEngine.Scope"/>
             </summary>
             <remarks>
             While all scopes have the same notion of 'lexical' parent, each type of 
             scope has its own notion of 'super' or 'inherited' parent. For example:
             <list type="bullet">
             <item>BlockStatement, Method - 0 parents </item>
             <item>Class - 1 parent, for the base class</item>
             <item>Interfaces - multiple parents, 1 parent for each base interface</item>
             <item>Namespace - A pseudo-parent from each using clauses.</item>
             </list>
             
             Either Nodes or Symbols may implement IScopeLookup, depending on which
             can best provide the super class.
             Only a Scope should have a reference to these. 
            </remarks>
        </member>
        <member name="T:AST.Exp">
            <summary>
            Abstract base class for all expressions.
            </summary>
            <remarks>
            <para>Provides virtual functions for Resolving as a left or right hand side expressions.
            All expressions have an associated System.Type (the <see cref="P:AST.Exp.CLRType"/> property).</para>
            <para>When an expression is resolved, it can mutate itself into a new expression.The 
            <see cref="M:AST.Exp.ResolveExpAsLeft(AST.Exp@,SymbolEngine.ISemanticResolver)"/> and <see cref="M:AST.Exp.ResolveExpAsRight(AST.Exp@,SymbolEngine.ISemanticResolver)"/> instance members
            return a exp. If the expression was not mutated, they return the 'this' pointer. If a mutation
            does occur, they could return a totally new, resolved, exp node. This is useful for code
            transforms. (ex: constant-folding).</para>
            </remarks>
        </member>
        <member name="T:AST.ArgExp">
            <summary>
            Node for an argument in a method call
            </summary>
            <remarks>
            An ArgExp represents each argument in a <see cref="T:AST.MethodCallExp"/>.
            <para><children>Children:<list type="bullet">
            <item><see cref="T:AST.EArgFlow"/> - specify if this is an 'in', 'out', or 'ref' parameter.</item>
            <item><see cref="T:AST.Exp"/> - specify the expression for this parameter</item>
            </list></children></para>
            </remarks>
        </member>
        <member name="T:AST.StatementExp">
            <summary>
            Abstract base class for expression that have sideeffects and can be used as statements.
            </summary>
            <remarks>
            <para>Some expressions, like assignment, methodcalls, and the ++,-- operators
            have sideeffects and so they can be used as a statement.</para>
            <para>A StatementExp can be used directly as an expression, or it can be held in a 
            <see cref="T:AST.ExpStatement"/> to be used as a statement.</para>
            </remarks>
        </member>
        <member name="T:AST.LiteralExp">
            <summary>
            Abstract base class for all literals (ints, strings, chars, null, etc)
            </summary>
        </member>
        <member name="T:AST.NullExp">
            <summary>
            Node representing the 'null' keyword literal.
            </summary>
        </member>
        <member name="T:AST.IntExp">
            <summary>
            Node representing an System.Int32
            </summary>
        </member>
        <member name="T:AST.Statement">
            <summary>
            Abstract base class for all statements.
            </summary>
        </member>
        <member name="T:AST.ExpStatement">
            <summary>
            Statement to hold an <see cref="T:AST.StatementExp"/>.
            </summary>
            <remarks>
            <para><children>Children<list type="bullet"><item>
            <see cref="T:AST.StatementExp"/> - the expression to be evaluated as a statement
            </item></list></children></para>
            </remarks>
        </member>
        <member name="T:AST.TypeSig">
            <summary>
            Abstract base class for ast nodes representing types.
            </summary>
            <remarks>
            <para>The following nodes derive from TypeSig:<list type="bullet">
            <item><see cref="T:AST.ResolvedTypeSig"/>- a node not associated with source that directly wraps a symbol. </item>
            <item><see cref="T:AST.SimpleTypeSig"/> - a node representing a non-decorated type from source.</item>
            <item><see cref="T:AST.ArrayTypeSig"/> - a node representing an array type</item>
            <item><see cref="T:AST.RefTypeSig"/> - a node representing a reference to a type.</item>
            </list></para>
            <para>A TypeSig represents the usage of a type in the AST. A <see cref="T:AST.ClassDecl"/> represents
            the definition of a type in the AST. A <see cref="T:SymbolEngine.TypeEntry"/> is the symbol
            representing the type.</para>
            </remarks>
        </member>
        <member name="T:Blue.Public.ICLRtypeProvider">
            <summary>
            The ICLRTypeProvider interface provides metadata objects to the symbol engine.
            </summary>
            <remarks>
            The ICLRTypeProvider interface is obtained from the emitter (in <see cref="T:Blue.Public.ICodeGenDriver"/>)
            and used by the <see cref="T:Blue.Public.ISemanticChecker"/>
            </remarks>
        </member>
        <member name="T:Blue.Public.ICodeGenDriver">
            <summary>
            This is the interface the driver uses to control CodeGeneration
            </summary>
        </member>
        <member name="M:Blue.Public.ICodeGenDriver.BeginOutput(System.String[])">
            <summary>
            Begin codegen. Creates the assembly. 
            </summary>        
            <param name="stFilenames">All files that are being compiled. This is used to determine
            a default name as well as associate files when building the .pdb. </param>        
        </member>
        <member name="M:Blue.Public.ICodeGenDriver.GetProvider(System.Reflection.Assembly[])">
            <summary>
            Given an array of the assemblies that we reference (not including mscorlib)
            return a CLRTypeProvider for symbol resolution to use.
            </summary>        
        </member>
        <member name="M:Blue.Public.ICodeGenDriver.DoCodeGen(AST.ProgramDecl)">
            <summary>
            Given the root of the program, walk the AST and emit the IL. 
            </summary>
            <param name="root">The root of an AST for the entire program</param>        
        </member>
        <member name="M:Blue.Public.ICodeGenDriver.EndOutput">
            <summary>
            The driver calls this when it is done with Codegen. 
            Save the assembly
            </summary>
        </member>
        <member name="T:ErrorException">
            <summary>
            <c>ErrorException</c> is the base class for all errors resulting from bad user-input
            (as opposed to errors resulting from bugs in blue). 
            </summary>
            <remarks>
            Each subsystem derives its own type safe exception with its own set of error codes.
            Use the <see cref="T:Blue.Public.IError"/> interface to print the errors.
            <list type="bullet">
            <item>
            <see cref="T:ManualParser.LexerException"/> - Lexical errors. Usually resulting from 
            missing End-of-file, unterminated constants, bad preprocessor structure.
            </item>
            <item>
            <see cref="T:ManualParser.Parser.ParserErrorException"/> - Syntax errors. 
            </item>
            <item>
            <see cref="T:SymbolError.SymbolErrorException"/> - Symantic errors. These are related to syntax
            errors in, but in general, any error that can reasonably be determined by the parser is
            a syntax error. 
            </item>
            </list>
            </remarks>
        </member>
        <member name="T:Help">
            <summary>
            Blue is a C# compiler written in C#.
            </summary>
            <remarks>