Initial commit

sources/org/aspectj/runtime/reflect/CodeSignatureImpl.java

@@ -0,0 +1,29 @@
+package org.aspectj.runtime.reflect;
+
+import org.aspectj.lang.reflect.CodeSignature;
+
+/* loaded from: classes2.dex */
+abstract class CodeSignatureImpl extends MemberSignatureImpl implements CodeSignature {
+    Class[] i;
+    Class[] j;
+
+    CodeSignatureImpl(int i, String str, Class cls, Class[] clsArr, String[] strArr, Class[] clsArr2) {
+        super(i, str, cls);
+        this.i = clsArr;
+        this.j = clsArr2;
+    }
+
+    public Class[] e() {
+        if (this.j == null) {
+            this.j = d(5);
+        }
+        return this.j;
+    }
+
+    public Class[] f() {
+        if (this.i == null) {
+            this.i = d(3);
+        }
+        return this.i;
+    }
+}

sources/org/aspectj/runtime/reflect/Factory.java

@@ -0,0 +1,110 @@
+package org.aspectj.runtime.reflect;
+
+import java.util.Hashtable;
+import java.util.StringTokenizer;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.Signature;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.aspectj.lang.reflect.SourceLocation;
+import org.aspectj.runtime.reflect.JoinPointImpl;
+
+/* loaded from: classes2.dex */
+public final class Factory {
+    static Hashtable e = new Hashtable();
+    private static Object[] f;
+    static /* synthetic */ Class g;
+    Class a;
+    ClassLoader b;
+    String c;
+    int d = 0;
+
+    static {
+        e.put("void", Void.TYPE);
+        e.put("boolean", Boolean.TYPE);
+        e.put("byte", Byte.TYPE);
+        e.put("char", Character.TYPE);
+        e.put("short", Short.TYPE);
+        e.put("int", Integer.TYPE);
+        e.put("long", Long.TYPE);
+        e.put("float", Float.TYPE);
+        e.put("double", Double.TYPE);
+        f = new Object[0];
+    }
+
+    public Factory(String str, Class cls) {
+        this.c = str;
+        this.a = cls;
+        this.b = cls.getClassLoader();
+    }
+
+    static Class a(String str, ClassLoader classLoader) {
+        if (str.equals("*")) {
+            return null;
+        }
+        Class cls = (Class) e.get(str);
+        if (cls != null) {
+            return cls;
+        }
+        try {
+            return classLoader == null ? Class.forName(str) : Class.forName(str, false, classLoader);
+        } catch (ClassNotFoundException unused) {
+            Class cls2 = g;
+            if (cls2 != null) {
+                return cls2;
+            }
+            Class a = a("java.lang.ClassNotFoundException");
+            g = a;
+            return a;
+        }
+    }
+
+    static /* synthetic */ Class a(String str) {
+        try {
+            return Class.forName(str);
+        } catch (ClassNotFoundException e2) {
+            throw new NoClassDefFoundError(e2.getMessage());
+        }
+    }
+
+    public JoinPoint.StaticPart a(String str, Signature signature, int i) {
+        int i2 = this.d;
+        this.d = i2 + 1;
+        return new JoinPointImpl.StaticPartImpl(i2, str, signature, a(i, -1));
+    }
+
+    public static JoinPoint a(JoinPoint.StaticPart staticPart, Object obj, Object obj2) {
+        return new JoinPointImpl(staticPart, obj, obj2, f);
+    }
+
+    public static JoinPoint a(JoinPoint.StaticPart staticPart, Object obj, Object obj2, Object obj3) {
+        return new JoinPointImpl(staticPart, obj, obj2, new Object[]{obj3});
+    }
+
+    public MethodSignature a(String str, String str2, String str3, String str4, String str5, String str6, String str7) {
+        int parseInt = Integer.parseInt(str, 16);
+        Class a = a(str3, this.b);
+        StringTokenizer stringTokenizer = new StringTokenizer(str4, ":");
+        int countTokens = stringTokenizer.countTokens();
+        Class[] clsArr = new Class[countTokens];
+        for (int i = 0; i < countTokens; i++) {
+            clsArr[i] = a(stringTokenizer.nextToken(), this.b);
+        }
+        StringTokenizer stringTokenizer2 = new StringTokenizer(str5, ":");
+        int countTokens2 = stringTokenizer2.countTokens();
+        String[] strArr = new String[countTokens2];
+        for (int i2 = 0; i2 < countTokens2; i2++) {
+            strArr[i2] = stringTokenizer2.nextToken();
+        }
+        StringTokenizer stringTokenizer3 = new StringTokenizer(str6, ":");
+        int countTokens3 = stringTokenizer3.countTokens();
+        Class[] clsArr2 = new Class[countTokens3];
+        for (int i3 = 0; i3 < countTokens3; i3++) {
+            clsArr2[i3] = a(stringTokenizer3.nextToken(), this.b);
+        }
+        return new MethodSignatureImpl(parseInt, str2, a, clsArr, strArr, clsArr2, a(str7, this.b));
+    }
+
+    public SourceLocation a(int i, int i2) {
+        return new SourceLocationImpl(this.a, this.c, i);
+    }
+}

