001    /* This file was generated with JastAdd2 (http://jastadd.org) version 2.1.13-12-g880e696 */
002    package org.extendj.ast;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.Set;
007    import java.util.Collections;
008    import java.util.Collection;
009    import java.util.ArrayList;
010    import beaver.*;
011    import java.util.*;
012    import java.io.ByteArrayOutputStream;
013    import java.io.PrintStream;
014    import java.lang.reflect.InvocationTargetException;
015    import java.lang.reflect.Method;
016    import org.jastadd.util.*;
017    import java.util.zip.*;
018    import java.io.*;
019    import org.jastadd.util.PrettyPrintable;
020    import org.jastadd.util.PrettyPrinter;
021    import java.io.FileNotFoundException;
022    import java.io.BufferedInputStream;
023    import java.io.DataInputStream;
024    /**
025     * @ast node
026     * @declaredat /home/jesper/git/extendj/java4/grammar/Java.ast:139
027     * @production LogNotExpr : {@link Unary};
028    
029     */
030    public class LogNotExpr extends Unary implements Cloneable {
031      /**
032       * @aspect TypeCheck
033       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:338
034       */
035      public void typeCheck() {
036        if (!getOperand().type().isBoolean()) {
037          error("unary ! only operates on boolean types");
038        }
039      }
040      /**
041       * @aspect CodeGenerationBinaryOperations
042       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:659
043       */
044      void emitOperation(CodeGeneration gen) { type().logNot(gen); }
045      /**
046       * @aspect CreateBCode
047       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1047
048       */
049      public void createBCode(CodeGeneration gen) { emitBooleanCondition(gen); }
050      /**
051       * @aspect CreateBCode
052       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1135
053       */
054      public void branchTrue(CodeGeneration gen, int target)  {
055        // branch when true
056        getOperand().branchFalse(gen, target);
057      }
058      /**
059       * @aspect CreateBCode
060       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1250
061       */
062      public void branchFalse(CodeGeneration gen, int target)  {
063        // branch when false
064        getOperand().branchTrue(gen, target);
065      }
066      /**
067       * @declaredat ASTNode:1
068       */
069      public LogNotExpr() {
070        super();
071      }
072      /**
073       * Initializes the child array to the correct size.
074       * Initializes List and Opt nta children.
075       * @apilevel internal
076       * @ast method
077       * @declaredat ASTNode:10
078       */
079      public void init$Children() {
080        children = new ASTNode[1];
081      }
082      /**
083       * @declaredat ASTNode:13
084       */
085      public LogNotExpr(Expr p0) {
086        setChild(p0, 0);
087      }
088      /**
089       * @apilevel low-level
090       * @declaredat ASTNode:19
091       */
092      protected int numChildren() {
093        return 1;
094      }
095      /**
096       * @apilevel internal
097       * @declaredat ASTNode:25
098       */
099      public boolean mayHaveRewrite() {
100        return false;
101      }
102      /**
103       * @apilevel internal
104       * @declaredat ASTNode:31
105       */
106      public void flushAttrCache() {
107        super.flushAttrCache();
108        type_reset();
109      }
110      /**
111       * @apilevel internal
112       * @declaredat ASTNode:38
113       */
114      public void flushCollectionCache() {
115        super.flushCollectionCache();
116      }
117      /**
118       * @apilevel internal
119       * @declaredat ASTNode:44
120       */
121      public void flushRewriteCache() {
122        super.flushRewriteCache();
123      }
124      /**
125       * @apilevel internal
126       * @declaredat ASTNode:50
127       */
128      public LogNotExpr clone() throws CloneNotSupportedException {
129        LogNotExpr node = (LogNotExpr) super.clone();
130        return node;
131      }
132      /**
133       * @apilevel internal
134       * @declaredat ASTNode:57
135       */
136      public LogNotExpr copy() {
137        try {
138          LogNotExpr node = (LogNotExpr) clone();
139          node.parent = null;
140          if (children != null) {
141            node.children = (ASTNode[]) children.clone();
142          }
143          return node;
144        } catch (CloneNotSupportedException e) {
145          throw new Error("Error: clone not supported for " + getClass().getName());
146        }
147      }
148      /**
149       * Create a deep copy of the AST subtree at this node.
150       * The copy is dangling, i.e. has no parent.
151       * @return dangling copy of the subtree at this node
152       * @apilevel low-level
153       * @deprecated Please use treeCopy or treeCopyNoTransform instead
154       * @declaredat ASTNode:76
155       */
156      @Deprecated
157      public LogNotExpr fullCopy() {
158        return treeCopyNoTransform();
159      }
160      /**
161       * Create a deep copy of the AST subtree at this node.
162       * The copy is dangling, i.e. has no parent.
163       * @return dangling copy of the subtree at this node
164       * @apilevel low-level
165       * @declaredat ASTNode:86
166       */
167      public LogNotExpr treeCopyNoTransform() {
168        LogNotExpr tree = (LogNotExpr) copy();
169        if (children != null) {
170          for (int i = 0; i < children.length; ++i) {
171            ASTNode child = (ASTNode) children[i];
172            if (child != null) {
173              child = child.treeCopyNoTransform();
174              tree.setChild(child, i);
175            }
176          }
177        }
178        return tree;
179      }
180      /**
181       * Create a deep copy of the AST subtree at this node.
182       * The subtree of this node is traversed to trigger rewrites before copy.
183       * The copy is dangling, i.e. has no parent.
184       * @return dangling copy of the subtree at this node
185       * @apilevel low-level
186       * @declaredat ASTNode:106
187       */
188      public LogNotExpr treeCopy() {
189        doFullTraversal();
190        return treeCopyNoTransform();
191      }
192      /**
193       * @apilevel internal
194       * @declaredat ASTNode:113
195       */
196      protected boolean is$Equal(ASTNode node) {
197        return super.is$Equal(node);    
198      }
199      /**
200       * Replaces the Operand child.
201       * @param node The new node to replace the Operand child.
202       * @apilevel high-level
203       */
204      public void setOperand(Expr node) {
205        setChild(node, 0);
206      }
207      /**
208       * Retrieves the Operand child.
209       * @return The current node used as the Operand child.
210       * @apilevel high-level
211       */
212      @ASTNodeAnnotation.Child(name="Operand")
213      public Expr getOperand() {
214        return (Expr) getChild(0);
215      }
216      /**
217       * Retrieves the Operand child.
218       * <p><em>This method does not invoke AST transformations.</em></p>
219       * @return The current node used as the Operand child.
220       * @apilevel low-level
221       */
222      public Expr getOperandNoTransform() {
223        return (Expr) getChildNoTransform(0);
224      }
225      /**
226       * @attribute syn
227       * @aspect ConstantExpression
228       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:254
229       */
230      @ASTNodeAnnotation.Attribute
231      public boolean isConstant() {
232        boolean isConstant_value = getOperand().isConstant();
233    
234        return isConstant_value;
235      }
236      /**
237       * @attribute syn
238       * @aspect ConstantExpression
239       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:283
240       */
241      @ASTNodeAnnotation.Attribute
242      public boolean isTrue() {
243        boolean isTrue_value = getOperand().isFalse();
244    
245        return isTrue_value;
246      }
247      /**
248       * @attribute syn
249       * @aspect ConstantExpression
250       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:284
251       */
252      @ASTNodeAnnotation.Attribute
253      public boolean isFalse() {
254        boolean isFalse_value = getOperand().isTrue();
255    
256        return isFalse_value;
257      }
258      /**
259       * @attribute syn
260       * @aspect ConstantExpression
261       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:32
262       */
263      @ASTNodeAnnotation.Attribute
264      public Constant constant() {
265        Constant constant_value = Constant.create(!getOperand().constant().booleanValue());
266    
267        return constant_value;
268      }
269      /**
270       * @attribute syn
271       * @aspect DA
272       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:374
273       */
274      @ASTNodeAnnotation.Attribute
275      public boolean isDAafterTrue(Variable v) {
276        boolean isDAafterTrue_Variable_value = isFalse() || getOperand().isDAafterFalse(v);
277    
278        return isDAafterTrue_Variable_value;
279      }
280      /**
281       * @attribute syn
282       * @aspect DA
283       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:375
284       */
285      @ASTNodeAnnotation.Attribute
286      public boolean isDAafterFalse(Variable v) {
287        boolean isDAafterFalse_Variable_value = isTrue() || getOperand().isDAafterTrue(v);
288    
289        return isDAafterFalse_Variable_value;
290      }
291      /**
292       * @attribute syn
293       * @aspect DA
294       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:259
295       */
296      @ASTNodeAnnotation.Attribute
297      public boolean isDAafter(Variable v) {
298        boolean isDAafter_Variable_value = isDAafterTrue(v) && isDAafterFalse(v);
299    
300        return isDAafter_Variable_value;
301      }
302      /**
303       * @attribute syn
304       * @aspect DU
305       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:791
306       */
307      @ASTNodeAnnotation.Attribute
308      public boolean isDUafterTrue(Variable v) {
309        boolean isDUafterTrue_Variable_value = getOperand().isDUafterFalse(v);
310    
311        return isDUafterTrue_Variable_value;
312      }
313      /**
314       * @attribute syn
315       * @aspect DU
316       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:792
317       */
318      @ASTNodeAnnotation.Attribute
319      public boolean isDUafterFalse(Variable v) {
320        boolean isDUafterFalse_Variable_value = getOperand().isDUafterTrue(v);
321    
322        return isDUafterFalse_Variable_value;
323      }
324      /**
325       * @attribute syn
326       * @aspect DU
327       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:783
328       */
329      @ASTNodeAnnotation.Attribute
330      public boolean isDUafter(Variable v) {
331        boolean isDUafter_Variable_value = isDUafterTrue(v) && isDUafterFalse(v);
332    
333        return isDUafter_Variable_value;
334      }
335      /**
336       * @attribute syn
337       * @aspect PrettyPrintUtil
338       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:310
339       */
340      @ASTNodeAnnotation.Attribute
341      public String printPreOp() {
342        String printPreOp_value = "!";
343    
344        return printPreOp_value;
345      }
346      /**
347       * @apilevel internal
348       */
349      protected boolean type_computed = false;
350      /**
351       * @apilevel internal
352       */
353      protected TypeDecl type_value;
354      /**
355       * @apilevel internal
356       */
357      private void type_reset() {
358        type_computed = false;
359        type_value = null;
360      }
361      /**
362       * @attribute syn
363       * @aspect TypeAnalysis
364       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:302
365       */
366      @ASTNodeAnnotation.Attribute
367      public TypeDecl type() {
368        ASTNode$State state = state();
369        if (type_computed) {
370          return type_value;
371        }
372        boolean intermediate = state.INTERMEDIATE_VALUE;
373        state.INTERMEDIATE_VALUE = false;
374        int num = state.boundariesCrossed;
375        boolean isFinal = this.is$Final();
376        type_value = typeBoolean();
377        if (isFinal && num == state().boundariesCrossed) {
378          type_computed = true;
379        } else {
380        }
381        state.INTERMEDIATE_VALUE |= intermediate;
382    
383        return type_value;
384      }
385      /**
386       * @attribute syn
387       * @aspect CreateBCode
388       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1022
389       */
390      @ASTNodeAnnotation.Attribute
391      public boolean canBeTrue() {
392        boolean canBeTrue_value = getOperand().canBeFalse();
393    
394        return canBeTrue_value;
395      }
396      /**
397       * @attribute syn
398       * @aspect CreateBCode
399       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1034
400       */
401      @ASTNodeAnnotation.Attribute
402      public boolean canBeFalse() {
403        boolean canBeFalse_value = getOperand().canBeTrue();
404    
405        return canBeFalse_value;
406      }
407      /**
408       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
409       * @apilevel internal
410       */
411      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
412        if (caller == getOperandNoTransform()) {
413          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:421
414          return isDAbefore(v);
415        }
416        else {
417          return getParent().Define_isDAbefore(this, caller, v);
418        }
419      }
420      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
421        return true;
422      }
423      /**
424       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
425       * @apilevel internal
426       */
427      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
428        if (caller == getOperandNoTransform()) {
429          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:912
430          return isDUbefore(v);
431        }
432        else {
433          return getParent().Define_isDUbefore(this, caller, v);
434        }
435      }
436      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
437        return true;
438      }
439      /**
440       * @apilevel internal
441       */
442      public ASTNode rewriteTo() {
443        return super.rewriteTo();
444      }
445    }