JLang_c

java.lang.Object
- polyglot.ast.JLang_c

All Implemented Interfaces:

JLang, Lang

Direct Known Subclasses:

J5Lang_c, JLangToJLDel
```
public class JLang_c
extends java.lang.Object
implements JLang
```
JLang_c defines the dispatching mechanism to methods which implement Java compiler operations. Language extensions may override methods that determine the appropriate object which implements AST operations (such as NodeOps) to redirect dispatching to appropriate extension code.

Field Summary

Fields
Modifier and Type Field and Description

static JLang instance

Fields
Modifier and Type	Field and Description
`static JLang`	`instance`

Constructor Summary

Constructors
Modifier Constructor and Description

protected JLang_c()

Constructors
Modifier	Constructor and Description
`protected`	`JLang_c()`

Method Summary

Methods
Modifier and Type	Method and Description
`<T> java.util.List<T>`	`acceptCFG(Term n, CFGBuilder<?> v, java.util.List<T> succs)` Visit this term in evaluation order, calling v.edge() for each successor in succs, if data flows on that edge.
`void`	`addDecls(Node n, Context c)` Add any declarations to the context that should be in scope when visiting later sibling nodes.
`Node`	`addDefaultConstructor(ClassDecl n, TypeSystem ts, NodeFactory nf, ConstructorInstance defaultConstructorInstance)`
`Node`	`buildTypes(Node n, TypeBuilder tb)` Collects classes, methods, and fields from the AST rooted at this node and constructs type objects for these.
`NodeVisitor`	`buildTypesEnter(Node n, TypeBuilder tb)` Collects classes, methods, and fields from the AST rooted at this node and constructs type objects for these.
`protected CallOps`	`CallOps(Call n)`
`Node`	`checkConstants(Node n, ConstantChecker cc)` Check if the node is a compile-time constant.
`Type`	`childExpectedType(Node n, Expr child, AscriptionVisitor av)` Get the expected type of a child expression of `this`.
`protected ClassDeclOps`	`ClassDeclOps(ClassDecl n)`
`boolean`	`condIsConstant(Loop n, JLang lang)` Returns true of cond() evaluates to a constant.
`boolean`	`condIsConstantFalse(Loop n, JLang lang)` Returns true if cond() is a constant that evaluates to false.
`boolean`	`condIsConstantTrue(Loop n, JLang lang)` Returns true if cond() is a constant that evaluates to true.
`java.lang.Object`	`constantValue(Expr n, Lang lang)` Return the constant value of the expression, if any.
`boolean`	`constantValueSet(Expr n, Lang lang)` Return true iff the compiler has determined whether this expression has a constant value.
`ExceptionChecker`	`constructTryBlockExceptionChecker(Try n, ExceptionChecker ec)` Construct an ExceptionChecker that is suitable for checking the try block of a try-catch-finally AST node.
`Term`	`continueTarget(Loop n)` Target of a continue statement in the loop body.
`Node`	`copy(Node n, ExtensionInfo extInfo)` Produce a copy of this node using the given ExtensionInfo.
`Node`	`copy(Node n, NodeFactory nf)` Produce a copy of this node using the given NodeFactory.
`Node`	`disambiguate(Node n, AmbiguityRemover ar)` Remove any remaining ambiguities from the AST.
`NodeVisitor`	`disambiguateEnter(Node n, AmbiguityRemover ar)` Remove any remaining ambiguities from the AST.
`Node`	`disambiguateOverride(Node n, Node parent, AmbiguityRemover ar)` Disambiguate the AST.
`void`	`dump(Node n, Lang lang, java.io.OutputStream os)` Dump the AST for debugging.
`void`	`dump(Node n, Lang lang, java.io.Writer w)` Dump the AST for debugging.
`Context`	`enterChildScope(Node n, Node child, Context c)` Push a new scope for visiting the child node `child`.
`Context`	`enterScope(Node n, Context c)` Push a new scope upon entering this node, and add any declarations to the context that should be in scope when visiting children of this node.
`Node`	`exceptionCheck(Node n, ExceptionChecker ec)` Check that exceptions are properly propagated throughout the AST.
`java.util.List<Catch>`	`exceptionCheckCatchBlocks(Try n, ExceptionChecker ec)` Perform exception checking of the catch blocks of a try-catch-finally AST node, using the supplied exception checker.
`NodeVisitor`	`exceptionCheckEnter(Node n, ExceptionChecker ec)` Check that exceptions are properly propagated throughout the AST.
`Block`	`exceptionCheckFinallyBlock(Try n, ExceptionChecker ec)` Perform exception checking of the finally block of a try-catch-finally AST node (if there is one), using the supplied exception checker.
`Block`	`exceptionCheckTryBlock(Try n, ExceptionChecker ec)` Perform exception checking of the try block of a try-catch-finally AST node, using the supplied exception checker.
`protected ExprOps`	`ExprOps(Expr n)`
`Node`	`extRewrite(Node n, ExtensionRewriter rw)` Rewrite the AST for the compilation in this language.
`NodeVisitor`	`extRewriteEnter(Node n, ExtensionRewriter rw)` Rewrite the AST for the compilation in this language.
`Type`	`findContainer(Call n, TypeSystem ts, MethodInstance mi)` Used to find the missing static target of a static method call.
`ClassType`	`findEnclosingClass(New n, Context c, ClassType ct)`
`TypeNode`	`findQualifiedTypeNode(New n, AmbiguityRemover ar, ClassType outer, TypeNode objectType)`
`Expr`	`findQualifier(New n, AmbiguityRemover ar, ClassType ct)`
`ReferenceType`	`findTargetType(Call n)`
`Term`	`firstChild(Term n)` Return the first direct subterm performed when evaluating this term.
`boolean`	`isConstant(Expr n, Lang lang)` Return whether the expression evaluates to a constant.
`protected LoopOps`	`LoopOps(Loop n)`
`protected NewOps`	`NewOps(New n)`
`protected NodeOps`	`NodeOps(Node n)`
`void`	`prettyPrint(Node n, CodeWriter w, PrettyPrinter pp)` Pretty-print the AST using the given code writer.
`void`	`prettyPrint(Node n, Lang lang, java.io.OutputStream os)` Pretty-print the AST for debugging.
`void`	`prettyPrint(Node n, Lang lang, java.io.Writer w)` Pretty-print the AST for debugging.
`void`	`prettyPrintFooter(ClassDecl n, CodeWriter w, PrettyPrinter tr)`
`void`	`prettyPrintHeader(ClassDecl n, CodeWriter w, PrettyPrinter tr)`
`void`	`prettyPrintHeader(ProcedureDecl n, Flags flags, CodeWriter w, PrettyPrinter tr)`
`void`	`printArgs(ProcedureCall n, CodeWriter w, PrettyPrinter tr)`
`void`	`printBody(New n, CodeWriter w, PrettyPrinter tr)`
`void`	`printQualifier(New n, CodeWriter w, PrettyPrinter tr)`
`void`	`printShortObjectType(New n, CodeWriter w, PrettyPrinter tr)`
`protected ProcedureCallOps`	`ProcedureCallOps(ProcedureCall n)`
`protected ProcedureDeclOps`	`ProcedureDeclOps(ProcedureDecl n)`
`protected TermOps`	`TermOps(Term n)`
`java.util.List<Type>`	`throwTypes(Node n, TypeSystem ts)` List of Types of exceptions that might get thrown.
`void`	`translate(Node n, CodeWriter w, Translator tr)` Translate the AST using the given code writer.
`protected TryOps`	`TryOps(Try n)`
`Node`	`typeCheck(Node n, TypeChecker tc)` Type check the AST.
`NodeVisitor`	`typeCheckEnter(Node n, TypeChecker tc)` Type check the AST.
`void`	`typeCheckFlags(New n, TypeChecker tc)`
`void`	`typeCheckNested(New n, TypeChecker tc)`
`Node`	`typeCheckNullTarget(Call n, TypeChecker tc, java.util.List<Type> argTypes)` Typecheck the Call when the target is null.
`Node`	`typeCheckOverride(Node n, Node parent, TypeChecker tc)` Type check the AST.
`Node`	`visitChildren(Node n, NodeVisitor v)` Visit the children of the node.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - instance
```
public static final JLang instance
```
- Constructor Detail
  - JLang_c