sources/org/aspectj/runtime/reflect/JoinPointImpl.java

@@ -0,0 +1,113 @@
+package org.aspectj.runtime.reflect;
+
+import com.ijm.dataencryption.de.DataDecryptTool;
+import com.ubt.jimu.base.util.FileUtil;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.Signature;
+import org.aspectj.lang.reflect.SourceLocation;
+import org.aspectj.runtime.internal.AroundClosure;
+
+/* loaded from: classes2.dex */
+class JoinPointImpl implements ProceedingJoinPoint {
+    Object[] a;
+    JoinPoint.StaticPart b;
+    private AroundClosure c;
+
+    static class StaticPartImpl implements JoinPoint.StaticPart {
+        String a;
+        Signature b;
+
+        public StaticPartImpl(int i, String str, Signature signature, SourceLocation sourceLocation) {
+            this.a = str;
+            this.b = signature;
+        }
+
+        public String a() {
+            return this.a;
+        }
+
+        public Signature b() {
+            return this.b;
+        }
+
+        @Override // org.aspectj.lang.JoinPoint.StaticPart
+        public final String toString() {
+            return a(StringMaker.k);
+        }
+
+        String a(StringMaker stringMaker) {
+            StringBuffer stringBuffer = new StringBuffer();
+            stringBuffer.append(stringMaker.a(a()));
+            stringBuffer.append("(");
+            stringBuffer.append(((SignatureImpl) b()).b(stringMaker));
+            stringBuffer.append(")");
+            return stringBuffer.toString();
+        }
+    }
+
+    public JoinPointImpl(JoinPoint.StaticPart staticPart, Object obj, Object obj2, Object[] objArr) {
+        this.b = staticPart;
+        this.a = objArr;
+    }
+
+    @Override // org.aspectj.lang.JoinPoint
+    public Object[] a() {
+        if (this.a == null) {
+            this.a = new Object[0];
+        }
+        Object[] objArr = this.a;
+        Object[] objArr2 = new Object[objArr.length];
+        System.arraycopy(objArr, 0, objArr2, 0, objArr.length);
+        return objArr2;
+    }
+
+    public final String toString() {
+        return this.b.toString();
+    }
+
+    @Override // org.aspectj.lang.ProceedingJoinPoint
+    public void a(AroundClosure aroundClosure) {
+        this.c = aroundClosure;
+    }
+
+    @Override // org.aspectj.lang.ProceedingJoinPoint
+    public Object a(Object[] objArr) throws Throwable {
+        int i;
+        AroundClosure aroundClosure = this.c;
+        if (aroundClosure == null) {
+            return null;
+        }
+        int flags = aroundClosure.getFlags();
+        int i2 = 1048576 & flags;
+        boolean z = (65536 & flags) != 0;
+        int i3 = (flags & FileUtil.ZIP_BUFFER_SIZE) != 0 ? 1 : 0;
+        int i4 = (flags & DataDecryptTool.DECRYPT_ALL_FILE) != 0 ? 1 : 0;
+        boolean z2 = (flags & 16) != 0;
+        boolean z3 = (flags & 1) != 0;
+        Object[] state = this.c.getState();
+        int i5 = i3 + 0 + ((!z2 || z) ? 0 : 1);
+        if (i3 == 0 || i4 == 0) {
+            i = 0;
+        } else {
+            state[0] = objArr[0];
+            i = 1;
+        }
+        if (z2 && z3) {
+            if (z) {
+                i = i4 + 1;
+                state[0] = objArr[i4];
+            } else {
+                char c = (i3 == 0 || i4 == 0) ? (char) 0 : (char) 1;
+                int i6 = (i3 == 0 || i4 == 0) ? 0 : 1;
+                int i7 = (z2 && z3 && !z) ? 1 : 0;
+                state[i3] = objArr[c];
+                i = i6 + i7;
+            }
+        }
+        for (int i8 = i; i8 < objArr.length; i8++) {
+            state[(i8 - i) + i5] = objArr[i8];
+        }
+        return this.c.run(state);
+    }
+}

