List of usage examples for org.objectweb.asm Opcodes ACC_ABSTRACT
int ACC_ABSTRACT
To view the source code for org.objectweb.asm Opcodes ACC_ABSTRACT.
Click Source Link
From source file:org.mbte.groovypp.compiler.TraitASTTransformFinal.java
License:Apache License
public static void improveAbstractMethods(final ClassNode classNode) { if ((classNode.getModifiers() & ACC_ABSTRACT) != 0) return;/*w w w . j a v a 2s . c o m*/ List<MethodNode> abstractMethods = getAbstractMethods(classNode); boolean addInit = false; if (abstractMethods != null) { for (final MethodNode method : abstractMethods) { List<AnnotationNode> list = method.getAnnotations(TypeUtil.HAS_DEFAULT_IMPLEMENTATION); if (list != null && !list.isEmpty()) { Expression klazz = list.get(0).getMember("value"); Expression field = list.get(0).getMember("fieldName"); if (field == null || (field instanceof ConstantExpression) && (((ConstantExpression) field).getValue() == null || "".equals((((ConstantExpression) field).getValue())))) { final Parameter[] oldParams = method.getParameters(); final Parameter[] params = new Parameter[oldParams.length + 1]; params[0] = new Parameter(method.getDeclaringClass(), "$self"); System.arraycopy(oldParams, 0, params, 1, oldParams.length); final MethodNode found = klazz.getType().getMethod(method.getName(), params); if (found != null) { addImplMethod(classNode, method, oldParams, found); } } else { if ((classNode.getModifiers() & Opcodes.ACC_ABSTRACT) != 0) continue; final ClassNode fieldType; final Parameter[] parameters; final boolean getter; if (method.getName().startsWith("get")) { fieldType = TypeUtil.mapTypeFromSuper(method.getReturnType(), method.getDeclaringClass(), classNode); parameters = Parameter.EMPTY_ARRAY; getter = true; } else { fieldType = TypeUtil.mapTypeFromSuper(method.getParameters()[0].getType(), method.getDeclaringClass(), classNode); parameters = new Parameter[] { new Parameter(fieldType, method.getParameters()[0].getName()) }; getter = false; } final String fieldName = (String) ((ConstantExpression) field).getValue(); FieldNode klazzField = classNode.getField(fieldName); if (klazzField == null) { klazzField = classNode.addField(fieldName, ACC_PRIVATE, fieldType, null); final MethodNode initMethod = klazz.getType().getMethod("__init_" + fieldName, new Parameter[] { new Parameter(method.getDeclaringClass(), "$self") }); if (initMethod != null) { classNode.getObjectInitializerStatements() .add(new ExpressionStatement(new StaticMethodCallExpression(klazz.getType(), initMethod.getName(), new ArgumentListExpression(VariableExpression.THIS_EXPRESSION)))); klazzField.addAnnotation(new AnnotationNode(TypeUtil.NO_EXTERNAL_INITIALIZATION)); addInit = true; } } createGetterSetter(classNode, method, fieldType, parameters, getter, fieldName); } } else { // very special case of clone () if (method.getName().equals("clone") && method.getParameters().length == 0) { classNode.addMethod(method.getName(), ACC_PUBLIC, method.getReturnType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, new BytecodeSequence(new BytecodeInstruction() { public void visit(MethodVisitor mv) { mv.visitVarInsn(ALOAD, 0); mv.visitMethodInsn(INVOKESPECIAL, BytecodeHelper .getClassInternalName(classNode.getSuperClass().getName()), "clone", "()Ljava/lang/Object;"); if (!ClassHelper.OBJECT_TYPE.equals(method.getReturnType())) mv.visitTypeInsn(CHECKCAST, BytecodeHelper.getClassInternalName(method.getReturnType())); BytecodeExpr.doReturn(mv, ClassHelper.OBJECT_TYPE); } })); } } } } if (addInit && !classNode.getDeclaredConstructors().isEmpty()) { CleaningVerifier.getCleaningVerifier().addInitialization(classNode); classNode.getObjectInitializerStatements().clear(); } }
From source file:org.mbte.groovypp.compiler.transformers.ConstructorCallExpressionTransformer.java
License:Apache License
public Expression transform(ConstructorCallExpression exp, final CompilerTransformer compiler) { if (exp.isSuperCall() || exp.isThisCall()) return transformSpecial(exp, compiler); MethodNode constructor;//from ww w . j a va2s . c o m ClassNode type = exp.getType(); if ((ClassHelper.isPrimitiveType(type))) { compiler.addError("Can't instantiate primitive type " + type.getName(), exp); return null; } if ((type.getModifiers() & Opcodes.ACC_ABSTRACT) != 0) { compiler.addError("Can't instantiate abstract type " + type.getName(), exp); return null; } if (type instanceof InnerClassNode) { InnerClassNode innerClassNode = (InnerClassNode) type; if (innerClassNode.isAnonymous()) { if (!improveWhatInnerClassVisitorDid(innerClassNode, exp, compiler)) return null; } } rewriteThis0(exp, compiler); if (exp.getArguments() instanceof TupleExpression && ((TupleExpression) exp.getArguments()).getExpressions().size() == 1 && ((TupleExpression) exp.getArguments()).getExpressions().get(0) instanceof MapExpression) { MapExpression me = (MapExpression) ((TupleExpression) exp.getArguments()).getExpressions().get(0); constructor = compiler.findConstructor(type, MAP_ARGS, null); if (constructor == null) { final ArrayList<BytecodeExpr> propSetters = new ArrayList<BytecodeExpr>(); constructor = compiler.findConstructor(type, ClassNode.EMPTY_ARRAY, null); if (constructor != null) { for (MapEntryExpression mee : me.getMapEntryExpressions()) { BytecodeExpr obj = new BytecodeExpr(mee, type) { protected void compile(MethodVisitor mv) { mv.visitInsn(DUP); } }; propSetters.add((BytecodeExpr) compiler .transform(new BinaryExpression(new PropertyExpression(obj, mee.getKeyExpression()), Token.newSymbol(Types.ASSIGN, -1, -1), mee.getValueExpression()))); } return new BytecodeExpr(exp, type) { protected void compile(MethodVisitor mv) { final String classInternalName = BytecodeHelper.getClassInternalName(getType()); mv.visitTypeInsn(NEW, classInternalName); mv.visitInsn(DUP); mv.visitMethodInsn(INVOKESPECIAL, classInternalName, "<init>", "()V"); for (BytecodeExpr prop : propSetters) { prop.visit(mv); if (!ClassHelper.VOID_TYPE.equals(prop.getType())) pop(prop.getType(), mv); } } }; } } } final TupleExpression newArgs = (TupleExpression) compiler.transform(exp.getArguments()); final ClassNode[] argTypes = compiler.exprToTypeArray(newArgs); constructor = findConstructorWithClosureCoercion(type, argTypes, compiler, null); if (constructor != null) { if (!AccessibilityCheck.isAccessible(constructor.getModifiers(), constructor.getDeclaringClass(), compiler.classNode, null)) { compiler.addError("Cannot access constructor", exp); return null; } final Parameter[] params = constructor.getParameters(); int base = 0; // if ((type.getModifiers() & ACC_STATIC) == 0 && type.redirect() instanceof InnerClassNode) { // base = 1; // } final ArgumentListExpression finalArgs = wrapArgumentsForVarargs(newArgs, params, base); if ((constructor.getModifiers() & Opcodes.ACC_PRIVATE) != 0 && constructor.getDeclaringClass() != compiler.classNode) { MethodNode delegate = compiler.context.getConstructorDelegate(constructor); return ResolvedMethodBytecodeExpr.create(exp, delegate, null, finalArgs, compiler); } // Improve type. GenericsType[] generics = type.redirect().getGenericsTypes(); // We don't support inference if the method itself is parameterized. if (generics != null && constructor.getGenericsTypes() == null) { ClassNode[] paramTypes = new ClassNode[params.length]; for (int i = 0; i < paramTypes.length; i++) { paramTypes[i] = params[i].getType(); } ClassNode[] unified = TypeUnification.inferTypeArguments(generics, paramTypes, argTypes); if (TypeUnification.totalInference(unified)) { type = TypeUtil.withGenericTypes(type, unified); } } for (int i = 0; i != finalArgs.getExpressions().size(); ++i) finalArgs.getExpressions().set(i, compiler.cast(finalArgs.getExpressions().get(i), constructor.getParameters()[i + base].getType())); final MethodNode constructor1 = constructor; final ClassNode compilerClass = compiler.classNode; return new BytecodeExpr(exp, type) { protected void compile(MethodVisitor mv) { final String classInternalName = BytecodeHelper.getClassInternalName(getType()); mv.visitTypeInsn(NEW, classInternalName); mv.visitInsn(DUP); int first = 0; // if ((getType().getModifiers() & ACC_STATIC) == 0 && getType().redirect() instanceof InnerClassNode) { // mv.visitVarInsn(ALOAD, 0); // for (ClassNode tp = compilerClass ; tp != getType().redirect().getOuterClass(); ) { // compiler.context.setOuterClassInstanceUsed(tp); // final ClassNode outerTp = tp.redirect().getOuterClass(); // mv.visitFieldInsn(GETFIELD, BytecodeHelper.getClassInternalName(tp), "this$0", BytecodeHelper.getTypeDescription(outerTp)); // tp = outerTp; // } // first = 1; // } for (int i = 0; i != finalArgs.getExpressions().size(); ++i) { BytecodeExpr be = (BytecodeExpr) finalArgs.getExpressions().get(i); be.visit(mv); final ClassNode paramType = constructor1.getParameters()[i + first].getType(); final ClassNode type = be.getType(); box(type, mv); cast(TypeUtil.wrapSafely(type), TypeUtil.wrapSafely(paramType), mv); unbox(paramType, mv); } mv.visitMethodInsn(INVOKESPECIAL, classInternalName, "<init>", BytecodeHelper .getMethodDescriptor(ClassHelper.VOID_TYPE, constructor1.getParameters())); } }; } if (compiler.policy == TypePolicy.STATIC) { compiler.addError("Cannot find constructor of " + exp.getType().getName(), exp); return null; } else return createDynamicCall(exp, compiler, newArgs); }
From source file:org.openjdk.jmh.generators.asm.ASMClassInfo.java
License:Open Source License
@Override public boolean isAbstract() { return (access & Opcodes.ACC_ABSTRACT) > 0; }
From source file:org.osjava.jardiff.Tools.java
License:Apache License
/** * Returns whether a class's newAccess is incompatible with oldAccess * following <a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html">Java Language Specification, Java SE 7 Edition</a>: * <ul>/*from w ww . j a v a 2 s.c o m*/ * <li><a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html#jls-13.4.1">13.4.1 abstract Classes</a><ul> * <li>If a class that was not declared abstract is changed to be declared abstract, * then pre-existing binaries that attempt to create new instances of that class * will throw either an InstantiationError at link time, * or (if a reflective method is used) an InstantiationException at run time. * Such changes <b>break backward compatibility</b>!</li> * <li>Changing a class that is declared abstract to no longer be declared abstract * <b>does not break compatibility</b> with pre-existing binaries.</li> * </ul></li> * <li><a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html#jls-13.4.2">13.4.2 final Classes</a><ul> * <li>If a class that was not declared final is changed to be declared final, * then a VerifyError is thrown if a binary of a pre-existing subclass of this class is loaded, * because final classes can have no subclasses. * Such changes <b>break functional backward compatibility</b>!</li> * <li>Changing a class that is declared final to no longer be declared final * <b>does not break compatibility</b> with pre-existing binaries.</li> * </ul></li> * </ul> * * @param oldAccess * @param newAccess * @return */ public static boolean isClassAccessChange(final int oldAccess, final int newAccess) { if (not(oldAccess, Opcodes.ACC_ABSTRACT) && has(newAccess, Opcodes.ACC_ABSTRACT)) { return true; // 13.4.1 #1 } else if (not(oldAccess, Opcodes.ACC_FINAL) && has(newAccess, Opcodes.ACC_FINAL)) { return true; // 13.4.2 #1 } else { final int compatibleChanges = Opcodes.ACC_ABSTRACT | // 13.4.1 #2 Opcodes.ACC_FINAL; // 13.4.2 #2 // FIXME Opcodes.ACC_VOLATILE ? final int oldAccess2 = oldAccess & ~compatibleChanges; final int newAccess2 = newAccess & ~compatibleChanges; return oldAccess2 != newAccess2; } }
From source file:org.osjava.jardiff.Tools.java
License:Apache License
/** * Returns whether a method's newAccess is incompatible with oldAccess * following <a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html">Java Language Specification, Java SE 7 Edition</a>: * <ul>/*from w ww .jav a2 s . c o m*/ * <li><a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html#jls-13.4.9">13.4.7 Access to Members and Constructors</a><ul> * <li>Changing the declared access of a member or constructor to permit less access * <b>may break compatibility</b> with pre-existing binaries, causing a linkage error to be thrown when these binaries are resolved. * </li> * <li>The binary format is defined so that changing a member or constructor to be more accessible does not cause a * linkage error when a subclass (already) defines a method to have less access. * </li> * </ul></li> * <li><a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html#jls-13.4.16">13.4.16 abstract Methods</a><ul> * <li>Changing a method that is declared abstract to no longer be declared abstract * <b>does not break compatibility</b> with pre-existing binaries.</li> * <li>Changing a method that is not declared abstract to be declared abstract * <b>will break compatibility</b> with pre-existing binaries that previously invoked the method, causing an AbstractMethodError.</li> * </ul></li> * <li><a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html#jls-13.4.17">13.4.17 final</a><ul> * <li>Changing a method that is declared final to no longer be declared final * <b>does not break compatibility</b> with pre-existing binaries.</li> * <li>Changing an instance method that is not declared final to be declared final * <b>may break compatibility</b> with existing binaries that depend on the ability to override the method.</li> * <li>Changing a class (static) method that is not declared final to be declared final * <b>does not break compatibility</b> with existing binaries, because the method could not have been overridden.</li> * </ul></li> * <li><a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html#jls-13.4.18">13.4.18 native Methods</a><ul> * <li>Adding or deleting a native modifier of a method * <b>does not break compatibility</b> with pre-existing binaries.</li> * </ul></li> * <li><a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html#jls-13.4.19">13.4.19 static Methods</a><ul> * <li>If a method that is not declared private is also declared static (that is, a class method) * and is changed to not be declared static (that is, to an instance method), or vice versa, * then <i>compatibility with pre-existing binaries may be broken</i>, resulting in a linkage time error, * namely an IncompatibleClassChangeError, if these methods are used by the pre-existing binaries. * Such changes <b>break functional backward compatibility</b>!</li> * </ul></li> * <li><a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html#jls-13.4.20">13.4.20 synchronized Methods</a><ul> * <li>Adding or deleting a synchronized modifier of a method * <b>does not break compatibility</b> with pre-existing binaries.</li> * </ul></li> * <li><a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html#jls-13.4.21">13.4.21 Method and Constructor Throws</a><ul> * <li>Changes to the throws clause of methods or constructors * <b>do not break compatibility</b> with pre-existing binaries; these clauses are checked only at compile time.</li> * </ul></li> * </ul> * * @param oldAccess * @param newAccess * @return */ public static boolean isMethodAccessChange(final int oldAccess, final int newAccess) { if (isAccessIncompatible(oldAccess, newAccess)) { return true; // 13.4.7 } if (not(oldAccess, Opcodes.ACC_ABSTRACT) && has(newAccess, Opcodes.ACC_ABSTRACT)) { return true; // 13.4.16 #2 } else if (not(oldAccess, Opcodes.ACC_FINAL) && not(oldAccess, Opcodes.ACC_STATIC) && has(newAccess, Opcodes.ACC_FINAL)) { return true; // 13.4.17 #2 excluding and #3 } else { final int compatibleChanges = Opcodes.ACC_ABSTRACT | // 13.4.16 #1 Opcodes.ACC_FINAL | // 13.4.17 #1 Opcodes.ACC_NATIVE | // 13.4.18 #1 Opcodes.ACC_SYNCHRONIZED; // 13.4.20 #1 final int accessPermissions = Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED | Opcodes.ACC_PRIVATE; final int oldAccess2 = oldAccess & ~compatibleChanges & ~accessPermissions; final int newAccess2 = newAccess & ~compatibleChanges & ~accessPermissions; return oldAccess2 != newAccess2; } }
From source file:org.osjava.jardiff.ToolsTest.java
License:Apache License
@Test public void isClassAccessChange() { // A class can't become final. assertTrue(Tools.isClassAccessChange(0, Opcodes.ACC_FINAL)); assertTrue(Tools.isClassAccessChange(0, Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL)); // ... but can become non-final. assertFalse(Tools.isClassAccessChange(Opcodes.ACC_FINAL, 0)); assertFalse(Tools.isClassAccessChange(Opcodes.ACC_FINAL + Opcodes.ACC_PUBLIC, Opcodes.ACC_PUBLIC)); // No matter the final access, can't become protected or private or // package if it was public. assertTrue(Tools.isClassAccessChange(Opcodes.ACC_FINAL + Opcodes.ACC_PUBLIC, 0)); assertTrue(Tools.isClassAccessChange(Opcodes.ACC_PUBLIC, Opcodes.ACC_PROTECTED)); // A class can become concrete. assertFalse(Tools.isClassAccessChange(Opcodes.ACC_ABSTRACT, 0)); assertFalse(Tools.isClassAccessChange(Opcodes.ACC_ABSTRACT + Opcodes.ACC_PUBLIC, Opcodes.ACC_PUBLIC)); assertFalse(Tools.isClassAccessChange(Opcodes.ACC_ABSTRACT + Opcodes.ACC_PROTECTED, Opcodes.ACC_PROTECTED)); // ...but can't become abstract assertTrue(Tools.isClassAccessChange(0, Opcodes.ACC_ABSTRACT)); assertTrue(Tools.isClassAccessChange(Opcodes.ACC_PUBLIC, Opcodes.ACC_PUBLIC + Opcodes.ACC_ABSTRACT)); assertTrue(Tools.isClassAccessChange(Opcodes.ACC_PROTECTED, Opcodes.ACC_PROTECTED + Opcodes.ACC_ABSTRACT)); }
From source file:org.osjava.jardiff.ToolsTest.java
License:Apache License
@Test public void isMethodAccessChange() { // A non-static method can't become final. assertTrue(Tools.isMethodAccessChange(0, Opcodes.ACC_FINAL)); assertTrue(Tools.isMethodAccessChange(0, Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL)); // ... but can become non-final. assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_FINAL, 0)); assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_FINAL + Opcodes.ACC_PUBLIC, Opcodes.ACC_PUBLIC)); // ... but a static method can become final! assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_STATIC, Opcodes.ACC_STATIC + Opcodes.ACC_FINAL)); assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_STATIC + Opcodes.ACC_PUBLIC, Opcodes.ACC_STATIC + Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL)); // A method can become more accessible assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_PROTECTED, Opcodes.ACC_PUBLIC)); assertFalse(Tools.isMethodAccessChange(0, Opcodes.ACC_PUBLIC)); assertFalse(Tools.isMethodAccessChange(0, Opcodes.ACC_PROTECTED)); assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_PRIVATE, Opcodes.ACC_PUBLIC)); assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_PRIVATE, Opcodes.ACC_PROTECTED)); assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_PRIVATE, 0)); // ...but can't become less accessible assertTrue(Tools.isMethodAccessChange(Opcodes.ACC_FINAL + Opcodes.ACC_PUBLIC, 0)); assertTrue(Tools.isMethodAccessChange(Opcodes.ACC_PUBLIC, Opcodes.ACC_PROTECTED)); assertTrue(Tools.isMethodAccessChange(Opcodes.ACC_PUBLIC, Opcodes.ACC_PRIVATE)); assertTrue(Tools.isMethodAccessChange(Opcodes.ACC_PROTECTED, 0)); assertTrue(Tools.isMethodAccessChange(Opcodes.ACC_PROTECTED, Opcodes.ACC_PRIVATE)); assertTrue(Tools.isMethodAccessChange(0, Opcodes.ACC_PRIVATE)); // A class or method can become concrete. assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_ABSTRACT, 0)); assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_ABSTRACT + Opcodes.ACC_PUBLIC, Opcodes.ACC_PUBLIC)); assertFalse(//from ww w . ja v a 2 s .c o m Tools.isMethodAccessChange(Opcodes.ACC_ABSTRACT + Opcodes.ACC_PROTECTED, Opcodes.ACC_PROTECTED)); // ...but can't become abstract assertTrue(Tools.isMethodAccessChange(0, Opcodes.ACC_ABSTRACT)); assertTrue(Tools.isMethodAccessChange(Opcodes.ACC_PUBLIC, Opcodes.ACC_PUBLIC + Opcodes.ACC_ABSTRACT)); assertTrue(Tools.isMethodAccessChange(Opcodes.ACC_PROTECTED, Opcodes.ACC_PROTECTED + Opcodes.ACC_ABSTRACT)); // A method can't change static assertTrue(Tools.isMethodAccessChange(Opcodes.ACC_STATIC, 0)); assertTrue(Tools.isMethodAccessChange(Opcodes.ACC_STATIC + Opcodes.ACC_PUBLIC, Opcodes.ACC_PUBLIC)); // A method can change synchronized assertFalse(Tools.isMethodAccessChange(0, Opcodes.ACC_SYNCHRONIZED)); assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_PUBLIC, Opcodes.ACC_PUBLIC + Opcodes.ACC_SYNCHRONIZED)); assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_SYNCHRONIZED, 0)); assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_PUBLIC + Opcodes.ACC_SYNCHRONIZED, Opcodes.ACC_PUBLIC)); // A method can change native assertFalse(Tools.isMethodAccessChange(0, Opcodes.ACC_NATIVE)); assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_PUBLIC, Opcodes.ACC_PUBLIC + Opcodes.ACC_NATIVE)); assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_NATIVE, 0)); assertFalse(Tools.isMethodAccessChange(Opcodes.ACC_PUBLIC + Opcodes.ACC_NATIVE, Opcodes.ACC_PUBLIC)); }
From source file:org.pitest.classinfo.ClassInfo.java
License:Apache License
public boolean isAbstract() { return (this.access & Opcodes.ACC_ABSTRACT) != 0; }
From source file:org.pitest.classinfo.ClassInfoTest.java
License:Apache License
@Test public void matchIfAbstractShouldReturnTrueForAbstractClasses() { this.data.access = Opcodes.ACC_ABSTRACT; makeTestee();// ww w . j a va2s . com assertTrue(ClassInfo.matchIfAbstract().apply(this.testee)); }
From source file:org.rascalmpl.library.lang.java.m3.internal.JarConverter.java
License:Open Source License
private IConstructor mapFieldAccesCode(int code, int where) { // Check the original M3 implementation for possible IConstructor types. switch (code) { case Opcodes.ACC_PUBLIC: return constructModifierNode("public"); case Opcodes.ACC_PRIVATE: return constructModifierNode("private"); case Opcodes.ACC_PROTECTED: return constructModifierNode("protected"); case Opcodes.ACC_STATIC: return constructModifierNode("static"); case Opcodes.ACC_FINAL: return constructModifierNode("final"); case Opcodes.ACC_SYNCHRONIZED: if (where == CLASSE) return null; return constructModifierNode("synchronized"); case Opcodes.ACC_ABSTRACT: return constructModifierNode("abstract"); case Opcodes.ACC_VOLATILE: return constructModifierNode("volatile"); case Opcodes.ACC_TRANSIENT: return constructModifierNode("transient"); case Opcodes.ACC_NATIVE: return constructModifierNode("native"); // TODO: GIT PULL/MERGE ORIGINAL RASCAL VERSION < 2013-11-30 (Shahin commit) // case Opcodes.ACC_DEPRECATED: // return constructModifierNode("deprecated"); default:/*w ww . j ava 2 s .c om*/ return null; } }