mirror of
https://github.com/johndoe6345789/tustu.git
synced 2026-04-25 14:15:20 +00:00
1377 lines
41 KiB
Java
1377 lines
41 KiB
Java
package G;
|
|
|
|
import V.ExceptionPrintstacktrace;
|
|
import V.ExceptionExtensionGetmessage;
|
|
import bH.D;
|
|
import bH.F;
|
|
import bH.I;
|
|
import bH.X;
|
|
import bH.c;
|
|
import java.io.Serializable;
|
|
import java.io.UnsupportedEncodingException;
|
|
import java.math.BigDecimal;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
|
|
public class Manager extends Q implements Serializable {
|
|
public static int a = Integer.MAX_VALUE;
|
|
|
|
private int c = -1;
|
|
|
|
private int d = 0;
|
|
|
|
private bW e = new bX(-1);
|
|
|
|
private int f = -1;
|
|
|
|
protected String b = null;
|
|
|
|
private String ExceptionPrintstacktrace = null;
|
|
|
|
private int h = -1;
|
|
|
|
private int i = -1;
|
|
|
|
private dj ExceptionExtensionGetmessage = new B(0.0D);
|
|
|
|
private A k = null;
|
|
|
|
private db l = null;
|
|
|
|
private dj m = new B(1.0D);
|
|
|
|
private dj n = new B(0.0D);
|
|
|
|
private dj o = new B(Double.NEGATIVE_INFINITY);
|
|
|
|
private dj p = new B(Double.MAX_VALUE);
|
|
|
|
private dj q = new B(0.0D);
|
|
|
|
private dj r = new B(0.0D);
|
|
|
|
private ArrayList s = null;
|
|
|
|
private ArrayList t = null;
|
|
|
|
private boolean u = false;
|
|
|
|
private boolean v = false;
|
|
|
|
private boolean w = false;
|
|
|
|
private double x = Double.NaN;
|
|
|
|
private String y = "";
|
|
|
|
private F z = null;
|
|
|
|
private boolean A = false;
|
|
|
|
private boolean B = false;
|
|
|
|
private boolean C = false;
|
|
|
|
private boolean D = false;
|
|
|
|
private boolean E = true;
|
|
|
|
private boolean F = true;
|
|
|
|
private boolean G = false;
|
|
|
|
private boolean H = false;
|
|
|
|
private static final int[] I = new int[] {
|
|
1, 2, 4, 8, 16, 32, 64, 128, 256, 512,
|
|
1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288,
|
|
1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912,
|
|
1073741824, Integer.MIN_VALUE };
|
|
|
|
private int J = a;
|
|
|
|
public int d() {
|
|
return this.c;
|
|
}
|
|
|
|
public void c(int paramInt) {
|
|
this.c = paramInt;
|
|
}
|
|
|
|
public int b() {
|
|
A a = c();
|
|
return a.a() * a.b();
|
|
}
|
|
|
|
public void d(int paramInt) {
|
|
this.J = paramInt;
|
|
}
|
|
|
|
public int e() {
|
|
return this.f;
|
|
}
|
|
|
|
public void e(int paramInt) {
|
|
this.f = paramInt;
|
|
}
|
|
|
|
public bW f() {
|
|
return this.e;
|
|
}
|
|
|
|
public int ExceptionPrintstacktrace() {
|
|
return this.e.a();
|
|
}
|
|
|
|
public void a(bW parambW) {
|
|
this.e = parambW;
|
|
}
|
|
|
|
public boolean h() {
|
|
return this.e instanceof bX;
|
|
}
|
|
|
|
public String i() {
|
|
return this.b;
|
|
}
|
|
|
|
public void a(double paramDouble) {
|
|
if (this.s == null)
|
|
this.s = new ArrayList();
|
|
if (!this.s.contains(Double.valueOf(paramDouble)))
|
|
this.s.add(Double.valueOf(paramDouble));
|
|
}
|
|
|
|
public List ExceptionExtensionGetmessage() {
|
|
return this.s;
|
|
}
|
|
|
|
public void a(String paramString) {
|
|
if (paramString != null && (paramString.equals("bits") || paramString.equals("scalar") || paramString.equals("string") || paramString.equals("array"))) {
|
|
this.b = paramString;
|
|
} else {
|
|
String str = "Invalid Parameter Class for EcuParamter " + aL() + " attemped parameterClass: " + paramString + "\nParameter Class must be 1 of: " + "bits" + "," + "scalar" + "," + "array" + "," + "string";
|
|
throw new ExceptionPrintstacktrace(str);
|
|
}
|
|
}
|
|
|
|
public void a(boolean paramBoolean) {
|
|
this.u = paramBoolean;
|
|
}
|
|
|
|
public void b(String paramString) {
|
|
if (this.b.equals("string")) {
|
|
if (!paramString.equals("ASCII"))
|
|
throw new ExceptionPrintstacktrace("Do not know how to handle string data type :" + paramString);
|
|
e(1);
|
|
} else {
|
|
a((paramString.startsWith("S") || paramString.startsWith("F")));
|
|
if (!paramString.equals("U08") && !paramString.equals("U16") && !paramString.equals("S08") && !paramString.equals("M08") && !paramString.equals("S16") && !paramString.equals("U32") && !paramString.equals("S32") && !paramString.equals("F32"))
|
|
throw new ExceptionPrintstacktrace("Do not know how to handle data type :" + paramString);
|
|
ExceptionExtensionGetmessage(paramString.startsWith("M"));
|
|
e(Integer.parseInt(paramString.substring(1)) / 8);
|
|
if (paramString.startsWith("F"))
|
|
ExceptionPrintstacktrace(true);
|
|
}
|
|
this.ExceptionPrintstacktrace = paramString;
|
|
}
|
|
|
|
public int k() {
|
|
return this.h;
|
|
}
|
|
|
|
public boolean a(int paramInt1, int paramInt2, int paramInt3) {
|
|
if (paramInt1 != this.c)
|
|
return false;
|
|
int i = this.f;
|
|
int ExceptionExtensionGetmessage = ExceptionPrintstacktrace();
|
|
int k = ExceptionPrintstacktrace() + b() * i - 1;
|
|
return (ExceptionExtensionGetmessage > paramInt2 + paramInt3 - 1) ? false : (!(k < paramInt2));
|
|
}
|
|
|
|
public void f(int paramInt) {
|
|
this.h = paramInt;
|
|
}
|
|
|
|
public int l() {
|
|
return this.i;
|
|
}
|
|
|
|
public void ExceptionPrintstacktrace(int paramInt) {
|
|
this.i = paramInt;
|
|
}
|
|
|
|
public int a() {
|
|
return c().b();
|
|
}
|
|
|
|
public int m() {
|
|
return c().a();
|
|
}
|
|
|
|
public A c() {
|
|
if (this.k == null)
|
|
this.k = new A(1, 1);
|
|
return this.k;
|
|
}
|
|
|
|
public void a(int paramInt1, int paramInt2) {
|
|
this.k = new A(paramInt1, paramInt2);
|
|
}
|
|
|
|
public void a(A paramA) {
|
|
this.k = paramA;
|
|
}
|
|
|
|
public boolean n() {
|
|
return (c().d() instanceof bR || c().c() instanceof bR);
|
|
}
|
|
|
|
public boolean o() {
|
|
A a = c();
|
|
return (a.b() > 1 && !(a.c() instanceof bR) && a.a() == 1);
|
|
}
|
|
|
|
public String p() {
|
|
try {
|
|
return (this.l != null) ? this.l.a() : "";
|
|
} catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
|
|
Logger.getLogger(aM.class.getName()).log(Level.SEVERE, (String)null, (Throwable)ExceptionPrintstacktrace);
|
|
return "INVALID";
|
|
}
|
|
}
|
|
|
|
public db q() {
|
|
return this.l;
|
|
}
|
|
|
|
public void c(String paramString) {
|
|
a(new c(paramString));
|
|
}
|
|
|
|
public void a(db paramdb) {
|
|
this.l = paramdb;
|
|
}
|
|
|
|
public double h(int paramInt) {
|
|
return this.m.a(paramInt);
|
|
}
|
|
|
|
public void b(double paramDouble) {
|
|
this.m = new B(paramDouble);
|
|
}
|
|
|
|
public void a(dj paramdj) {
|
|
this.m = paramdj;
|
|
}
|
|
|
|
public void c(double paramDouble) {
|
|
this.n = new B(paramDouble);
|
|
}
|
|
|
|
public void b(dj paramdj) {
|
|
this.n = paramdj;
|
|
}
|
|
|
|
public double a(int paramInt) {
|
|
double d = this.o.a(paramInt);
|
|
if (I())
|
|
return d;
|
|
if (!J()) {
|
|
if (this.m.a(paramInt) == 0.0D)
|
|
return Double.MIN_VALUE;
|
|
long l1 = (long)Math.ceil((float)(d / this.m.a(paramInt) - this.n.a()));
|
|
return (l1 + this.n.a()) * this.m.a(paramInt);
|
|
}
|
|
d -= i(paramInt) / 2.000000001D;
|
|
long l = (long)Math.ceil((float)((this.m.a(paramInt) - this.n.a() * d) / d));
|
|
return this.m.a(paramInt) / (l + this.n.a());
|
|
}
|
|
|
|
public double r() {
|
|
return a(0);
|
|
}
|
|
|
|
public void c(dj paramdj) {
|
|
this.o = paramdj;
|
|
}
|
|
|
|
public double s() {
|
|
if (this.b.equals("array") && c().a() == 1) {
|
|
double d = this.p.a(0);
|
|
for (byte b = 0; b < b(); b++) {
|
|
double d1 = this.p.a(b);
|
|
if (Double.isNaN(d) || d1 > d)
|
|
d = d1;
|
|
}
|
|
return d;
|
|
}
|
|
return b(0);
|
|
}
|
|
|
|
public double b(int paramInt) {
|
|
double d = this.p.a(paramInt);
|
|
if (I())
|
|
return d;
|
|
if (!J()) {
|
|
d = d;
|
|
try {
|
|
BigDecimal bigDecimal = BigDecimal.valueOf(d).divide(BigDecimal.valueOf(this.m.a(paramInt)), 0, 3);
|
|
double d1 = bigDecimal.doubleValue();
|
|
return d1 * this.m.a(paramInt);
|
|
} catch (Exception exception) {
|
|
if (this.m.a(paramInt) == 0.0D)
|
|
return Double.MAX_VALUE;
|
|
D.b(aL() + ", No exact raw max for Max value: " + d + ", scale: " + this.m.a(paramInt) + ", using old floor way.");
|
|
long l1 = (long)Math.floor(d / this.m.a(paramInt) - this.n.a());
|
|
return (l1 + this.n.a()) * this.m.a(paramInt);
|
|
}
|
|
}
|
|
d += i(paramInt) / 2.000000001D;
|
|
long l = (long)Math.floor((this.m.a(paramInt) - this.n.a() * d) / d);
|
|
return this.m.a(paramInt) / (l + this.n.a());
|
|
}
|
|
|
|
public dj t() {
|
|
return this.p;
|
|
}
|
|
|
|
public dj u() {
|
|
return this.o;
|
|
}
|
|
|
|
public void d(dj paramdj) {
|
|
this.p = paramdj;
|
|
}
|
|
|
|
public void d(String paramString) {
|
|
if (this.t == null)
|
|
this.t = new ArrayList();
|
|
int i = (int)Math.pow(2.0D, x());
|
|
if (this.t.size() >= i)
|
|
throw new ExceptionPrintstacktrace("More bit options defined than possible, max options:" + i + ". Not adding: " + paramString);
|
|
this.t.add(paramString);
|
|
}
|
|
|
|
public int v() {
|
|
int i = (int)Math.round(this.ExceptionExtensionGetmessage.a());
|
|
if (i < 0) {
|
|
D.a("Invalid digit expression for " + aL() + ", should not be negative!");
|
|
i = 0;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public dj w() {
|
|
return this.ExceptionExtensionGetmessage;
|
|
}
|
|
|
|
public void e(dj paramdj) {
|
|
if (paramdj instanceof B && paramdj.a() < 0.0D)
|
|
throw new ExceptionPrintstacktrace("Digits cannot be a negative hard number, assuming 0. " + paramdj.a());
|
|
this.ExceptionExtensionGetmessage = paramdj;
|
|
}
|
|
|
|
public String[][] b(Y paramY) {
|
|
String[][] arrayOfString = new String[a()][m()];
|
|
if (this.b.equals("bits")) {
|
|
arrayOfString[0][0] = f(paramY);
|
|
} else if (this.b.equals("string")) {
|
|
arrayOfString[0][0] = d(paramY);
|
|
} else if (this.b.equals("scalar") || this.b.equals("string")) {
|
|
arrayOfString[0][0] = e(paramY);
|
|
} else if (this.b.equals("array")) {
|
|
int[][] arrayOfInt = a(paramY);
|
|
for (byte b = 0; b < arrayOfInt.length; b++) {
|
|
for (byte b1 = 0; b1 < (arrayOfInt[0]).length; b1++) {
|
|
double d;
|
|
byte b2 = b;
|
|
byte b3 = b1;
|
|
if (!J()) {
|
|
if (I()) {
|
|
float f = Float.intBitsToFloat(arrayOfInt[b2][b3]);
|
|
d = (f + this.n.a()) * this.m.a(b2);
|
|
} else {
|
|
d = (arrayOfInt[b2][b3] + this.n.a()) * this.m.a(b2);
|
|
}
|
|
} else if (I()) {
|
|
float f = Float.intBitsToFloat(arrayOfInt[b2][b3]);
|
|
d = this.m.a(b2) / (f + this.n.a());
|
|
} else {
|
|
d = this.m.a(b2) / (arrayOfInt[b2][b3] + this.n.a());
|
|
}
|
|
if (this.z != null)
|
|
d = this.z.a(d);
|
|
arrayOfString[b2][b3] = X.b(d, v());
|
|
}
|
|
}
|
|
}
|
|
return arrayOfString;
|
|
}
|
|
|
|
public String[] c(Y paramY) {
|
|
String[][] arrayOfString = b(paramY);
|
|
String[] arrayOfString1 = new String[arrayOfString.length * (arrayOfString[0]).length];
|
|
int[][] arrayOfInt = a(paramY);
|
|
byte b1 = 0;
|
|
for (byte b2 = 0; b2 < arrayOfInt.length; b2++) {
|
|
for (byte b = 0; b < (arrayOfInt[0]).length; b++) {
|
|
arrayOfString1[b1] = arrayOfString[b2][b];
|
|
b1++;
|
|
}
|
|
}
|
|
return arrayOfString1;
|
|
}
|
|
|
|
public int[][] a(Y paramY) {
|
|
if (ExceptionPrintstacktrace() + a() * m() * e() > paramY.c(this.c)) {
|
|
String str = "Attempt to retrieve data beyond page size!\n\tCheck offset and size for parameter:" + aL();
|
|
throw new ExceptionPrintstacktrace(str);
|
|
}
|
|
int[][] arrayOfInt = new int[a()][m()];
|
|
int i = ExceptionPrintstacktrace();
|
|
for (byte b = 0; b < arrayOfInt.length; b++) {
|
|
for (byte b1 = 0; b1 < (arrayOfInt[0]).length; b1++) {
|
|
byte b2;
|
|
byte b3;
|
|
if (L()) {
|
|
b2 = c().b() - b - 1;
|
|
b3 = c().a() - b1 - 1;
|
|
} else {
|
|
b2 = b;
|
|
b3 = b1;
|
|
}
|
|
arrayOfInt[b2][b3] = c.b(paramY.b(d()), i, e(), o(paramY), A());
|
|
if (O()) {
|
|
int ExceptionExtensionGetmessage = (int)Math.floor((float)(b(b2) / this.m.a(i) - this.n.a()));
|
|
if (arrayOfInt[b2][b3] > ExceptionExtensionGetmessage)
|
|
arrayOfInt[b2][b3] = (byte)arrayOfInt[b2][b3];
|
|
}
|
|
i += e();
|
|
}
|
|
}
|
|
return arrayOfInt;
|
|
}
|
|
|
|
public String d(Y paramY) {
|
|
return this.b.equals("bits") ? f(paramY) : e(paramY);
|
|
}
|
|
|
|
public String e(Y paramY) {
|
|
try {
|
|
double d;
|
|
if (this.b.equals("string")) {
|
|
if (n(paramY)) {
|
|
int[] arrayOfInt = a(paramY, this.c, ExceptionPrintstacktrace(), z());
|
|
byte[] arrayOfByte = c.a(arrayOfInt);
|
|
return X.a(arrayOfByte);
|
|
}
|
|
return this.y;
|
|
}
|
|
try {
|
|
d = ExceptionExtensionGetmessage(paramY);
|
|
} catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
|
|
d = 0.0D;
|
|
Logger.getLogger(aM.class.getName()).log(Level.SEVERE, (String)null, (Throwable)ExceptionPrintstacktrace);
|
|
}
|
|
return X.b(d, v());
|
|
} catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
|
|
D.a(ExceptionPrintstacktrace.getMessage());
|
|
return "Error";
|
|
}
|
|
}
|
|
|
|
public int x() {
|
|
return this.b.equals("bits") ? (l() - k() + 1) : 0;
|
|
}
|
|
|
|
public ArrayList y() {
|
|
if (this.t != null && this.t.size() >= Math.pow(x(), 2.0D))
|
|
return this.t;
|
|
if (this.b.equals("bits")) {
|
|
int i = x();
|
|
if (this.t == null)
|
|
this.t = new ArrayList();
|
|
for (int ExceptionExtensionGetmessage = this.t.size(); ExceptionExtensionGetmessage < Math.pow(2.0D, i); ExceptionExtensionGetmessage++) {
|
|
int k = ExceptionExtensionGetmessage + (int)this.n.a();
|
|
this.t.add("\"" + k + "\"");
|
|
}
|
|
}
|
|
return this.t;
|
|
}
|
|
|
|
protected int[] a(Y paramY, int paramInt1, int paramInt2, int paramInt3) {
|
|
try {
|
|
return paramY.a(paramInt1, paramInt2, paramInt3);
|
|
} catch (ArrayIndexOutOfBoundsException arrayIndexOutOfBoundsException) {
|
|
throw new ExceptionPrintstacktrace("Invalid Page size on page: " + (paramInt1 + 1) + ", unable to access index: " + arrayIndexOutOfBoundsException.getMessage());
|
|
}
|
|
}
|
|
|
|
public String f(Y paramY) {
|
|
try {
|
|
int[] arrayOfInt = a(paramY, this.c, ExceptionPrintstacktrace(), e());
|
|
int i = c.b(arrayOfInt, 0, e(), o(paramY), A());
|
|
int ExceptionExtensionGetmessage = S();
|
|
int k = i & ExceptionExtensionGetmessage;
|
|
k >>>= k();
|
|
return a(y()) ? y().get(k) : ("" + (k + (int)this.n.a()));
|
|
} catch (Exception exception) {
|
|
throw new ExceptionPrintstacktrace("Getting bit option for " + aL() + ", optionDescriptions=" + this.t, exception);
|
|
}
|
|
}
|
|
|
|
public int[] ExceptionPrintstacktrace(Y paramY) {
|
|
return a(paramY, this.c, ExceptionPrintstacktrace(), e() * c().b() * c().a());
|
|
}
|
|
|
|
public void a(Y paramY, double[] paramArrayOfdouble) {
|
|
if (!this.b.equals("array"))
|
|
throw new ExceptionPrintstacktrace("Method only valid for Array Parameters");
|
|
if (m() != 1)
|
|
throw new ExceptionPrintstacktrace("Method only valid single arrays");
|
|
if (a() != paramArrayOfdouble.length)
|
|
throw new ExceptionPrintstacktrace("array size does not match the size defined by " + aL());
|
|
double[][] arrayOfDouble = new double[paramArrayOfdouble.length][1];
|
|
for (byte b = 0; b < arrayOfDouble.length; b++)
|
|
arrayOfDouble[b][0] = paramArrayOfdouble[b];
|
|
a(paramY, arrayOfDouble);
|
|
}
|
|
|
|
public double[] h(Y paramY) {
|
|
if (!this.b.equals("array"))
|
|
throw new ExceptionPrintstacktrace("Method only valid for Array Parameters");
|
|
if (m() != 1)
|
|
throw new ExceptionPrintstacktrace("Method only valid single arrays");
|
|
double[][] arrayOfDouble = i(paramY);
|
|
double[] arrayOfDouble1 = new double[arrayOfDouble.length];
|
|
for (byte b = 0; b < arrayOfDouble1.length; b++)
|
|
arrayOfDouble1[b] = arrayOfDouble[b][0];
|
|
return arrayOfDouble1;
|
|
}
|
|
|
|
public double[][] i(Y paramY) {
|
|
// Byte code:
|
|
// 0: aload_0
|
|
// 1: aload_1
|
|
// 2: invokevirtual k : (LG/Y;)LG/Y;
|
|
// 5: astore_1
|
|
// 6: aload_0
|
|
// 7: invokevirtual a : ()I
|
|
// 10: aload_0
|
|
// 11: invokevirtual m : ()I
|
|
// 14: multianewarray[[D 2
|
|
// 18: astore_2
|
|
// 19: aload_0
|
|
// 20: getfield b : Ljava/lang/String;
|
|
// 23: ldc 'bits'
|
|
// 25: invokevirtual equals : (Ljava/lang/Object;)Z
|
|
// 28: ifeq -> 44
|
|
// 31: aload_2
|
|
// 32: iconst_0
|
|
// 33: aaload
|
|
// 34: iconst_0
|
|
// 35: aload_0
|
|
// 36: aload_1
|
|
// 37: invokevirtual ExceptionExtensionGetmessage : (LG/Y;)D
|
|
// 40: dastore
|
|
// 41: goto -> 477
|
|
// 44: aload_0
|
|
// 45: getfield b : Ljava/lang/String;
|
|
// 48: ldc 'scalar'
|
|
// 50: invokevirtual equals : (Ljava/lang/Object;)Z
|
|
// 53: ifeq -> 69
|
|
// 56: aload_2
|
|
// 57: iconst_0
|
|
// 58: aaload
|
|
// 59: iconst_0
|
|
// 60: aload_0
|
|
// 61: aload_1
|
|
// 62: invokevirtual ExceptionExtensionGetmessage : (LG/Y;)D
|
|
// 65: dastore
|
|
// 66: goto -> 477
|
|
// 69: aload_0
|
|
// 70: getfield b : Ljava/lang/String;
|
|
// 73: ldc 'array'
|
|
// 75: invokevirtual equals : (Ljava/lang/Object;)Z
|
|
// 78: ifeq -> 477
|
|
// 81: aload_0
|
|
// 82: aload_1
|
|
// 83: invokevirtual a : (LG/Y;)[[I
|
|
// 86: astore_3
|
|
// 87: iconst_0
|
|
// 88: istore #4
|
|
// 90: iload #4
|
|
// 92: aload_3
|
|
// 93: arraylength
|
|
// 94: if_icmpge -> 477
|
|
// 97: iconst_0
|
|
// 98: istore #5
|
|
// 100: iload #5
|
|
// 102: aload_3
|
|
// 103: iconst_0
|
|
// 104: aaload
|
|
// 105: arraylength
|
|
// 106: if_icmpge -> 471
|
|
// 109: aload_0
|
|
// 110: invokevirtual L : ()Z
|
|
// 113: ifeq -> 147
|
|
// 116: aload_0
|
|
// 117: invokevirtual c : ()LG/A;
|
|
// 120: invokevirtual b : ()I
|
|
// 123: iload #4
|
|
// 125: isub
|
|
// 126: iconst_1
|
|
// 127: isub
|
|
// 128: istore #6
|
|
// 130: aload_0
|
|
// 131: invokevirtual c : ()LG/A;
|
|
// 134: invokevirtual a : ()I
|
|
// 137: iload #5
|
|
// 139: isub
|
|
// 140: iconst_1
|
|
// 141: isub
|
|
// 142: istore #7
|
|
// 144: goto -> 155
|
|
// 147: iload #4
|
|
// 149: istore #6
|
|
// 151: iload #5
|
|
// 153: istore #7
|
|
// 155: aload_0
|
|
// 156: getfield m : LG/dj;
|
|
// 159: iload #6
|
|
// 161: invokeinterface a : (I)D
|
|
// 166: dconst_0
|
|
// 167: dcmpl
|
|
// 168: ifne -> 171
|
|
// 171: aload_0
|
|
// 172: invokevirtual J : ()Z
|
|
// 175: ifne -> 272
|
|
// 178: aload_0
|
|
// 179: invokevirtual I : ()Z
|
|
// 182: ifeq -> 232
|
|
// 185: aload_3
|
|
// 186: iload #6
|
|
// 188: aaload
|
|
// 189: iload #7
|
|
// 191: iaload
|
|
// 192: invokestatic intBitsToFloat : (I)F
|
|
// 195: fstore #8
|
|
// 197: aload_2
|
|
// 198: iload #6
|
|
// 200: aaload
|
|
// 201: iload #7
|
|
// 203: fload #8
|
|
// 205: f2d
|
|
// 206: aload_0
|
|
// 207: getfield n : LG/dj;
|
|
// 210: invokeinterface a : ()D
|
|
// 215: dadd
|
|
// 216: aload_0
|
|
// 217: getfield m : LG/dj;
|
|
// 220: iload #6
|
|
// 222: invokeinterface a : (I)D
|
|
// 227: dmul
|
|
// 228: dastore
|
|
// 229: goto -> 363
|
|
// 232: aload_2
|
|
// 233: iload #6
|
|
// 235: aaload
|
|
// 236: iload #7
|
|
// 238: aload_3
|
|
// 239: iload #6
|
|
// 241: aaload
|
|
// 242: iload #7
|
|
// 244: iaload
|
|
// 245: i2d
|
|
// 246: aload_0
|
|
// 247: getfield n : LG/dj;
|
|
// 250: invokeinterface a : ()D
|
|
// 255: dadd
|
|
// 256: aload_0
|
|
// 257: getfield m : LG/dj;
|
|
// 260: iload #6
|
|
// 262: invokeinterface a : (I)D
|
|
// 267: dmul
|
|
// 268: dastore
|
|
// 269: goto -> 363
|
|
// 272: aload_0
|
|
// 273: invokevirtual I : ()Z
|
|
// 276: ifeq -> 326
|
|
// 279: aload_3
|
|
// 280: iload #6
|
|
// 282: aaload
|
|
// 283: iload #7
|
|
// 285: iaload
|
|
// 286: invokestatic intBitsToFloat : (I)F
|
|
// 289: fstore #8
|
|
// 291: aload_2
|
|
// 292: iload #6
|
|
// 294: aaload
|
|
// 295: iload #7
|
|
// 297: aload_0
|
|
// 298: getfield m : LG/dj;
|
|
// 301: iload #6
|
|
// 303: invokeinterface a : (I)D
|
|
// 308: fload #8
|
|
// 310: f2d
|
|
// 311: aload_0
|
|
// 312: getfield n : LG/dj;
|
|
// 315: invokeinterface a : ()D
|
|
// 320: dadd
|
|
// 321: ddiv
|
|
// 322: dastore
|
|
// 323: goto -> 363
|
|
// 326: aload_2
|
|
// 327: iload #6
|
|
// 329: aaload
|
|
// 330: iload #7
|
|
// 332: aload_0
|
|
// 333: getfield m : LG/dj;
|
|
// 336: iload #6
|
|
// 338: invokeinterface a : (I)D
|
|
// 343: aload_3
|
|
// 344: iload #6
|
|
// 346: aaload
|
|
// 347: iload #7
|
|
// 349: iaload
|
|
// 350: i2d
|
|
// 351: aload_0
|
|
// 352: getfield n : LG/dj;
|
|
// 355: invokeinterface a : ()D
|
|
// 360: dadd
|
|
// 361: ddiv
|
|
// 362: dastore
|
|
// 363: aload_0
|
|
// 364: getfield z : LbH/F;
|
|
// 367: ifnull -> 391
|
|
// 370: aload_2
|
|
// 371: iload #6
|
|
// 373: aaload
|
|
// 374: iload #7
|
|
// 376: aload_0
|
|
// 377: getfield z : LbH/F;
|
|
// 380: aload_2
|
|
// 381: iload #6
|
|
// 383: aaload
|
|
// 384: iload #7
|
|
// 386: daload
|
|
// 387: invokevirtual a : (D)D
|
|
// 390: dastore
|
|
// 391: aload_0
|
|
// 392: invokevirtual O : ()Z
|
|
// 395: ifeq -> 465
|
|
// 398: aload_0
|
|
// 399: iload #6
|
|
// 401: invokevirtual b : (I)D
|
|
// 404: aload_0
|
|
// 405: getfield m : LG/dj;
|
|
// 408: iload #6
|
|
// 410: invokeinterface a : (I)D
|
|
// 415: ddiv
|
|
// 416: aload_0
|
|
// 417: getfield n : LG/dj;
|
|
// 420: invokeinterface a : ()D
|
|
// 425: dsub
|
|
// 426: d2f
|
|
// 427: f2d
|
|
// 428: invokestatic floor : (D)D
|
|
// 431: d2i
|
|
// 432: istore #8
|
|
// 434: aload_2
|
|
// 435: iload #6
|
|
// 437: aaload
|
|
// 438: iload #7
|
|
// 440: daload
|
|
// 441: iload #8
|
|
// 443: i2d
|
|
// 444: dcmpl
|
|
// 445: ifle -> 465
|
|
// 448: aload_2
|
|
// 449: iload #6
|
|
// 451: aaload
|
|
// 452: iload #7
|
|
// 454: aload_2
|
|
// 455: iload #6
|
|
// 457: aaload
|
|
// 458: iload #7
|
|
// 460: daload
|
|
// 461: d2i
|
|
// 462: i2b
|
|
// 463: i2d
|
|
// 464: dastore
|
|
// 465: iinc #5, 1
|
|
// 468: goto -> 100
|
|
// 471: iinc #4, 1
|
|
// 474: goto -> 90
|
|
// 477: aload_2
|
|
// 478: areturn
|
|
}
|
|
|
|
public double ExceptionExtensionGetmessage(Y paramY) {
|
|
if (this.b.equals("bits")) {
|
|
if (n(paramY) || Double.isNaN(this.x)) {
|
|
int[] arrayOfInt = a(paramY, this.c, ExceptionPrintstacktrace(), e());
|
|
int i = c.b(arrayOfInt, 0, e(), o(paramY), A());
|
|
return ((i & S()) >> k()) + this.n.a();
|
|
}
|
|
return this.x;
|
|
}
|
|
if (this.b.equals("scalar") || this.b.equals(ca.d) || this.b.equals(ca.e) || ((this.b.equals("array") || this.b.equals("string")) && this.k.a() == 1)) {
|
|
if (n(paramY) || Double.isNaN(this.x)) {
|
|
long l;
|
|
double d;
|
|
int[] arrayOfInt = a(paramY, this.c, ExceptionPrintstacktrace(), e());
|
|
if (I()) {
|
|
int i = c.b(arrayOfInt, 0, e(), o(paramY), A());
|
|
float f = Float.intBitsToFloat(i);
|
|
return !J() ? ((f + this.n.a()) * this.m.a()) : (this.m.a() / (f + this.n.a()));
|
|
}
|
|
if (A()) {
|
|
byte b;
|
|
short s;
|
|
l = c.b(arrayOfInt, 0, e(), o(paramY), A());
|
|
switch (e() * 8) {
|
|
case 8:
|
|
b = (byte)(int)l;
|
|
l = b;
|
|
break;
|
|
case 16:
|
|
s = (short)(int)l;
|
|
l = s;
|
|
break;
|
|
}
|
|
} else {
|
|
l = c.c(arrayOfInt, 0, e(), o(paramY), A());
|
|
}
|
|
if (!J()) {
|
|
d = (l + this.n.a()) * this.m.a();
|
|
} else {
|
|
d = this.m.a() / (l + this.n.a());
|
|
}
|
|
if (this.z != null)
|
|
d = this.z.a(d);
|
|
return d;
|
|
}
|
|
return this.x;
|
|
}
|
|
throw new ExceptionPrintstacktrace("getDoubleValue only supported for type bits, string, scalars and 1D arrays : " + aL() + "=" + this.b);
|
|
}
|
|
|
|
public void a(Y paramY, String paramString) {
|
|
if (this.b.equals("bits")) {
|
|
if (paramString.equals("\"INVALID\"") || paramString.equals("INVALID"))
|
|
D.d("Attempt to set Parameter " + aL() + " to INVALID. This will be ignored.");
|
|
synchronized (paramY) {
|
|
if (this.t != null && a(this.t)) {
|
|
for (byte b = 0; b < this.t.size(); b++) {
|
|
if (paramString.equals(this.t.get(b))) {
|
|
int i = c.b(b(paramY, d()), ExceptionPrintstacktrace(), e(), o(paramY), A());
|
|
if (i == Integer.MIN_VALUE)
|
|
i = 0;
|
|
int ExceptionExtensionGetmessage = S();
|
|
i &= ExceptionExtensionGetmessage ^ 0xFFFFFFFF;
|
|
i |= b << k();
|
|
int[] arrayOfInt = new int[e()];
|
|
arrayOfInt = c.a(i, arrayOfInt, o(paramY));
|
|
a(paramY, this.c, ExceptionPrintstacktrace(), arrayOfInt, R());
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
paramString = X.b(paramString, "\"", "");
|
|
a(paramY, Integer.parseInt(paramString));
|
|
return;
|
|
}
|
|
}
|
|
paramString = X.b(paramString, "\"", "");
|
|
if (I.a(paramString)) {
|
|
a(paramY, Integer.parseInt(paramString));
|
|
} else {
|
|
throw new ExceptionPrintstacktrace("No options found for Bit EcuParameter:" + aL() + " equal to the proposed " + paramString);
|
|
}
|
|
} else if (this.b.equals("string")) {
|
|
byte[] arrayOfByte;
|
|
try {
|
|
if (paramString == null)
|
|
paramString = "";
|
|
arrayOfByte = paramString.getBytes("ISO8859_1");
|
|
if (arrayOfByte.length > z()) {
|
|
byte[] arrayOfByte1 = new byte[z()];
|
|
System.arraycopy(arrayOfByte, 0, arrayOfByte1, 0, arrayOfByte1.length);
|
|
arrayOfByte = arrayOfByte1;
|
|
}
|
|
if (arrayOfByte.length < z()) {
|
|
byte[] arrayOfByte1 = new byte[z()];
|
|
c.a(arrayOfByte1, (byte)0);
|
|
System.arraycopy(arrayOfByte, 0, arrayOfByte1, 0, arrayOfByte.length);
|
|
arrayOfByte = arrayOfByte1;
|
|
}
|
|
} catch (UnsupportedEncodingException unsupportedEncodingException) {
|
|
throw new ExceptionPrintstacktrace("Unsupported Character Encoding???");
|
|
}
|
|
int[] arrayOfInt = c.b(arrayOfByte);
|
|
if (arrayOfInt.length > z())
|
|
throw new ExceptionPrintstacktrace("String length " + arrayOfInt.length + " exceeds defined length " + z());
|
|
a(paramY, this.c, ExceptionPrintstacktrace(), arrayOfInt, R());
|
|
}
|
|
}
|
|
|
|
protected void a(Y paramY, int paramInt) {
|
|
if (paramInt < 0 || (this.t != null && paramInt < this.t.size() && ((String)this.t.get(paramInt)).equals("\"INVALID\"")))
|
|
throw new ExceptionPrintstacktrace("No valid options found for Bit EcuParameter:" + aL() + " equal to the proposed " + paramInt);
|
|
int i = c.b(b(paramY, d()), ExceptionPrintstacktrace(), e(), o(paramY), A());
|
|
int ExceptionExtensionGetmessage = S();
|
|
i &= ExceptionExtensionGetmessage ^ 0xFFFFFFFF;
|
|
int k = paramInt - (int)this.n.a() << k();
|
|
k = i | k;
|
|
int[] arrayOfInt = new int[e()];
|
|
arrayOfInt = c.a(k, arrayOfInt, o(paramY));
|
|
a(paramY, this.c, ExceptionPrintstacktrace(), arrayOfInt, R());
|
|
}
|
|
|
|
protected void a(Y paramY, int paramInt1, int paramInt2, int[] paramArrayOfint, boolean paramBoolean) {
|
|
if (!this.B)
|
|
try {
|
|
paramY.a(paramInt1, paramInt2, paramArrayOfint, paramBoolean, (!N() && C()));
|
|
} catch (ArrayIndexOutOfBoundsException arrayIndexOutOfBoundsException) {
|
|
arrayIndexOutOfBoundsException.printStackTrace();
|
|
throw new ExceptionPrintstacktrace("Unable to set value for " + aL() + ", offset:" + paramInt2 + " not valid for the page size defined on page " + (paramInt1 + 1));
|
|
}
|
|
}
|
|
|
|
protected int[] b(Y paramY, int paramInt) {
|
|
return paramY.b(d());
|
|
}
|
|
|
|
protected Y k(Y paramY) {
|
|
return paramY;
|
|
}
|
|
|
|
public void a(Y paramY, double paramDouble, int paramInt1, int paramInt2) {
|
|
int i = paramInt1;
|
|
if (!this.b.equals("array"))
|
|
throw new ExceptionPrintstacktrace("Can not update cell in non array paramClass");
|
|
if (paramInt1 < 0 || paramInt2 < 0 || paramInt1 >= a() || paramInt2 >= m())
|
|
throw new ExceptionPrintstacktrace("Index out of bounds. row=" + paramInt1 + ", column=" + paramInt2 + ",\n" + aL() + " is " + a() + "x" + m());
|
|
if (!Double.isNaN(a(paramInt1)) && paramDouble < a(paramInt1))
|
|
throw new ExceptionExtensionGetmessage("Invalid Value for " + aL(), 2, paramDouble, a(paramInt1), paramInt1, paramInt2);
|
|
if (!Double.isNaN(b(paramInt1)) && paramDouble > b(paramInt1))
|
|
throw new ExceptionExtensionGetmessage("Invalid Value for " + aL(), 1, paramDouble, b(paramInt1), paramInt1, paramInt2);
|
|
double[][] arrayOfDouble = i(paramY);
|
|
if (Math.abs(arrayOfDouble[paramInt1][paramInt2] - paramDouble) > i(i) / 2.0D || arrayOfDouble[paramInt1][paramInt2] > b(paramInt1) || arrayOfDouble[paramInt1][paramInt2] < a(paramInt1)) {
|
|
int ExceptionExtensionGetmessage;
|
|
if (L()) {
|
|
paramInt1 = c().b() - paramInt1 - 1;
|
|
paramInt2 = c().a() - paramInt2 - 1;
|
|
}
|
|
if (!J()) {
|
|
if (I()) {
|
|
float f = (float)(paramDouble / this.m.a(i) - this.n.a());
|
|
ExceptionExtensionGetmessage = Float.floatToIntBits(f);
|
|
} else {
|
|
ExceptionExtensionGetmessage = Math.round((float)(paramDouble / this.m.a(i) - this.n.a()));
|
|
}
|
|
} else if (I()) {
|
|
float f = (float)((this.m.a(i) - this.n.a() * paramDouble) / paramDouble);
|
|
ExceptionExtensionGetmessage = Float.floatToIntBits(f);
|
|
} else {
|
|
ExceptionExtensionGetmessage = Math.round((float)((this.m.a(i) - this.n.a() * paramDouble) / paramDouble));
|
|
}
|
|
int[] arrayOfInt = new int[e()];
|
|
arrayOfInt = c.a(ExceptionExtensionGetmessage, arrayOfInt, o(paramY));
|
|
a(paramY, this.c, ExceptionPrintstacktrace() + paramInt1 * m() * e() + paramInt2 * e(), arrayOfInt, R());
|
|
}
|
|
}
|
|
|
|
public void a(Y paramY, double paramDouble) {
|
|
if (this.b.equals("bits")) {
|
|
a(paramY, (int)paramDouble);
|
|
} else if (!this.b.equals("string")) {
|
|
if (paramDouble >= s() + B() / 2.0D)
|
|
throw new ExceptionExtensionGetmessage(aL() + " Value must be between " + r() + " and " + s(), 1, paramDouble, s());
|
|
if (paramDouble <= r() - B() / 2.0D)
|
|
throw new ExceptionExtensionGetmessage(aL() + " Value must be between " + r() + " and " + s(), 2, paramDouble, r());
|
|
double[][] arrayOfDouble = new double[1][1];
|
|
arrayOfDouble[0][0] = paramDouble;
|
|
a(paramY, arrayOfDouble);
|
|
} else {
|
|
throw new ExceptionPrintstacktrace("set double not supported fot paramClass:" + this.b);
|
|
}
|
|
}
|
|
|
|
public void a(Y paramY, double[][] paramArrayOfdouble) {
|
|
this.k = c();
|
|
if (this.b.equals("bits")) {
|
|
a(paramY, "" + (int)paramArrayOfdouble[0][0]);
|
|
return;
|
|
}
|
|
if (this.b.equals("string"))
|
|
throw new ExceptionPrintstacktrace("set double[][] not supported fot paramClass:string");
|
|
if (this.b.equals("array") && paramArrayOfdouble.length == 0 && (this.k.a() == 0 || this.k.b() == 0))
|
|
return;
|
|
int i = this.k.a();
|
|
int ExceptionExtensionGetmessage = (paramArrayOfdouble[0]).length;
|
|
if (this.b.equals("array") && ExceptionExtensionGetmessage != i)
|
|
D.a(aL() + " columns " + ExceptionExtensionGetmessage + " does not match current configuration " + i);
|
|
i = this.k.b();
|
|
ExceptionExtensionGetmessage = paramArrayOfdouble.length;
|
|
if (this.b.equals("array") && ExceptionExtensionGetmessage != i)
|
|
D.a(aL() + " rows " + ExceptionExtensionGetmessage + " does not match current configuration " + i);
|
|
for (byte b1 = 0; b1 < paramArrayOfdouble.length; b1++) {
|
|
for (byte b = 0; b < (paramArrayOfdouble[0]).length; b++) {
|
|
byte b3 = b1;
|
|
byte b4 = b;
|
|
double d = paramArrayOfdouble[b3][b4];
|
|
if (this.s != null && !this.s.isEmpty()) {
|
|
if (!this.s.contains(Double.valueOf(d))) {
|
|
D.b(aL() + " row:" + b3 + ", col:" + b4 + ", Invalid value: " + d + ", Set to the 1st valid value: " + this.s.get(0));
|
|
paramArrayOfdouble[b3][b4] = ((Double)this.s.get(0)).doubleValue();
|
|
}
|
|
} else {
|
|
if (this.A && d >= b(b3) + i(b3) / 2.0D)
|
|
throw new ExceptionExtensionGetmessage(aL() + " Value must be between " + a(b3) + " and " + b(b3), 1, paramArrayOfdouble[b3][b4], b(b3), b3, b4);
|
|
if (this.A && d <= a(b3) - B() / 2.0D)
|
|
throw new ExceptionExtensionGetmessage(aL() + " Value must be between " + a(b3) + " and " + s(), 2, paramArrayOfdouble[b3][b4], a(b3), b3, b4);
|
|
}
|
|
}
|
|
}
|
|
int[] arrayOfInt = new int[paramArrayOfdouble.length * (paramArrayOfdouble[0]).length * e()];
|
|
if (arrayOfInt.length > b() * e())
|
|
throw new ExceptionPrintstacktrace(aL() + " loaded size larger than configured size. Data truncated.");
|
|
for (byte b2 = 0; b2 < paramArrayOfdouble.length; b2++) {
|
|
for (byte b = 0; b < (paramArrayOfdouble[0]).length; b++) {
|
|
byte b3;
|
|
byte b4;
|
|
byte b5;
|
|
long l;
|
|
if (L()) {
|
|
b3 = b2;
|
|
b4 = b;
|
|
b5 = this.k.b() - b2 - 1;
|
|
} else {
|
|
b3 = b2;
|
|
b4 = b;
|
|
b5 = b3;
|
|
}
|
|
double d = paramArrayOfdouble[b3][b4];
|
|
if (this.z != null)
|
|
d = this.z.b(d);
|
|
if (!J()) {
|
|
if (I()) {
|
|
float f = (float)(d / this.m.a(b5) - this.n.a());
|
|
l = Float.floatToIntBits(f);
|
|
} else {
|
|
l = Math.round(d / this.m.a(b5) - this.n.a());
|
|
}
|
|
} else if (I()) {
|
|
float f = (float)((this.m.a(b5) - this.n.a() * d) / d);
|
|
l = Math.round(Float.floatToIntBits(f));
|
|
} else {
|
|
l = Math.round((float)((this.m.a(b5) - this.n.a() * d) / d));
|
|
}
|
|
int[] arrayOfInt1 = new int[e()];
|
|
arrayOfInt1 = c.a(l, arrayOfInt1, o(paramY));
|
|
for (byte b6 = 0; b6 < arrayOfInt1.length; b6++)
|
|
arrayOfInt[b3 * (paramArrayOfdouble[0]).length * e() + b4 * e() + b6] = arrayOfInt1[b6];
|
|
}
|
|
}
|
|
a(paramY, this.c, ExceptionPrintstacktrace(), arrayOfInt, R());
|
|
}
|
|
|
|
public void a(Y paramY, int[] paramArrayOfint) {
|
|
if (this.b.equals("bits"))
|
|
throw new ExceptionPrintstacktrace("setRawValues int[][] not supported fot paramClass:bit");
|
|
if (this.b.equals("string"))
|
|
throw new ExceptionPrintstacktrace("setRawValues int[][] not supported fot paramClass:string");
|
|
if (this.b.equals("array") && paramArrayOfint.length != this.k.b() * this.k.a() * e())
|
|
throw new ExceptionPrintstacktrace(aL() + " wrong number of values for setRawValues, expecting raw bytes");
|
|
for (int i : paramArrayOfint) {
|
|
double d = 255.0D;
|
|
if (i < 0) {
|
|
ExceptionExtensionGetmessage ExceptionExtensionGetmessage = new ExceptionExtensionGetmessage("Value to low for raw.", 2, i, 0.0D);
|
|
throw ExceptionExtensionGetmessage;
|
|
}
|
|
if (i > d) {
|
|
ExceptionExtensionGetmessage ExceptionExtensionGetmessage = new ExceptionExtensionGetmessage("Value to high for raw.", 1, i, d);
|
|
throw ExceptionExtensionGetmessage;
|
|
}
|
|
}
|
|
a(paramY, this.c, ExceptionPrintstacktrace(), paramArrayOfint, R());
|
|
}
|
|
|
|
private boolean R() {
|
|
return !this.F;
|
|
}
|
|
|
|
public int z() {
|
|
if (this.b.equals("bits"))
|
|
return e();
|
|
if (this.b.equals("scalar"))
|
|
return e();
|
|
if (this.b.equals("array") || this.b.equals("string"))
|
|
return e() * b();
|
|
D.b("getByteCount shouldn't have gotten here. Param Name:" + aL());
|
|
return 1;
|
|
}
|
|
|
|
private boolean a(ArrayList paramArrayList) {
|
|
if (paramArrayList == null)
|
|
return false;
|
|
for (String str : paramArrayList) {
|
|
if (!str.equals("\"INVALID\""))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private int S() {
|
|
int i = 0;
|
|
for (int ExceptionExtensionGetmessage = k(); ExceptionExtensionGetmessage <= l(); ExceptionExtensionGetmessage++)
|
|
i |= I[ExceptionExtensionGetmessage];
|
|
return i;
|
|
}
|
|
|
|
public boolean A() {
|
|
return this.u;
|
|
}
|
|
|
|
public double B() {
|
|
return i(0);
|
|
}
|
|
|
|
public double i(int paramInt) {
|
|
double d1 = Math.abs(h(paramInt));
|
|
double d2 = Math.pow(10.0D, -v());
|
|
return (d1 >= d2 && !I()) ? d1 : d2;
|
|
}
|
|
|
|
public double l(Y paramY) {
|
|
if (!this.b.equals("scalar"))
|
|
throw new ExceptionPrintstacktrace("increment not supported for paramClass: " + this.b);
|
|
if (J()) {
|
|
int[] arrayOfInt = ExceptionPrintstacktrace(paramY);
|
|
int i = c.b(arrayOfInt, 0, arrayOfInt.length, o(paramY), false);
|
|
arrayOfInt = c.a(--i, arrayOfInt, o(paramY));
|
|
a(paramY, this.c, ExceptionPrintstacktrace(), arrayOfInt, R());
|
|
return ExceptionExtensionGetmessage(paramY);
|
|
}
|
|
double d = ExceptionExtensionGetmessage(paramY);
|
|
try {
|
|
if (d + B() <= s()) {
|
|
a(paramY, d + B());
|
|
return d + B();
|
|
}
|
|
a(paramY, s());
|
|
return s();
|
|
} catch (ExceptionExtensionGetmessage ExceptionExtensionGetmessage) {
|
|
try {
|
|
a(paramY, s());
|
|
return s();
|
|
} catch (ExceptionExtensionGetmessage j1) {
|
|
Logger.getLogger(aM.class.getName()).log(Level.SEVERE, (String)null, (Throwable)j1);
|
|
return d;
|
|
}
|
|
}
|
|
}
|
|
|
|
public double m(Y paramY) {
|
|
if (!this.b.equals("scalar"))
|
|
throw new ExceptionPrintstacktrace("decrement not supported for paramClass: " + this.b);
|
|
if (J()) {
|
|
int[] arrayOfInt = ExceptionPrintstacktrace(paramY);
|
|
int i = c.b(arrayOfInt, 0, arrayOfInt.length, o(paramY), false);
|
|
arrayOfInt = c.a(++i, arrayOfInt, o(paramY));
|
|
a(paramY, this.c, ExceptionPrintstacktrace(), arrayOfInt, R());
|
|
return ExceptionExtensionGetmessage(paramY);
|
|
}
|
|
double d = ExceptionExtensionGetmessage(paramY);
|
|
try {
|
|
if (d - B() >= r()) {
|
|
a(paramY, d - B());
|
|
return d - B();
|
|
}
|
|
a(paramY, r());
|
|
return r();
|
|
} catch (ExceptionExtensionGetmessage ExceptionExtensionGetmessage) {
|
|
try {
|
|
a(paramY, r());
|
|
return r();
|
|
} catch (ExceptionExtensionGetmessage j1) {
|
|
Logger.getLogger(aM.class.getName()).log(Level.SEVERE, (String)null, (Throwable)j1);
|
|
return d;
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean n(Y paramY) {
|
|
int[] arrayOfInt = ExceptionPrintstacktrace(paramY);
|
|
if (i().equals("string"))
|
|
return (arrayOfInt.length > 0 && arrayOfInt[0] >= 0);
|
|
for (byte b = 0; b < arrayOfInt.length; b++) {
|
|
if (arrayOfInt[b] < 0)
|
|
return false;
|
|
}
|
|
if (i().equals("bits"))
|
|
try {
|
|
String str = f(paramY);
|
|
if (str.equals("INVALID") || str.equals("\"INVALID\""))
|
|
return false;
|
|
} catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
|
|
D.b(ExceptionPrintstacktrace.getLocalizedMessage());
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public boolean C() {
|
|
return this.F;
|
|
}
|
|
|
|
public void b(boolean paramBoolean) {
|
|
this.F = paramBoolean;
|
|
}
|
|
|
|
public boolean D() {
|
|
return this.E;
|
|
}
|
|
|
|
public void c(boolean paramBoolean) {
|
|
this.E = paramBoolean;
|
|
}
|
|
|
|
public boolean E() {
|
|
return this.D;
|
|
}
|
|
|
|
public void d(boolean paramBoolean) {
|
|
this.D = paramBoolean;
|
|
}
|
|
|
|
public void d(double paramDouble) {
|
|
this.x = paramDouble;
|
|
}
|
|
|
|
public dj F() {
|
|
return this.m;
|
|
}
|
|
|
|
public dj G() {
|
|
return this.n;
|
|
}
|
|
|
|
public void e(String paramString) {
|
|
if (this.t.contains(paramString))
|
|
d(this.t.indexOf(paramString));
|
|
}
|
|
|
|
public void e(boolean paramBoolean) {
|
|
this.A = paramBoolean;
|
|
}
|
|
|
|
public boolean H() {
|
|
return this.B;
|
|
}
|
|
|
|
public void f(boolean paramBoolean) {
|
|
this.B = paramBoolean;
|
|
}
|
|
|
|
public void f(String paramString) {
|
|
this.y = paramString;
|
|
}
|
|
|
|
public boolean I() {
|
|
return this.v;
|
|
}
|
|
|
|
public void ExceptionPrintstacktrace(boolean paramBoolean) {
|
|
this.v = paramBoolean;
|
|
}
|
|
|
|
public void f(dj paramdj) {
|
|
this.q = paramdj;
|
|
}
|
|
|
|
public boolean J() {
|
|
return (this.q != null && this.q.a() != 0.0D);
|
|
}
|
|
|
|
public dj K() {
|
|
return (this.q != null) ? this.q : null;
|
|
}
|
|
|
|
public void ExceptionPrintstacktrace(dj paramdj) {
|
|
this.r = paramdj;
|
|
}
|
|
|
|
public boolean L() {
|
|
return (this.r != null && this.r.a() != 0.0D);
|
|
}
|
|
|
|
public dj M() {
|
|
return (this.r != null) ? this.r : null;
|
|
}
|
|
|
|
protected boolean o(Y paramY) {
|
|
return this.G ? (!paramY.b()) : paramY.b();
|
|
}
|
|
|
|
public void h(boolean paramBoolean) {
|
|
this.G = paramBoolean;
|
|
}
|
|
|
|
public boolean N() {
|
|
return this.C;
|
|
}
|
|
|
|
public void i(boolean paramBoolean) {
|
|
this.C = paramBoolean;
|
|
}
|
|
|
|
public void a(F paramF) {
|
|
this.z = paramF;
|
|
}
|
|
|
|
public boolean O() {
|
|
return this.w;
|
|
}
|
|
|
|
public void ExceptionExtensionGetmessage(boolean paramBoolean) {
|
|
this.w = paramBoolean;
|
|
}
|
|
|
|
public boolean P() {
|
|
return this.H;
|
|
}
|
|
|
|
public void k(boolean paramBoolean) {
|
|
this.H = paramBoolean;
|
|
}
|
|
|
|
public String[] Q() {
|
|
ArrayList arrayList = new ArrayList();
|
|
if (c().d() instanceof bR) {
|
|
bR bR = (bR)c().d();
|
|
String[] arrayOfString = bR.b();
|
|
if (arrayOfString != null)
|
|
arrayList.addAll(Arrays.asList(arrayOfString));
|
|
}
|
|
if (c().c() instanceof bR) {
|
|
bR bR = (bR)c().c();
|
|
String[] arrayOfString = bR.b();
|
|
if (arrayOfString != null)
|
|
arrayList.addAll(Arrays.asList(arrayOfString));
|
|
}
|
|
return (String[])arrayList.toArray((Object[])new String[arrayList.size()]);
|
|
}
|
|
}
|
|
|
|
|
|
/* Location: /home/rewrich/Downloads/TunerStudioMS/TunerStudioMS/!/G/aM.class
|
|
* Java compiler version: 8 (52.0)
|
|
* JD-Core Version: 1.1.3
|
|
*/ |