sources/org/aspectj/runtime/reflect/MemberSignatureImpl.java

@@ -0,0 +1,10 @@
+package org.aspectj.runtime.reflect;
+
+import org.aspectj.lang.reflect.MemberSignature;
+
+/* loaded from: classes2.dex */
+abstract class MemberSignatureImpl extends SignatureImpl implements MemberSignature {
+    MemberSignatureImpl(int i, String str, Class cls) {
+        super(i, str, cls);
+    }
+}

sources/org/aspectj/runtime/reflect/MethodSignatureImpl.java

@@ -0,0 +1,38 @@
+package org.aspectj.runtime.reflect;
+
+import org.aspectj.lang.reflect.MethodSignature;
+
+/* loaded from: classes2.dex */
+class MethodSignatureImpl extends CodeSignatureImpl implements MethodSignature {
+    Class k;
+
+    MethodSignatureImpl(int i, String str, Class cls, Class[] clsArr, String[] strArr, Class[] clsArr2, Class cls2) {
+        super(i, str, cls, clsArr, strArr, clsArr2);
+        this.k = cls2;
+    }
+
+    @Override // org.aspectj.runtime.reflect.SignatureImpl
+    protected String a(StringMaker stringMaker) {
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append(stringMaker.a(c()));
+        if (stringMaker.b) {
+            stringBuffer.append(stringMaker.a(g()));
+        }
+        if (stringMaker.b) {
+            stringBuffer.append(" ");
+        }
+        stringBuffer.append(stringMaker.a(a(), b()));
+        stringBuffer.append(".");
+        stringBuffer.append(d());
+        stringMaker.a(stringBuffer, f());
+        stringMaker.b(stringBuffer, e());
+        return stringBuffer.toString();
+    }
+
+    public Class g() {
+        if (this.k == null) {
+            this.k = c(6);
+        }
+        return this.k;
+    }
+}

sources/org/aspectj/runtime/reflect/SignatureImpl.java

