* Managed.Windows.Forms/System.Windows.Forms/HtmlDocument.cs,
[mono.git] / mcs / docs / compiler.txt
index c67e0c4355931f7ba866c658dbb88bedd1b5b035..275ff0d9566b0dc5f24843b643d27103f40ec7af 100755 (executable)
        All errors must be reported during the resolution phase
        (DoResolve) and if an error is detected the DoResolve method
        will return null which is used to flag that an error condition
-       has ocurred, this will be used to stop compilation later on.
+       has occurred, this will be used to stop compilation later on.
        This means that anyone that calls Expression.Resolve must
        check the return value for null which would indicate an error
        condition.
 
        We take advantage of the distinction between the expressions that
        are generated by the parser and the expressions that are the
-       result of the semantic analysis phase for lambda expresions (more
+       result of the semantic analysis phase for lambda expressions (more
        information in the "Lambda Expressions" section).
 
        But what is important is that expressions and statements that are
        blocks to avoid using the name.  We thus need to maintain a
        blacklist of taboo names in all surrounding blocks -- and we
        take the expedient of doing so simply: actually maintaining a
-       (superset of the) blacklist in each block datastructure, which
+       (superset of the) blacklist in each block data structure, which
        we call the 'known_variable' list.
 
        Because we create the 'known_variable' list during the parse
        rest of the IMiaB property by looking up a couple of lists.
 
        This turns out to be quite efficient: when we used a block
-       tree walk, a testcase took 5-10mins, while with this simple
+       tree walk, a test case took 5-10mins, while with this simple
        mildly-redundant data structure, the time taken for the same
-       testcase came down to a couple of seconds.
+       test case came down to a couple of seconds.
 
        The IKnownVariable interface is a small wrinkle.  Firstly, the
        IMiaB also applies to parameter names, especially those of
        more than one matching method).
 
        To compile this, we need to hook into the resolution process,
-       but since the resolution process has side effects (callig
+       but since the resolution process has side effects (calling
        Resolve can either return instances of the resolved expression
        type, or can alter field internals) it was necessary to
        incorporate a framework to "clone" expressions before we
        probe.
 
-       The support for clonning was added into Statements and
+       The support for cloning was added into Statements and
        Expressions and is only necessary for objects of those types
        that are created during parsing.   It is not necessary to
        support these in the classes that are the result of calling
        implicitly converted to the given delegate type.
 
        And also happens as a result of the generic method parameter
-       type inferrencing. 
+       type inferencing. 
 
 ** Lambda Expressions and Cloning