```
protected JLang_c()
```
- Method Detail
  - NodeOps
```
protected NodeOps NodeOps(Node n)
```
  - CallOps
```
protected CallOps CallOps(Call n)
```
  - ClassDeclOps
```
protected ClassDeclOps ClassDeclOps(ClassDecl n)
```
  - ExprOps
```
protected ExprOps ExprOps(Expr n)
```
  - LoopOps
```
protected LoopOps LoopOps(Loop n)
```
  - NewOps
```
protected NewOps NewOps(New n)
```
  - ProcedureCallOps
```
protected ProcedureCallOps ProcedureCallOps(ProcedureCall n)
```
  - ProcedureDeclOps
```
protected ProcedureDeclOps ProcedureDeclOps(ProcedureDecl n)
```
  - TermOps
```
protected TermOps TermOps(Term n)
```
  - TryOps
```
protected TryOps TryOps(Try n)
```
  - visitChildren
```
public final Node visitChildren(Node n,
                 NodeVisitor v)
```
    Description copied from interface: Lang
    
    Visit the children of the node.
    
    Specified by:
    
    visitChildren in interface Lang
    
    v - The visitor that will traverse/rewrite the AST.
    
    Returns:
    A new AST if a change was made, or this.
  - enterScope
```
public final Context enterScope(Node n,
                 Context c)
```
    Description copied from interface: Lang
    
    Push a new scope upon entering this node, and add any declarations to the context that should be in scope when visiting children of this node. This should not update the old context imperatively. Use addDecls when leaving the node for that.
    
    Specified by:
    
    enterScope in interface Lang
    
    c - the current Context
    
    Returns:
    the Context to be used for visiting this node.
  - enterChildScope
