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:143 027 * @production PostfixExpr : {@link Unary}; 028 029 */ 030 public abstract class PostfixExpr extends Unary implements Cloneable { 031 /** 032 * @aspect DefiniteAssignment 033 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:86 034 */ 035 public void definiteAssignment() { 036 if (getOperand().isVariable()) { 037 Variable v = getOperand().varDecl(); 038 if (v != null && v.isFinal()) { 039 error("++ and -- can not be applied to final variable " + v); 040 } 041 } 042 } 043 /** 044 * @aspect DA 045 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:521 046 */ 047 protected boolean checkDUeverywhere(Variable v) { 048 if (getOperand().isVariable() && getOperand().varDecl() == v) { 049 if (!isDAbefore(v)) { 050 return false; 051 } 052 } 053 return super.checkDUeverywhere(v); 054 } 055 /** 056 * @aspect TypeCheck 057 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:345 058 */ 059 public void typeCheck() { 060 if (!getOperand().isVariable()) { 061 error("postfix expressions only work on variables"); 062 } else if (!getOperand().type().isNumericType()) { 063 error("postfix expressions only operates on numeric types"); 064 } 065 } 066 /** 067 * @declaredat ASTNode:1 068 */ 069 public PostfixExpr() { 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 PostfixExpr(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 } 109 /** 110 * @apilevel internal 111 * @declaredat ASTNode:37 112 */ 113 public void flushCollectionCache() { 114 super.flushCollectionCache(); 115 } 116 /** 117 * @apilevel internal 118 * @declaredat ASTNode:43 119 */ 120 public void flushRewriteCache() { 121 super.flushRewriteCache(); 122 } 123 /** 124 * @apilevel internal 125 * @declaredat ASTNode:49 126 */ 127 public PostfixExpr clone() throws CloneNotSupportedException { 128 PostfixExpr node = (PostfixExpr) super.clone(); 129 return node; 130 } 131 /** 132 * Create a deep copy of the AST subtree at this node. 133 * The copy is dangling, i.e. has no parent. 134 * @return dangling copy of the subtree at this node 135 * @apilevel low-level 136 * @deprecated Please use treeCopy or treeCopyNoTransform instead 137 * @declaredat ASTNode:60 138 */ 139 @Deprecated 140 public abstract PostfixExpr fullCopy(); 141 /** 142 * Create a deep copy of the AST subtree at this node. 143 * The copy is dangling, i.e. has no parent. 144 * @return dangling copy of the subtree at this node 145 * @apilevel low-level 146 * @declaredat ASTNode:68 147 */ 148 public abstract PostfixExpr treeCopyNoTransform(); 149 /** 150 * Create a deep copy of the AST subtree at this node. 151 * The subtree of this node is traversed to trigger rewrites before copy. 152 * The copy is dangling, i.e. has no parent. 153 * @return dangling copy of the subtree at this node 154 * @apilevel low-level 155 * @declaredat ASTNode:76 156 */ 157 public abstract PostfixExpr treeCopy(); 158 /** 159 * Replaces the Operand child. 160 * @param node The new node to replace the Operand child. 161 * @apilevel high-level 162 */ 163 public void setOperand(Expr node) { 164 setChild(node, 0); 165 } 166 /** 167 * Retrieves the Operand child. 168 * @return The current node used as the Operand child. 169 * @apilevel high-level 170 */ 171 @ASTNodeAnnotation.Child(name="Operand") 172 public Expr getOperand() { 173 return (Expr) getChild(0); 174 } 175 /** 176 * Retrieves the Operand child. 177 * <p><em>This method does not invoke AST transformations.</em></p> 178 * @return The current node used as the Operand child. 179 * @apilevel low-level 180 */ 181 public Expr getOperandNoTransform() { 182 return (Expr) getChildNoTransform(0); 183 } 184 /** 185 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:37 186 * @apilevel internal 187 */ 188 public boolean Define_isDest(ASTNode caller, ASTNode child) { 189 if (caller == getOperandNoTransform()) { 190 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:67 191 return true; 192 } 193 else { 194 return getParent().Define_isDest(this, caller); 195 } 196 } 197 protected boolean canDefine_isDest(ASTNode caller, ASTNode child) { 198 return true; 199 } 200 /** 201 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:71 202 * @apilevel internal 203 */ 204 public boolean Define_isIncOrDec(ASTNode caller, ASTNode child) { 205 if (caller == getOperandNoTransform()) { 206 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:76 207 return true; 208 } 209 else { 210 return getParent().Define_isIncOrDec(this, caller); 211 } 212 } 213 protected boolean canDefine_isIncOrDec(ASTNode caller, ASTNode child) { 214 return true; 215 } 216 /** 217 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 218 * @apilevel internal 219 */ 220 public NameType Define_nameType(ASTNode caller, ASTNode child) { 221 if (caller == getOperandNoTransform()) { 222 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:125 223 return NameType.EXPRESSION_NAME; 224 } 225 else { 226 return getParent().Define_nameType(this, caller); 227 } 228 } 229 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 230 return true; 231 } 232 /** 233 * @apilevel internal 234 */ 235 public ASTNode rewriteTo() { 236 return super.rewriteTo(); 237 } 238 }