public static ISignaturePattern readNotSignaturePattern(VersionedDataInputStream s, ISourceContext context) throws IOException { NotSignaturePattern ret = new NotSignaturePattern(readCompoundSignaturePattern(s, context)); // ret.readLocation(context, s); // TODO output position currently useless so dont need to do this s.readInt(); s.readInt(); return ret; }
public static ResolvedMember[] readResolvedMemberArray(VersionedDataInputStream s, ISourceContext context) throws IOException { int len = s.readInt(); ResolvedMember[] members = new ResolvedMember[len]; for (int i = 0; i < len; i++) { members[i] = ResolvedMemberImpl.readResolvedMember(s, context); } return members; }
public static ISignaturePattern readOrSignaturePattern(VersionedDataInputStream s, ISourceContext context) throws IOException { OrSignaturePattern ret = new OrSignaturePattern(readCompoundSignaturePattern(s, context), readCompoundSignaturePattern(s, context)); s.readInt(); s.readInt(); // ret.readLocation(context, s); // TODO output position currently useless so dont need to do this return ret; }
public static ISignaturePattern readAndSignaturePattern(VersionedDataInputStream s, ISourceContext context) throws IOException { AndSignaturePattern ret = new AndSignaturePattern(readCompoundSignaturePattern(s, context), readCompoundSignaturePattern(s, context)); s.readInt(); s.readInt(); // ret.readLocation(context, s); // TODO output position currently useless so dont need to do this return ret; }
public static AdviceAttribute read(VersionedDataInputStream s, ISourceContext context) throws IOException { AdviceKind kind = AdviceKind.read(s); if (kind == AdviceKind.Around) { return new AdviceAttribute(kind, Pointcut.read(s, context), s.readByte(), s.readInt(), s.readInt(), context, s.readBoolean(), ResolvedMemberImpl.readResolvedMemberArray(s, context), FileUtil.readBooleanArray(s), UnresolvedType.readArray(s)); } else { return new AdviceAttribute(kind, Pointcut.read(s, context), s.readByte(), s.readInt(), s.readInt(), context); } }
protected static Set<ResolvedMember> readSuperMethodsCalled(VersionedDataInputStream s) throws IOException { Set<ResolvedMember> ret = new HashSet<ResolvedMember>(); int n = -1; if (s.isAtLeast169()) { n = s.readByte(); } else { n = s.readInt(); } if (n < 0) { throw new BCException("Problem deserializing type munger"); } for (int i = 0; i < n; i++) { ret.add(ResolvedMemberImpl.readResolvedMember(s, null)); } return ret; }
public static TypeVariablePatternList read(VersionedDataInputStream s, ISourceContext context) throws IOException { TypeVariablePatternList ret = EMPTY; int length = s.readInt(); if (length > 0) { TypeVariablePattern[] patterns = new TypeVariablePattern[length]; for (int i = 0; i < patterns.length; i++) { patterns[i] = TypeVariablePattern.read(s, context); } ret = new TypeVariablePatternList(patterns); } ret.readLocation(context, s); // redundant but safe to read location for EMPTY return ret; }
protected static List<String> readInTypeAliases(VersionedDataInputStream s) throws IOException { if (s.getMajorVersion() >= AjAttribute.WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ150) { int count = -1; if (s.isAtLeast169()) { count = s.readByte(); } else { count = s.readInt(); } if (count != 0) { List<String> aliases = new ArrayList<String>(); for (int i = 0; i < count; i++) { aliases.add(s.readUTF()); } return aliases; } } return null; }
public static SourceContextAttribute read(VersionedDataInputStream s) throws IOException { String sourceFileName = s.isAtLeast169() ? s.readPath() : s.readUTF(); int lineBreaks = s.readInt(); int[] lines = new int[lineBreaks]; int previous = 0; for (int i = 0; i < lineBreaks; i++) { if (s.isAtLeast169()) { lines[i] = s.readShort() + previous; previous = lines[i]; } else { lines[i] = s.readInt(); } } return new SourceContextAttribute(sourceFileName, lines); }
public static Declare read(VersionedDataInputStream s, ISourceContext context) throws IOException { DeclareParentsMixin ret = new DeclareParentsMixin(TypePattern.read(s, context), TypePatternList.read(s, context)); ret.readLocation(context, s); ret.bitflags = s.readInt(); return ret; }
public static TypeVariable read(VersionedDataInputStream s) throws IOException { // if (s.getMajorVersion()>=AjAttribute.WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ150) { String name = s.readUTF(); UnresolvedType ubound = UnresolvedType.read(s); int iboundcount = s.readInt(); UnresolvedType[] ibounds = UnresolvedType.NONE; if (iboundcount > 0) { ibounds = new UnresolvedType[iboundcount]; for (int i = 0; i < iboundcount; i++) { ibounds[i] = UnresolvedType.read(s); } } TypeVariable newVariable = new TypeVariable(name, ubound, ibounds); return newVariable; }
public static ResolvedPointcutDefinition read(VersionedDataInputStream s, ISourceContext context) throws IOException { ResolvedPointcutDefinition rpd = new ResolvedPointcutDefinition(UnresolvedType.read(s), s.readInt(), s.readUTF(), UnresolvedType.readArray(s), Pointcut.read(s, context)); rpd.setSourceContext(context); // whilst we have a source context, let's remember it return rpd; }
public static ResolvedTypeMunger readInnerClass(VersionedDataInputStream stream, ISourceContext context) throws IOException { /* int version = */stream.readInt(); UnresolvedType targetType = UnresolvedType.read(stream); String memberTypeName = stream.readUTF(); ISourceLocation sourceLocation = readSourceLocation(stream); List<String> typeVarAliases = readInTypeAliases(stream); NewMemberClassTypeMunger newInstance = new NewMemberClassTypeMunger(targetType, memberTypeName); newInstance.setTypeVariableAliases(typeVarAliases); newInstance.setSourceLocation(sourceLocation); return newInstance; }
public static TypePattern readTypePatternOldStyle(VersionedDataInputStream s, ISourceContext context) throws IOException { int len = s.readShort(); NamePattern[] namePatterns = new NamePattern[len]; for (int i = 0; i < len; i++) { namePatterns[i] = NamePattern.read(s); } boolean includeSubtypes = s.readBoolean(); int dim = s.readInt(); WildTypePattern ret = new WildTypePattern(namePatterns, includeSubtypes, dim, false, null); ret.knownMatches = FileUtil.readStringArray(s); ret.importedPrefixes = FileUtil.readStringArray(s); ret.readLocation(context, s); return ret; }
public static AnnotationTypePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException { WildAnnotationTypePattern ret; byte version = s.readByte(); if (version > VERSION) { throw new BCException("ExactAnnotationTypePattern was written by a newer version of AspectJ"); } TypePattern t = TypePattern.read(s, context); ret = new WildAnnotationTypePattern(t); ret.readLocation(context, s); if (s.getMajorVersion() >= WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ160) { if (s.readBoolean()) { ret.setForParameterAnnotationMatch(); } } if (s.getMajorVersion() >= WeaverVersionInfo.WEAVER_VERSION_MAJOR_AJ160M2) { int annotationValueCount = s.readInt(); if (annotationValueCount > 0) { Map<String, String> aValues = new HashMap<String, String>(); for (int i = 0; i < annotationValueCount; i++) { String key = s.readUTF(); String val = s.readUTF(); aValues.put(key, val); } ret.annotationValues = aValues; } } return ret; }
public static ResolvedTypeMunger readField(VersionedDataInputStream s, ISourceContext context) throws IOException { ISourceLocation sloc = null; ResolvedMember fieldSignature = ResolvedMemberImpl.readResolvedMember(s, context); Set superMethodsCalled = readSuperMethodsCalled(s); sloc = readSourceLocation(s); List aliases = readInTypeAliases(s); NewFieldTypeMunger munger = new NewFieldTypeMunger(fieldSignature, superMethodsCalled, aliases); if (sloc != null) { munger.setSourceLocation(sloc); } if (s.getMajorVersion() >= WeaverVersionInfo.WEAVER_VERSION_AJ169) { // there is a version int munger.version = s.readInt(); } else { munger.version = VersionOne; } return munger; }
public static TypeVariablePattern read(VersionedDataInputStream s, ISourceContext context) throws IOException { TypeVariablePattern tv = null; String name = s.readUTF(); TypePattern upperBound = TypePattern.read(s, context); TypePattern[] additionalInterfaceBounds = null; int numInterfaceBounds = s.readInt(); if (numInterfaceBounds > 0) { additionalInterfaceBounds = new TypePattern[numInterfaceBounds]; for (int i = 0; i < additionalInterfaceBounds.length; i++) { additionalInterfaceBounds[i] = TypePattern.read(s, context); } } boolean hasLowerBound = s.readBoolean(); TypePattern lowerBound = null; if (hasLowerBound) { lowerBound = TypePattern.read(s, context); } tv = new TypeVariablePattern(name, upperBound, additionalInterfaceBounds, lowerBound); tv.readLocation(context, s); return tv; }
public static ResolvedTypeMunger readMethod(VersionedDataInputStream s, ISourceContext context, boolean isEnhanced) throws IOException { ResolvedMemberImpl signature = ResolvedMemberImpl.readResolvedMember(s, context); UnresolvedType aspect = UnresolvedType.read(s); String implClassName = s.readUTF(); TypePattern tp = TypePattern.read(s, context); MethodDelegateTypeMunger typeMunger = new MethodDelegateTypeMunger(signature, aspect, implClassName, tp); UnresolvedType fieldType = null; if (isEnhanced) { fieldType = UnresolvedType.read(s); } else { // a guess... that will work in a lot of cases fieldType = signature.getDeclaringType(); } typeMunger.setFieldType(fieldType); if (isEnhanced) { typeMunger.factoryMethodName = s.readUTF(); typeMunger.factoryMethodSignature = s.readUTF(); typeMunger.bitflags = s.readInt(); } return typeMunger; }