```
public final Context enterChildScope(Node n,
                      Node child,
                      Context c)
```
    Description copied from interface: Lang
    
    Push a new scope for visiting the child node child. The default behavior is to delegate the call to the child node, and let it add appropriate declarations that should be in scope. However, this method gives parent nodes have the ability to modify this behavior.
    
    Specified by:
    
    enterChildScope in interface Lang
    
    child - The child node about to be entered.
    c - The current Context
    
    Returns:
    the Context to be used for visiting node child
  - addDecls
```
public final void addDecls(Node n,
            Context c)
```
    Description copied from interface: Lang
    
    Add any declarations to the context that should be in scope when visiting later sibling nodes.
    
    Specified by:
    
    addDecls in interface Lang
    
    c - The context to which to add declarations.
  - buildTypesEnter
```
public final NodeVisitor buildTypesEnter(Node n,
                          TypeBuilder tb)
                                  throws SemanticException
```
    Description copied from interface: Lang
    
    Collects classes, methods, and fields from the AST rooted at this node and constructs type objects for these. These type objects may be ambiguous. Inserts classes into the TypeSystem. This method is called by the enter() method of the visitor. The * method should perform work that should be done before visiting the children of the node. The method may return this or a new copy of the node on which visitChildren() and leave() will be invoked.
    
    Specified by:
    
    buildTypesEnter in interface Lang
    
    tb - The visitor which adds new type objects to the TypeSystem.
    
    Throws:
    
    SemanticException
  - buildTypes
