case 'a': if ("abstract".equals(ident)) { modifiers = modifiers.toAbstract(true); } else { break loop; modifiers = modifiers.toFinal(true); } else { break loop; modifiers = modifiers.toNative(true); } else { break loop; modifiers = modifiers.toPublic(true); } else if ("private".equals(ident)) { modifiers = modifiers.toPrivate(true); } else if ("protected".equals(ident)) { modifiers = modifiers.toProtected(true); } else { break loop; modifiers = modifiers.toStatic(true); } else if ("synchronized".equals(ident)) { modifiers = modifiers.toSynchronized(true); } else if ("strict".equals(ident)) { modifiers = modifiers.toStrict(true); } else { break loop;
if (modifiers.isPublic()) { if (modifiers.isAbstract()) { print("PUBLIC_ABSTRACT"); modifiers = modifiers.toAbstract(false); } else if (modifiers.isStatic()) { print("PUBLIC_STATIC"); modifiers = modifiers.toStatic(false); } else { print("PUBLIC"); modifiers = modifiers.toPublic(false); } else if (modifiers.isProtected()) { print("PROTECTED"); modifiers = modifiers.toProtected(false); } else if (modifiers.isPrivate()) { print("PRIVATE"); modifiers = modifiers.toPrivate(false); } else { print("NONE"); if (modifiers.isStatic()) { print(".toStatic(true)"); if (modifiers.isFinal()) { print(".toFinal(true)"); if (modifiers.isSynchronized()) { print(".toSynchronized(true)");
/** * When set as an interface, non-interface settings are cleared and the * bitmask is set abstract. * * @param b true to set interface, false otherwise */ public Modifiers toInterface(boolean b) { return convert(toInterface(mBitmask, b)); }
Modifiers modifiers = Modifiers.getInstance(din.readUnsignedShort()) .toSynchronized(false); .toStatic(innerFlags.isStatic()) .toPrivate(innerFlags.isPrivate()) .toProtected(innerFlags.isProtected()) .toPublic(innerFlags.isPublic()); } else if (info.getOuterClass() == null || thisClass.equals(info.getOuterClass())) {
mClassFile.addField(Modifiers.PROTECTED.toFinal(true), SUPPORT_FIELD_NAME, mSupportType); final Modifiers fieldModifiers = Modifiers.PROTECTED.toStatic(true).toFinal(true); mClassFile.addField(Modifiers.PRIVATE.toTransient(true), name, type); requireStateField = true; } else { mClassFile.addField(Modifiers.PROTECTED.toVolatile(isVolatile), name, type); requireStateField = true; mi.setModifiers(mi.getModifiers().toSynchronized(true)); mi.setModifiers(mi.getModifiers().toSynchronized(true)); CodeBuilder b = new CodeBuilder(mi); (Modifiers.PROTECTED, writeName, null, new TypeDesc[] {fromType}); mi.markSynthetic(); mi.setModifiers(mi.getModifiers().toSynchronized(true)); (Modifiers.PUBLIC.toSynchronized(true), TRY_LOAD_METHOD_NAME, TypeDesc.BOOLEAN, null); (Modifiers.PROTECTED.toAbstract(true), DO_TRY_LOAD_METHOD_NAME, TypeDesc.BOOLEAN, null); mi.addException(TypeDesc.forClass(FetchException.class));
private String addStaticComparatorField(TypeDesc type) { if (mComparatorFields == null) { mComparatorFields = new IdentityHashMap<TypeDesc, String>(); } String fieldName = mComparatorFields.get(type); if (fieldName != null) { return fieldName; } fieldName = COMPARATOR_FIELD_PREFIX + mComparatorFields.size(); TypeDesc comparatorType = TypeDesc.forClass(Comparator.class); mClassFile.addField(Modifiers.PRIVATE.toStatic(true).toFinal(true), fieldName, comparatorType); if (mStaticInitBuilder == null) { mStaticInitBuilder = new CodeBuilder(mClassFile.addInitializer()); } mStaticInitBuilder.loadConstant(type); mStaticInitBuilder.loadConstant(true); mStaticInitBuilder.invokeStatic (TypeDesc.forClass(Comparators.class), "arrayComparator", comparatorType, new TypeDesc[] {TypeDesc.forClass(Class.class), BOOLEAN}); mStaticInitBuilder.storeStaticField(fieldName, comparatorType); mComparatorFields.put(type, fieldName); return fieldName; }
if (aFlags.isStatic()) { if (!bFlags.isStatic()) { return -1; if (bFlags.isStatic()) { return 1; if (aFlags.isPublic()) { aValue = 0; } else if (aFlags.isProtected()) { aValue = 4; } else if (!aFlags.isPrivate()) { aValue = 8; } else { if (bFlags.isPublic()) { bValue = 0; } else if (bFlags.isProtected()) { bValue = 4; } else if (!bFlags.isPrivate()) { bValue = 8; } else { aValue += (aFlags.isFinal()) ? 0 : 2; bValue += (bFlags.isFinal()) ? 0 : 2; aValue += (aFlags.isTransient()) ? 1 : 0; bValue += (bFlags.isTransient()) ? 1 : 0;
cf.addField(Modifiers.PRIVATE.toFinal(true), REF_FIELD_NAME, atomicRefType);
md.getReturnType() == TypeDesc.VOID && md.getParameterCount() == 0 && (method.getModifiers().isStatic()) && (!method.getModifiers().isAbstract()) && method.getExceptions().length == 0) { } else { Modifiers modifiers = method.getModifiers(); boolean varargs = modifiers.isVarArgs(); if (varargs) { modifiers = modifiers.toVarArgs(false);
cf.setModifiers(cf.getModifiers().toAbstract(true)); cf.markSynthetic(); cf.setSourceFile(RawStorableGenerator.class.getName()); cf.addMethod(Modifiers.PROTECTED.toAbstract(true), ENCODE_KEY_METHOD_NAME, byteArrayType, null); cf.addMethod(Modifiers.PROTECTED.toAbstract(true), DECODE_KEY_METHOD_NAME, null, new TypeDesc[]{byteArrayType}); cf.addMethod(Modifiers.PROTECTED.toAbstract(true), ENCODE_DATA_METHOD_NAME, byteArrayType, null); cf.addMethod(Modifiers.PROTECTED.toAbstract(true), DECODE_DATA_METHOD_NAME, null, new TypeDesc[]{byteArrayType}); (Modifiers.PROTECTED.toFinal(true), MasterStorableGenerator.DO_TRY_LOAD_MASTER_METHOD_NAME, TypeDesc.BOOLEAN, null); mi.addException(TypeDesc.forClass(FetchException.class)); (Modifiers.PROTECTED.toFinal(true), MasterStorableGenerator.DO_TRY_INSERT_MASTER_METHOD_NAME, TypeDesc.BOOLEAN, null); mi.addException(TypeDesc.forClass(PersistException.class)); (Modifiers.PROTECTED.toFinal(true), MasterStorableGenerator.DO_TRY_UPDATE_MASTER_METHOD_NAME, TypeDesc.BOOLEAN, null); mi.addException(TypeDesc.forClass(PersistException.class)); (Modifiers.PROTECTED.toFinal(true), MasterStorableGenerator.DO_TRY_DELETE_MASTER_METHOD_NAME, TypeDesc.BOOLEAN, null); mi.addException(TypeDesc.forClass(PersistException.class));
if (cf.getModifiers().isInterface()) { cf.addField(Modifiers.PRIVATE.toStatic(true), mHandlerFieldName, TypeDesc.forClass(TraceHandler.class)); int hasThis = mi.getModifiers().isStatic() ? 0 : 1;
generatedSequenceFields = true; cf.addField(Modifiers.PRIVATE.toVolatile(true), SEQUENCE_NAME, TypeDesc.INT); cf.addField(Modifiers.PRIVATE.toStatic(true).toFinal(true), SEQUENCE_UPDATER_NAME, updaterType); mods = mods.toVolatile(true); } else { mods = mods.toFinal(true); (Modifiers.PUBLIC.toStatic(true), "sessionLink", LINK_TYPE, new TypeDesc[] {cf.getType()}); CodeBuilder b = new CodeBuilder(mi);
MethodInfo(ClassFile parent, Modifiers modifiers, String name, MethodDesc desc) { mParent = parent; mCp = parent.getConstantPool(); mName = name; mDesc = desc; mModifiers = modifiers; mNameConstant = mCp.addConstantUTF(name); mDescriptorConstant = mCp.addConstantUTF(desc.getDescriptor()); if (!modifiers.isAbstract() && !modifiers.isNative()) { addAttribute(new CodeAttr(mCp)); } }
/** * Add a static initializer to this class. */ public MethodInfo addInitializer() { MethodDesc md = MethodDesc.forArguments(null, null); Modifiers af = Modifiers.NONE.toStatic(true); MethodInfo mi = new MethodInfo(this, af, "<clinit>", md); mMethods.add(mi); return mi; }
void set(ConstantPool cp, MethodInfo info) { TypeDesc[] paramTypes = info.getMethodDescriptor().getParameterTypes(); VerificationTypeInfo[] infos; int offset; if (info.getModifiers().isStatic()) { infos = new VerificationTypeInfo[paramTypes.length]; offset = 0; } else { infos = new VerificationTypeInfo[1 + paramTypes.length]; if (info.getName().equals("<init>")) { infos[0] = UninitThisVariableInfo.THE; } else { infos[0] = VerificationTypeInfo.forType(cp, info.getClassFile().getType()); } offset = 1; } for (int i=0; i<paramTypes.length; i++) { infos[offset + i] = VerificationTypeInfo.forType(cp, paramTypes[i]); } mLocalInfos = infos; } }
/** * When set volatile, non-field settings are cleared. * * @param b true to set volatile, false otherwise */ public Modifiers toVolatile(boolean b) { return convert(toVolatile(mBitmask, b)); }