@@ -0,0 +1,185 @@
+package org.aspectj.runtime.reflect;
+
+import java.lang.ref.SoftReference;
+import java.util.StringTokenizer;
+import org.aspectj.lang.Signature;
+
+/* loaded from: classes2.dex */
+abstract class SignatureImpl implements Signature {
+    private static boolean h = true;
+    int a;
+    String b;
+    String c;
+    Class d;
+    Cache e;
+    private String f;
+    ClassLoader g = null;
+
+    private interface Cache {
+        void a(int i, String str);
+
+        String get(int i);
+    }
+
+    SignatureImpl(int i, String str, Class cls) {
+        this.a = -1;
+        this.a = i;
+        this.b = str;
+        this.d = cls;
+    }
+
+    private ClassLoader e() {
+        if (this.g == null) {
+            this.g = getClass().getClassLoader();
+        }
+        return this.g;
+    }
+
+    public Class a() {
+        if (this.d == null) {
+            this.d = c(2);
+        }
+        return this.d;
+    }
+
+    protected abstract String a(StringMaker stringMaker);
+
+    /* JADX WARN: Removed duplicated region for block: B:10:0x0026  */
+    /* JADX WARN: Removed duplicated region for block: B:7:0x001e  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    java.lang.String b(org.aspectj.runtime.reflect.StringMaker r3) {
+        /*
+            r2 = this;
+            boolean r0 = org.aspectj.runtime.reflect.SignatureImpl.h
+            if (r0 == 0) goto L1b
+            org.aspectj.runtime.reflect.SignatureImpl$Cache r0 = r2.e
+            if (r0 != 0) goto L14
+            org.aspectj.runtime.reflect.SignatureImpl$CacheImpl r0 = new org.aspectj.runtime.reflect.SignatureImpl$CacheImpl     // Catch: java.lang.Throwable -> L10
+            r0.<init>()     // Catch: java.lang.Throwable -> L10
+            r2.e = r0     // Catch: java.lang.Throwable -> L10
+            goto L1b
+        L10:
+            r0 = 0
+            org.aspectj.runtime.reflect.SignatureImpl.h = r0
+            goto L1b
+        L14:
+            int r1 = r3.i
+            java.lang.String r0 = r0.get(r1)
+            goto L1c
+        L1b:
+            r0 = 0
+        L1c:
+            if (r0 != 0) goto L22
+            java.lang.String r0 = r2.a(r3)
+        L22:
+            boolean r1 = org.aspectj.runtime.reflect.SignatureImpl.h
+            if (r1 == 0) goto L2d
+            org.aspectj.runtime.reflect.SignatureImpl$Cache r1 = r2.e
+            int r3 = r3.i
+            r1.a(r3, r0)
+        L2d:
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: org.aspectj.runtime.reflect.SignatureImpl.b(org.aspectj.runtime.reflect.StringMaker):java.lang.String");
+    }
+
+    public int c() {
+        if (this.a == -1) {
+            this.a = a(0);
+        }
+        return this.a;
+    }
+
+    public String d() {
+        if (this.b == null) {
+            this.b = b(1);
+        }
+        return this.b;
+    }
+
+    public final String toString() {
+        return b(StringMaker.k);
+    }
+
+    private static final class CacheImpl implements Cache {
+        private SoftReference a;
+
+        public CacheImpl() {
+            b();
+        }
+
+        private String[] b() {
+            String[] strArr = new String[3];
+            this.a = new SoftReference(strArr);
+            return strArr;
+        }
+
+        @Override // org.aspectj.runtime.reflect.SignatureImpl.Cache
+        public void a(int i, String str) {
+            String[] a = a();
+            if (a == null) {
+                a = b();
+            }
+            a[i] = str;
+        }
+
+        @Override // org.aspectj.runtime.reflect.SignatureImpl.Cache
+        public String get(int i) {
+            String[] a = a();
+            if (a == null) {
+                return null;
+            }
+            return a[i];
+        }
+
+        private String[] a() {
+            return (String[]) this.a.get();
+        }
+    }
+
+    int a(int i) {
+        return Integer.parseInt(b(i), 16);
+    }
+
+    Class c(int i) {
+        return Factory.a(b(i), e());
+    }
+
+    Class[] d(int i) {
+        StringTokenizer stringTokenizer = new StringTokenizer(b(i), ":");
+        int countTokens = stringTokenizer.countTokens();
+        Class[] clsArr = new Class[countTokens];
+        for (int i2 = 0; i2 < countTokens; i2++) {
+            clsArr[i2] = Factory.a(stringTokenizer.nextToken(), e());
+        }
+        return clsArr;
+    }
+
+    public String b() {
+        if (this.c == null) {
+            this.c = a().getName();
+        }
+        return this.c;
+    }
+
+    String b(int i) {
+        int indexOf = this.f.indexOf(45);
+        int i2 = 0;
+        while (true) {
+            int i3 = i - 1;
+            if (i <= 0) {
+                break;
+            }
+            i2 = indexOf + 1;
+            indexOf = this.f.indexOf(45, i2);
+            i = i3;
+        }
+        if (indexOf == -1) {
+            indexOf = this.f.length();
+        }
+        return this.f.substring(i2, indexOf);
+    }
+}

sources/org/aspectj/runtime/reflect/SourceLocationImpl.java

@@ -0,0 +1,30 @@
+package org.aspectj.runtime.reflect;
+
+import org.aspectj.lang.reflect.SourceLocation;
+
+/* loaded from: classes2.dex */
+class SourceLocationImpl implements SourceLocation {
+    String a;
+    int b;
+
+    SourceLocationImpl(Class cls, String str, int i) {
+        this.a = str;
+        this.b = i;
+    }
+
+    public String a() {
+        return this.a;
+    }
+
+    public int b() {
+        return this.b;
+    }
+
+    public String toString() {
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append(a());
+        stringBuffer.append(":");
+        stringBuffer.append(b());
+        return stringBuffer.toString();
+    }
+}

sources/org/aspectj/runtime/reflect/StringMaker.java

@@ -0,0 +1,135 @@
+package org.aspectj.runtime.reflect;
+
+import java.lang.reflect.Modifier;
+
+/* loaded from: classes2.dex */
+class StringMaker {
+    static StringMaker j = new StringMaker();
+    static StringMaker k;
+    static StringMaker l;
+    boolean a = true;
+    boolean b = true;
+    boolean c = false;
+    boolean d = false;
+    boolean e = false;
+    boolean f;
+    boolean g;
+    boolean h;
+    int i;
+
+    static {
+        StringMaker stringMaker = j;
+        stringMaker.a = true;
+        stringMaker.b = false;
+        stringMaker.c = false;
+        stringMaker.d = false;
+        stringMaker.e = true;
+        stringMaker.f = false;
+        stringMaker.g = false;
+        stringMaker.i = 0;
+        k = new StringMaker();
+        StringMaker stringMaker2 = k;
+        stringMaker2.a = true;
+        stringMaker2.b = true;
+        stringMaker2.c = false;
+        stringMaker2.d = false;
+        stringMaker2.e = false;
+        j.i = 1;
+        l = new StringMaker();
+        StringMaker stringMaker3 = l;
+        stringMaker3.a = false;
+        stringMaker3.b = true;
+        stringMaker3.c = false;
+        stringMaker3.d = true;
+        stringMaker3.e = false;
+        stringMaker3.h = false;
+        stringMaker3.i = 2;
+    }
+
+    StringMaker() {
+    }
+
+    String a(String str) {
+        int lastIndexOf = str.lastIndexOf(45);
+        return lastIndexOf == -1 ? str : str.substring(lastIndexOf + 1);
+    }
+
+    String b(String str) {
+        int lastIndexOf = str.lastIndexOf(46);
+        return lastIndexOf == -1 ? str : str.substring(lastIndexOf + 1);
+    }
+
+    public void c(StringBuffer stringBuffer, Class[] clsArr) {
+        for (int i = 0; i < clsArr.length; i++) {
+            if (i > 0) {
+                stringBuffer.append(", ");
+            }
+            stringBuffer.append(a(clsArr[i]));
+        }
+    }
+
+    String a(int i) {
+        if (!this.d) {
+            return "";
+        }
+        String modifier = Modifier.toString(i);
+        if (modifier.length() == 0) {
+            return "";
+        }
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append(modifier);
+        stringBuffer.append(" ");
+        return stringBuffer.toString();
+    }
+
+    public void b(StringBuffer stringBuffer, Class[] clsArr) {
+        if (!this.c || clsArr == null || clsArr.length == 0) {
+            return;
+        }
+        stringBuffer.append(" throws ");
+        c(stringBuffer, clsArr);
+    }
+
+    String a(Class cls, String str, boolean z) {
+        if (cls == null) {
+            return "ANONYMOUS";
+        }
+        if (!cls.isArray()) {
+            if (z) {
+                return b(str).replace('$', '.');
+            }
+            return str.replace('$', '.');
+        }
+        Class<?> componentType = cls.getComponentType();
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append(a(componentType, componentType.getName(), z));
+        stringBuffer.append("[]");
+        return stringBuffer.toString();
+    }
+
+    public String a(Class cls) {
+        return a(cls, cls.getName(), this.a);
+    }
+
+    public String a(Class cls, String str) {
+        return a(cls, str, this.e);
+    }
+
+    public void a(StringBuffer stringBuffer, Class[] clsArr) {
+        if (clsArr == null) {
+            return;
+        }
+        if (!this.b) {
+            if (clsArr.length == 0) {
+                stringBuffer.append("()");
+                return;
+            } else {
+                stringBuffer.append("(..)");
+                return;
+            }
+        }
+        stringBuffer.append("(");
+        c(stringBuffer, clsArr);
+        stringBuffer.append(")");
+    }
+}