```
public final Node buildTypes(Node n,
              TypeBuilder tb)
                      throws SemanticException
```
    Description copied from interface: Lang
    
    Collects classes, methods, and fields from the AST rooted at this node and constructs type objects for these. These type objects may be ambiguous. Inserts classes into the TypeSystem. This method is called by the leave() method of the visitor. The method should perform work that should be done after visiting the children of the node. The method may return this or a new copy of the node which will be installed as a child of the node's parent.
    
    Specified by:
    
    buildTypes in interface Lang
    
    tb - The visitor which adds new type objects to the TypeSystem.
    
    Throws:
    
    SemanticException
  - disambiguateOverride
```
public final Node disambiguateOverride(Node n,
                        Node parent,
                        AmbiguityRemover ar)
                                throws SemanticException
```
    Description copied from interface: JLang
    
    Disambiguate the AST. This method is called by the override() method of the visitor. If this method returns non-null, the node's children will not be visited automatically. Thus, the method should check both the node this and it's children, usually by invoking visitChildren with tc or with another visitor, returning a non-null node. OR, the method should do nothing and simply return null to allow enter, visitChildren, and leave to be invoked on the node. The default implementation returns null. Overriding of this method is discouraged, but sometimes necessary.
    
    Specified by:
    
    disambiguateOverride in interface JLang
    
    ar - The visitor which disambiguates.
    
    Throws:
    
    SemanticException
  - disambiguateEnter
```
public final NodeVisitor disambiguateEnter(Node n,
                            AmbiguityRemover ar)
                                    throws SemanticException
```
    Description copied from interface: JLang
    
    Remove any remaining ambiguities from the AST. This method is called by the enter() method of the visitor. The * method should perform work that should be done before visiting the children of the node. The method may return this or a new copy of the node on which visitChildren() and leave() will be invoked.
    
    Specified by:
    
    disambiguateEnter in interface JLang
    
    ar - The visitor which disambiguates.
    
    Throws:
    
    SemanticException
  - disambiguate
```
public final Node disambiguate(Node n,
                AmbiguityRemover ar)
                        throws SemanticException
```
    Description copied from interface: JLang
    
    Remove any remaining ambiguities from the AST. This method is called by the leave() method of the visitor. The method should perform work that should be done after visiting the children of the node. The method may return this or a new copy of the node which will be installed as a child of the node's parent. The node should not assume that its children have been disambiguated. If it depends on a child being disambiguated, it may just return this without doing any work.
    
    Specified by:
    
    disambiguate in interface JLang
    
    ar - The visitor which disambiguates.
    
    Throws:
    
    SemanticException
  - typeCheckEnter
```
public final NodeVisitor typeCheckEnter(Node n,
                         TypeChecker tc)
                                 throws SemanticException
```
    Description copied from interface: Lang
    
    Type check the AST. This method is called by the enter() method of the visitor. The * method should perform work that should be done before visiting the children of the node. The method may return this or a new copy of the node on which visitChildren() and leave() will be invoked.
    
    Specified by:
    
    typeCheckEnter in interface Lang
    
    tc - The type checking visitor.
    
    Throws:
    
    SemanticException
  - typeCheckOverride
```
public final Node typeCheckOverride(Node n,
                     Node parent,
                     TypeChecker tc)
                             throws SemanticException
```
    Description copied from interface: Lang
    
    Type check the AST. This method is called by the override() method of the visitor. If this method returns non-null, the node's children will not be visited automatically. Thus, the method should check both the node this and it's children, usually by invoking visitChildren with tc or with another visitor, returning a non-null node. OR, the method should do nothing and simply return null to allow enter, visitChildren, and leave to be invoked on the node. The default implementation returns null. Overriding of this method is discouraged, but sometimes necessary.
    
    Specified by:
    
    typeCheckOverride in interface Lang
    
    tc - The type checking visitor.
    
    Throws:
    
    SemanticException
  - typeCheck
```
public final Node typeCheck(Node n,
             TypeChecker tc)
                     throws SemanticException
```
    Description copied from interface: Lang
    
    Type check the AST. This method is called by the leave() method of the visitor. The method should perform work that should be done after visiting the children of the node. The method may return this or a new copy of the node which will be installed as a child of the node's parent.
    
    Specified by:
    
    typeCheck in interface Lang
    
    tc - The type checking visitor.
    
    Throws:
    
    SemanticException
  - childExpectedType
```
public final Type childExpectedType(Node n,
                     Expr child,
                     AscriptionVisitor av)
```
    Description copied from interface: JLang
    
    Get the expected type of a child expression of this. The expected type is determined by the context in that the child occurs (e.g., for x = e, the expected type of e is the declared type of x. The expected type should impose the least constraints on the child's type that are allowed by the parent node.
    
    Specified by:
    
    childExpectedType in interface JLang
    
    child - A child expression of this node.
    av - An ascription visitor.
    
    Returns:
    The expected type of child.
  - checkConstants
```
public final Node checkConstants(Node n,
                  ConstantChecker cc)
                          throws SemanticException
```
    Description copied from interface: JLang
    
    Check if the node is a compile-time constant. This method is called by the leave() method of the visitor. The method should perform work that should be done after visiting the children of the node. The method may return this or a new copy of the node which will be installed as a child of the node's parent.
    
    Specified by:
    
    checkConstants in interface JLang
    
    cc - The constant checking visitor.
    
    Throws:
    
    SemanticException
  - exceptionCheckEnter
```
public final NodeVisitor exceptionCheckEnter(Node n,
                              ExceptionChecker ec)
                                      throws SemanticException
```
    Description copied from interface: JLang
    
    Check that exceptions are properly propagated throughout the AST. This method is called by the enter() method of the visitor. The * method should perform work that should be done before visiting the children of the node. The method may return this or a new copy of the node on which visitChildren() and leave() will be invoked.
    
    Specified by:
    
    exceptionCheckEnter in interface JLang
    
    ec - The visitor.
    
    Throws:
    
    SemanticException
  - exceptionCheck
```
public final Node exceptionCheck(Node n,
                  ExceptionChecker ec)
                          throws SemanticException
```
    Description copied from interface: JLang
    
    Check that exceptions are properly propagated throughout the AST. This method is called by the leave() method of the visitor. The method should perform work that should be done after visiting the children of the node. The method may return this or a new copy of the node which will be installed as a child of the node's parent.
    
    Specified by:
    
    exceptionCheck in interface JLang
    
    ec - The visitor.
    
    Throws:
    
    SemanticException
  - throwTypes
```
public final java.util.List<Type> throwTypes(Node n,
                              TypeSystem ts)
```
    Description copied from interface: JLang
    
    List of Types of exceptions that might get thrown. The result is not necessarily correct until after type checking.
    
    Specified by:
    
    throwTypes in interface JLang
  - extRewriteEnter
```
public final NodeVisitor extRewriteEnter(Node n,
                          ExtensionRewriter rw)
                                  throws SemanticException
```
    Description copied from interface: Lang
    
    Rewrite the AST for the compilation in this language. This method is called by the enter() method of the visitor. The method should perform work that should be done before visiting the children of the node. The method may return this or a new copy of the node on which visitChildren() and leave() will be invoked.
    
    Specified by:
    
    extRewriteEnter in interface Lang
    
    rw - The visitor.
    
    Throws:
    
    SemanticException
  - extRewrite
```
public final Node extRewrite(Node n,
              ExtensionRewriter rw)
                      throws SemanticException
```
    Description copied from interface: Lang
    
    Rewrite the AST for the compilation in this language. This method is called by the leave() method of the visitor. The method should perform work that should be done after visiting the children of the node. The method may return this or a new copy of the node which will be installed as a child of the node's parent.
    
    Specified by:
    
    extRewrite in interface Lang
    
    rw - The visitor.
    
    Throws:
    
    SemanticException
  - dump
```
public final void dump(Node n,
        Lang lang,
        java.io.OutputStream os)
```
    Description copied from interface: Lang
    
    Dump the AST for debugging.
    
    Specified by:
    
    dump in interface Lang
  - dump
```
public final void dump(Node n,
        Lang lang,
        java.io.Writer w)
```
    Description copied from interface: Lang
    
    Dump the AST for debugging.
    
    Specified by:
    
    dump in interface Lang
  - prettyPrint
```
public final void prettyPrint(Node n,
               Lang lang,
               java.io.OutputStream os)
```
    Description copied from interface: Lang
    
    Pretty-print the AST for debugging.
    
    Specified by:
    
    prettyPrint in interface Lang
  - prettyPrint
```
public final void prettyPrint(Node n,
               Lang lang,
               java.io.Writer w)
```
    Description copied from interface: Lang
    
    Pretty-print the AST for debugging.
    
    Specified by:
    
    prettyPrint in interface Lang
  - prettyPrint
```
public final void prettyPrint(Node n,
               CodeWriter w,
               PrettyPrinter pp)
```
    Description copied from interface: Lang
    
    Pretty-print the AST using the given code writer.
    
    Specified by:
    
    prettyPrint in interface Lang
    
    w - The code writer to which to write.
    pp - The pretty printer. This is not a visitor.
  - translate
```
public final void translate(Node n,
             CodeWriter w,
             Translator tr)
```
    Description copied from interface: Lang
    
    Translate the AST using the given code writer.
    
    Specified by:
    
    translate in interface Lang
    
    w - The code writer to which to write.
    tr - The translation pass. This is not a visitor.
  - copy
```
public final Node copy(Node n,
        NodeFactory nf)
```
    Description copied from interface: Lang
    
    Produce a copy of this node using the given NodeFactory.
    
    Specified by:
    
    copy in interface Lang
  - copy
```
public final Node copy(Node n,
        ExtensionInfo extInfo)
                throws SemanticException
```
    Description copied from interface: Lang
    
    Produce a copy of this node using the given ExtensionInfo. This will typically be implemented by calling copy(NodeFactory nf), and then potentially copying over type information.
    
    Specified by:
    
    copy in interface Lang
    
    Throws:
    
    SemanticException - If the type information cannot be copied.
  - findContainer
```
public final Type findContainer(Call n,
                 TypeSystem ts,
                 MethodInstance mi)
```
    Description copied from interface: JLang
    
    Used to find the missing static target of a static method call. Should return the container of the method instance.
    
    Specified by:
    
    findContainer in interface JLang
  - findTargetType
```
public final ReferenceType findTargetType(Call n)
                                   throws SemanticException
```
    Specified by:
    
    findTargetType in interface JLang
    
    Throws:
    
    SemanticException
  - typeCheckNullTarget
```
public final Node typeCheckNullTarget(Call n,
                       TypeChecker tc,
                       java.util.List<Type> argTypes)
                               throws SemanticException
```
    Description copied from interface: JLang
    
    Typecheck the Call when the target is null. This method finds an appropriate target, and then type checks accordingly.
    
    Specified by:
    
    typeCheckNullTarget in interface JLang
    
    argTypes - list of Types of the arguments
    
    Throws:
    
    SemanticException
  - prettyPrintHeader
```
public final void prettyPrintHeader(ClassDecl n,
                     CodeWriter w,
                     PrettyPrinter tr)
```
    Specified by:
    
    prettyPrintHeader in interface JLang
  - prettyPrintFooter
```
public final void prettyPrintFooter(ClassDecl n,
                     CodeWriter w,
                     PrettyPrinter tr)
```
    Specified by:
    
    prettyPrintFooter in interface JLang
  - addDefaultConstructor
```
public final Node addDefaultConstructor(ClassDecl n,
                         TypeSystem ts,
                         NodeFactory nf,
                         ConstructorInstance defaultConstructorInstance)
                                 throws SemanticException
```
    Specified by:
    
    addDefaultConstructor in interface JLang
    
    Throws:
    
    SemanticException
  - constantValueSet
```
public final boolean constantValueSet(Expr n,
                       Lang lang)
```
    Description copied from interface: Lang
    
    Return true iff the compiler has determined whether this expression has a constant value. The value returned by isConstant() is valid only if constantValueSet() is true.
    
    Specified by:
    
    constantValueSet in interface Lang
  - isConstant
```
public final boolean isConstant(Expr n,
                 Lang lang)
```
    Description copied from interface: Lang
    
    Return whether the expression evaluates to a constant. Requires that disambiguation has been done, and that constantValueSet() is true.
    
    Specified by:
    
    isConstant in interface Lang
  - constantValue
```
public final java.lang.Object constantValue(Expr n,
                             Lang lang)
```
    Description copied from interface: Lang
    
    Return the constant value of the expression, if any. Requires that isConstant() is true.
    
    Specified by:
    
    constantValue in interface Lang
  - condIsConstant
```
public final boolean condIsConstant(Loop n,
                     JLang lang)
```
    Description copied from interface: JLang
    
    Returns true of cond() evaluates to a constant.
    
    Specified by:
    
    condIsConstant in interface JLang
  - condIsConstantTrue
```
public final boolean condIsConstantTrue(Loop n,
                         JLang lang)
```
    Description copied from interface: JLang
    
    Returns true if cond() is a constant that evaluates to true.
    
    Specified by:
    
    condIsConstantTrue in interface JLang
  - condIsConstantFalse
```
public final boolean condIsConstantFalse(Loop n,
                          JLang lang)
```
    Description copied from interface: JLang
    
    Returns true if cond() is a constant that evaluates to false.
    
    Specified by:
    
    condIsConstantFalse in interface JLang
  - continueTarget
```
public final Term continueTarget(Loop n)
```
    Description copied from interface: JLang
    
    Target of a continue statement in the loop body.
    
    Specified by:
    
    continueTarget in interface JLang
  - findQualifiedTypeNode
```
public final TypeNode findQualifiedTypeNode(New n,
                             AmbiguityRemover ar,
                             ClassType outer,
                             TypeNode objectType)
                                     throws SemanticException
```
    Specified by:
    
    findQualifiedTypeNode in interface JLang
    
    Throws:
    
    SemanticException
  - findQualifier
```
public final Expr findQualifier(New n,
                 AmbiguityRemover ar,
                 ClassType ct)
                         throws SemanticException
```
    Specified by:
    
    findQualifier in interface JLang
    
    Throws:
    
    SemanticException
  - typeCheckFlags
```
public final void typeCheckFlags(New n,
                  TypeChecker tc)
                          throws SemanticException
```
    Specified by:
    
    typeCheckFlags in interface JLang
    
    Throws:
    
    SemanticException
  - typeCheckNested
```
public final void typeCheckNested(New n,
                   TypeChecker tc)
                           throws SemanticException
```
    Specified by:
    
    typeCheckNested in interface JLang
    
    Throws:
    
    SemanticException
  - printQualifier
```
public final void printQualifier(New n,
                  CodeWriter w,
                  PrettyPrinter tr)
```
    Specified by:
    
    printQualifier in interface JLang
  - printShortObjectType
```
public final void printShortObjectType(New n,
                        CodeWriter w,
                        PrettyPrinter tr)
```
    Specified by:
    
    printShortObjectType in interface JLang
  - printBody
```
public final void printBody(New n,
             CodeWriter w,
             PrettyPrinter tr)
```
    Specified by:
    
    printBody in interface JLang
  - findEnclosingClass
```
public final ClassType findEnclosingClass(New n,
                           Context c,
                           ClassType ct)
```
    Specified by:
    
    findEnclosingClass in interface JLang
  - printArgs
```
public final void printArgs(ProcedureCall n,
             CodeWriter w,
             PrettyPrinter tr)
```
    Specified by:
    
    printArgs in interface JLang
  - prettyPrintHeader
```
public final void prettyPrintHeader(ProcedureDecl n,
                     Flags flags,
                     CodeWriter w,
                     PrettyPrinter tr)
```
    Specified by:
    
    prettyPrintHeader in interface JLang
  - firstChild
```
public final Term firstChild(Term n)
```
    Description copied from interface: JLang
    
    Return the first direct subterm performed when evaluating this term. If this term has no subterms, this should return null. This method is similar to the deprecated entry(), but it should *not* recursively drill down to the innermost subterm. The direct child visited first in this term's dataflow should be returned.
    
    Specified by:
    
    firstChild in interface JLang
  - acceptCFG
```
public final <T> java.util.List<T> acceptCFG(Term n,
                              CFGBuilder<?> v,
                              java.util.List<T> succs)
```
    Description copied from interface: JLang
    
    Visit this term in evaluation order, calling v.edge() for each successor in succs, if data flows on that edge.
    
    Specified by:
    
    acceptCFG in interface JLang
  - constructTryBlockExceptionChecker
```
public final ExceptionChecker constructTryBlockExceptionChecker(Try n,
                                                 ExceptionChecker ec)
```
    Description copied from interface: JLang
    
    Construct an ExceptionChecker that is suitable for checking the try block of a try-catch-finally AST node.
    
    Specified by:
    
    constructTryBlockExceptionChecker in interface JLang
    
    ec - The exception checker immediately prior to the try block.
    
    Returns:
  - exceptionCheckTryBlock
```
public final Block exceptionCheckTryBlock(Try n,
                           ExceptionChecker ec)
                                   throws SemanticException
```
    Description copied from interface: JLang
    
    Perform exception checking of the try block of a try-catch-finally AST node, using the supplied exception checker.
    
    Specified by:
    
    exceptionCheckTryBlock in interface JLang
    
    Returns:
    
    Throws:
    
    SemanticException
  - exceptionCheckCatchBlocks
```
public final java.util.List<Catch> exceptionCheckCatchBlocks(Try n,
                                              ExceptionChecker ec)
                                                      throws SemanticException
```
    Description copied from interface: JLang
    
    Perform exception checking of the catch blocks of a try-catch-finally AST node, using the supplied exception checker.
    
    Specified by:
    
    exceptionCheckCatchBlocks in interface JLang
    
    Returns:
    
    Throws:
    
    SemanticException
  - exceptionCheckFinallyBlock
```
public final Block exceptionCheckFinallyBlock(Try n,
                               ExceptionChecker ec)
                                       throws SemanticException
```
    Description copied from interface: JLang
    
    Perform exception checking of the finally block of a try-catch-finally AST node (if there is one), using the supplied exception checker.
    
    Specified by:
    
    exceptionCheckFinallyBlock in interface JLang
    
    Returns:
    
    Throws:
    
    SemanticException

Class JLang_c

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

instance

Constructor Detail

JLang_c

Method Detail

NodeOps

CallOps

ClassDeclOps

ExprOps

LoopOps

NewOps

ProcedureCallOps

ProcedureDeclOps

TermOps

TryOps

visitChildren

enterScope

enterChildScope

addDecls

buildTypesEnter

buildTypes

disambiguateOverride

disambiguateEnter

disambiguate

typeCheckEnter

typeCheckOverride

typeCheck

childExpectedType

checkConstants

exceptionCheckEnter

exceptionCheck

throwTypes

extRewriteEnter

extRewrite

dump

dump

prettyPrint

prettyPrint

prettyPrint

translate

copy

copy

findContainer

findTargetType

typeCheckNullTarget

prettyPrintHeader

prettyPrintFooter

addDefaultConstructor

constantValueSet

isConstant

constantValue

condIsConstant

condIsConstantTrue

condIsConstantFalse

continueTarget

findQualifiedTypeNode

findQualifier

typeCheckFlags

typeCheckNested

printQualifier

printShortObjectType

printBody

findEnclosingClass

printArgs

prettyPrintHeader

firstChild

acceptCFG

constructTryBlockExceptionChecker

exceptionCheckTryBlock

exceptionCheckCatchBlocks

exceptionCheckFinallyBlock