jniwrap-3.8.4

16:37:57.066 INFO  jd.cli.Main - Decompiling jniwrap-3.8.4.jar
package com.jniwrapper;

public class ShortInt
  extends ax
{
  public ShortInt()
  {
    super(PlatformContext.getShortLength(), false);
  }
  
  public ShortInt(long paramLong)
  {
    this();
    setValue(paramLong);
  }
  
  public ShortInt(IntegerParameter paramIntegerParameter)
  {
    this();
    setValue(paramIntegerParameter.getValue());
  }
  
  public Object clone()
  {
    return new ShortInt(this);
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.ShortInt
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

import java.lang.ref.ReferenceQueue;
import org.slf4j.Logger;

public class a
  extends Thread
{
  private final NativeResourceCollector a;
  
  public a(NativeResourceCollector paramNativeResourceCollector)
  {
    a = paramNativeResourceCollector;
  }
  
  public void run()
  {
    while (NativeResourceCollector.d(a)) {
      try
      {
        while (NativeResourceCollector.d(a))
        {
          bh localbh = (bh)NativeResourceCollector.b(a).remove();
          if (localbh != null) {
            try
            {
              localbh.b();
            }
            catch (Throwable localThrowable)
            {
              NativeResourceCollector.c().error("", localThrowable);
            }
          }
        }
      }
      catch (InterruptedException localInterruptedException)
      {
        NativeResourceCollector.c().debug("", localInterruptedException);
      }
    }
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.a
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

public class UnicodeString
  extends ZeroTerminatedString
{
  public UnicodeString()
  {
    this(256);
  }
  
  public UnicodeString(int paramInt)
  {
    this("", paramInt);
  }
  
  public UnicodeString(String paramString)
  {
    this(a(paramString));
  }
  
  public UnicodeString(String paramString, int paramInt)
  {
    this(a(paramString), paramInt * 2);
  }
  
  private UnicodeString(byte[] paramArrayOfByte)
  {
    this(paramArrayOfByte, paramArrayOfByte.length + 2);
  }
  
  private UnicodeString(byte[] paramArrayOfByte, int paramInt)
  {
    super(paramArrayOfByte, paramInt, 2);
  }
  
  public UnicodeString(UnicodeString paramUnicodeString)
  {
    this(paramUnicodeString.getValue(), paramUnicodeString.getMaxLength());
  }
  
  public String bytesToString(byte[] paramArrayOfByte)
  {
    char[] arrayOfChar = new char[getMaxLength()];
    for (int i = 0; i < getMaxLength(); i++)
    {
      int j = i * b();
      UnicodeChar localUnicodeChar = new UnicodeChar();
      localUnicodeChar.read(paramArrayOfByte, j);
      if (localUnicodeChar.getValue() == 0) {
        break;
      }
      arrayOfChar[i] = localUnicodeChar.getValue();
    }
    return new String(arrayOfChar, 0, i);
  }
  
  public byte[] stringToBytes(String paramString)
  {
    byte[] arrayOfByte = a(paramString);
    return arrayOfByte;
  }
  
  private static byte[] a(String paramString)
  {
    char[] arrayOfChar = paramString.toCharArray();
    byte[] arrayOfByte = new byte[arrayOfChar.length * 2];
    for (int i = 0; i < arrayOfChar.length; i++)
    {
      int j = i * 2;
      
      UnicodeChar localUnicodeChar = new UnicodeChar(arrayOfChar[i]);
      localUnicodeChar.write(arrayOfByte, j);
    }
    return arrayOfByte;
  }
  
  public Object clone()
  {
    return new UnicodeString(this);
  }
  
  public int getStrLen(DataBuffer paramDataBuffer, int paramInt)
  {
    for (int i = paramInt; i < paramInt + getLength(); i += 2)
    {
      int j = 1;
      for (int k = i; k < i + 2; k++) {
        if (paramDataBuffer.readByte(k) != 0)
        {
          j = 0;
          break;
        }
      }
      if (j != 0) {
        return (i - paramInt) / 2;
      }
    }
    return getLength() / 2;
  }
  
  public int getAlignmentRequirement()
  {
    return 2;
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.UnicodeString
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

public class b
  implements af
{
  public String getNativeLibraryName()
  {
    return "jniwrap";
  }
  
  public String getFullNativeLibraryName()
  {
    return "libjniwrap.jnilib";
  }
  
  public int prepareReturnParameterFlags(Parameter paramParameter)
  {
    return 0;
  }
  
  public Parameter[] prepareFunctionCallParameters(Parameter[] paramArrayOfParameter)
  {
    return aa.a(paramArrayOfParameter);
  }
  
  public byte[] generateCallbackParametersInfo(Parameter paramParameter, Parameter[] paramArrayOfParameter)
  {
    Parameter[] arrayOfParameter = aa.a(paramParameter, paramArrayOfParameter);
    byte[] arrayOfByte = new byte[arrayOfParameter.length * 4];
    DataBuffer localDataBuffer = DataBufferFactory.getInstance().createArrayBuffer(arrayOfByte);
    for (int i = 0; i < arrayOfParameter.length; i++)
    {
      Parameter localParameter = arrayOfParameter[i];
      localParameter.push(localDataBuffer, i * 4, false);
    }
    return arrayOfByte;
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.b
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

public class Int8
  extends ac
{
  public Int8()
  {
    this((byte)0);
  }
  
  public Int8(byte paramByte)
  {
    setValue(paramByte);
  }
  
  public Int8(IntegerParameter paramIntegerParameter)
  {
    this((byte)(int)paramIntegerParameter.getValue());
  }
  
  public int getLength()
  {
    return 1;
  }
  
  public Object clone()
  {
    return new Int8(this);
  }
  
  public long getValue()
  {
    return getDataBuffer().readByte(getDataBufferOffset());
  }
  
  public void setValue(long paramLong)
  {
    getDataBuffer().writeByte(getDataBufferOffset(), (byte)(int)paramLong);
  }
  
  public long a()
  {
    return 4L;
  }
  
  public void write(DataBuffer paramDataBuffer, int paramInt, boolean paramBoolean)
    throws MemoryAccessViolationException
  {
    paramDataBuffer.writeByte(paramInt, (byte)(int)getValue());
  }
  
  public void read(DataBuffer paramDataBuffer, int paramInt, boolean paramBoolean)
    throws MemoryAccessViolationException
  {
    setValue(paramDataBuffer.readByte(paramInt));
  }
  
  public void push(DataBuffer paramDataBuffer, int paramInt, boolean paramBoolean)
    throws MemoryAccessViolationException
  {
    if (!paramBoolean) {
      paramDataBuffer.writeByte(paramInt, (byte)(int)getValue());
    }
  }
  
  public void pop(DataBuffer paramDataBuffer, int paramInt, boolean paramBoolean)
    throws MemoryAccessViolationException
  {
    if (paramBoolean) {
      setValue(paramDataBuffer.readByte(paramInt));
    }
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.Int8
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.text.MessageFormat;
import java.util.Enumeration;
import java.util.LinkedList;
import java.util.List;

public class c
  implements as
{
  public String a;
  private String b;
  private String c;
  
  public c(String paramString1, String paramString2, String paramString3)
  {
    a = paramString1;
    b = paramString2;
    c = paramString3;
  }
  
  public List c()
  {
    LinkedList localLinkedList = new LinkedList();
    ah localah;
    if ((localah = a(b)) != null)
    {
      localLinkedList.add(localah);
      return localLinkedList;
    }
    if ((localah = a(c)) != null)
    {
      localLinkedList.add(localah);
      return localLinkedList;
    }
    String str = MessageFormat.format("{0} license file ''{1}'' cannot be found in the classpath.", new Object[] { a, b });
    throw f.a(a, str);
  }
  
  public String b()
  {
    return b;
  }
  
  public String a()
  {
    return c;
  }
  
  private ah a(String paramString)
  {
    try
    {
      Enumeration localEnumeration = getClass().getClassLoader().getResources(paramString);
      if (!localEnumeration.hasMoreElements()) {
        return null;
      }
      URL localURL = (URL)localEnumeration.nextElement();
      if (localEnumeration.hasMoreElements()) {
        throw f.a(a, "There's more than one license file '" + paramString + "' in the classpath.");
      }
      InputStream localInputStream = localURL.openStream();
      aj localaj = new aj(localInputStream);
      localInputStream.close();
      return new ah(localaj, paramString);
    }
    catch (IOException localIOException)
    {
      throw new RuntimeException(localIOException);
    }
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.c
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

public class Pointer$Void
  extends Parameter
  implements IntegerParameter, PointerParameter
{
  public Pointer$Void()
  {
    this(0L);
  }
  
  public Pointer$Void(long paramLong)
  {
    super(new bg(), 0);
    setValue(paramLong);
  }
  
  public Pointer$Void(Void paramVoid)
  {
    this(paramVoid.getValue());
  }
  
  public int getLength()
  {
    return Pointer.POINTER_LENGTH;
  }
  
  public void write(DataBuffer paramDataBuffer, int paramInt, boolean paramBoolean)
    throws MemoryAccessViolationException
  {
    paramDataBuffer.writePointer(paramInt, getValue());
  }
  
  public void read(DataBuffer paramDataBuffer, int paramInt, boolean paramBoolean)
    throws MemoryAccessViolationException
  {
    setValue(paramDataBuffer.readPointer(paramInt));
  }
  
  public Object clone()
  {
    return new Void(this);
  }
  
  public void setValue(long paramLong)
  {
    getDataBuffer().writePointer(getDataBufferOffset(), paramLong);
  }
  
  public long getValue()
  {
    return getDataBuffer().readPointer(getDataBufferOffset());
  }
  
  public boolean isNull()
  {
    return getValue() == 0L;
  }
  
  public String getDebugInfo()
  {
    return "(void*)0x" + Long.toHexString(getValue());
  }
  
  public Function asFunction()
  {
    return asFunction((byte)0);
  }
  
  public Function asFunction(byte paramByte)
  {
    return new Function(getValue(), paramByte);
  }
  
  /**
   * @deprecated
   */
  public void asTypedPointer(Pointer paramPointer)
  {
    castTo(paramPointer);
  }
  
  public void castTo(Pointer paramPointer)
  {
    bg localbg = new bg();
    write(localbg, 0, false);
    paramPointer.read(localbg, 0, false);
  }
  
  public boolean equals(Object paramObject)
  {
    if (!(paramObject instanceof Void)) {
      return false;
    }
    return getValue() == ((Void)paramObject).getValue();
  }
  
  public int hashCode()
  {
    return (int)getValue();
  }
  
  public String toString()
  {
    return getDebugInfo();
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.Pointer.Void
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

public abstract interface DataBuffer
{
  public abstract void writeByte(int paramInt, byte paramByte);
  
  public abstract byte readByte(int paramInt);
  
  public abstract void writeShort(int paramInt, short paramShort);
  
  public abstract short readShort(int paramInt);
  
  public abstract void writeInt(int paramInt1, int paramInt2);
  
  public abstract int readInt(int paramInt);
  
  public abstract void writeLong(int paramInt, long paramLong);
  
  public abstract long readLong(int paramInt);
  
  public abstract void writePointer(int paramInt, long paramLong);
  
  public abstract long readPointer(int paramInt);
  
  public abstract void writeCallbackReference(int paramInt, long paramLong);
  
  public abstract long readCallbackReference(int paramInt);
  
  public abstract void writeByteArray(int paramInt1, byte[] paramArrayOfByte, int paramInt2, int paramInt3);
  
  public abstract void readByteArray(int paramInt1, byte[] paramArrayOfByte, int paramInt2, int paramInt3);
  
  public abstract void writeByteArray(int paramInt, byte[] paramArrayOfByte);
  
  public abstract byte[] readByteArray(int paramInt1, int paramInt2);
  
  public abstract void resize(int paramInt);
}

/* Location:
 * Qualified Name:     com.jniwrapper.DataBuffer
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

public class NoSuchVariableException
  extends JNIWrapperException
{
  public NoSuchVariableException(String paramString)
  {
    super(paramString);
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.NoSuchVariableException
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

import java.util.List;

public class d
  extends h
{
  private int f;
  private int b;
  
  public static int a(d paramd)
  {
    return b;
  }
  
  public d(Structure paramStructure, int paramInt, boolean paramBoolean)
  {
    super(paramStructure.getMembers(), paramInt, paramBoolean);
    
    int i = 0;
    for (int j = 0; j < g.length; j++) {
      if ((g[j] instanceof PrimitiveArray)) {
        i += ((PrimitiveArray)g[j]).getElementCount();
      } else {
        i++;
      }
    }
    if (i > g.length)
    {
      Parameter[] arrayOfParameter = new Parameter[i];
      int k = 0;
      for (int m = 0; k < g.length; k++) {
        if ((g[k] instanceof PrimitiveArray))
        {
          PrimitiveArray localPrimitiveArray = (PrimitiveArray)g[k];
          for (int n = 0; n < localPrimitiveArray.getElementCount(); n++) {
            arrayOfParameter[(m++)] = localPrimitiveArray.getElement(n);
          }
        }
        else
        {
          arrayOfParameter[(m++)] = g[k];
        }
      }
      g = arrayOfParameter;
    }
  }
  
  private boolean b()
  {
    int i = g.length;
    int j = aa.a(g[f], aa.j);
    byte[] arrayOfByte;
    Object localObject1;
    switch (j)
    {
    case 3: 
      this.i.add(new Int32(7));
      if (!a)
      {
        arrayOfByte = Parameter.toByteArray(g[f]);
        localObject1 = new Int32();
        ((Int32)localObject1).read(arrayOfByte, 0);
        this.i.add(localObject1);
      }
      d += 1;
      b += 1;
      break;
    case 4: 
      arrayOfByte = Parameter.toByteArray(g[f]);
      this.i.add(new Int32(7));
      if (!a)
      {
        localObject1 = new Int32();
        ((Int32)localObject1).read(arrayOfByte, 0);
        this.i.add(localObject1);
      }
      this.i.add(new Int32(7));
      if (!a)
      {
        localObject1 = new Int32();
        ((Int32)localObject1).read(arrayOfByte, 4);
        this.i.add(localObject1);
      }
      d += 2;
      b += 2;
      
      break;
    case -1: 
    case 0: 
    case 2: 
      h += 1;
      d += 1;
      this.i.add(new Int32(2));
      if (!a) {
        this.i.add(g[f]);
      }
      b += 1;
      break;
    case 1: 
      h += 1;
      d += 1;
      
      int k = PlatformContext.getLongLength();
      localObject1 = new byte[k];
      int m = 0;
      Object localObject2;
      while (m < k)
      {
        if (!a)
        {
          localObject2 = Parameter.toByteArray(g[f]);
          System.arraycopy(localObject2, 0, localObject1, m, localObject2.length);
        }
        m += g[f].getLength();
        if ((f + 1 == i) || (aa.a(g[(f + 1)], aa.j) != 1) || (m + g[(f + 1)].getLength() > k)) {
          break;
        }
        f += 1;
      }
      if (m > PlatformContext.getIntLength())
      {
        this.i.add(new Int32(2));
        if (!a)
        {
          localObject2 = new Int64();
          ((Int64)localObject2).read((byte[])localObject1, 0);
          this.i.add(localObject2);
        }
        d += 1;
      }
      else
      {
        this.i.add(new Int32(1));
        if (!a)
        {
          localObject2 = new Int32();
          ((Int32)localObject2).read((byte[])localObject1, 0);
          this.i.add(localObject2);
        }
      }
      b += 1;
      
      break;
    default: 
      return false;
    }
    return true;
  }
  
  public boolean a()
  {
    b = 0;
    h = 0;
    d = 0;
    
    Int32 localInt32 = new Int32();
    i.add(localInt32);
    for (f = 0; f < g.length; f += 1) {
      if (!b()) {
        return false;
      }
    }
    localInt32.setValue(b);
    return true;
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.d
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;

public class e
  extends aj
{
  private static final DateFormat n = new SimpleDateFormat("EEE MMM d HH:mm:ss zzz yyyy", Locale.ENGLISH);
  public List g;
  
  public e(InputStream paramInputStream)
    throws IOException
  {
    super(paramInputStream);
  }
  
  public void b(BufferedReader paramBufferedReader)
    throws IOException
  {
    a(b("1m81b2vpljtfnxmoxaelbol"), f(a(paramBufferedReader)));
    a(b("iagms4wv805n13wj3"), a(paramBufferedReader));
    a(b("31kgw2or0myveb8yq91"), a(paramBufferedReader));
    a(b("28lqbdq6yls9p1vraqtfplx"), a(paramBufferedReader));
    a(b("36xzg4lboedkeoqf811"), a(paramBufferedReader));
    a(b("36xzg4lboedkelo46lr"), a(paramBufferedReader));
    a(b("-bb4dw1s9uscwb1"), a(paramBufferedReader));
    a(b("-7nkkov"), paramBufferedReader.readLine());
    a(b("-7nkkou"), paramBufferedReader.readLine());
    a(b("19fxiwileni"), e(a(paramBufferedReader)));
    a(b("1q7n272qd84"), e(a(paramBufferedReader)));
    a(b("5j1bhimjm9oboxe6h14nh47"), e(a(paramBufferedReader)));
    a(b("mwlw9w46mxsl96fjodecolv9odg7e7"), e(a(paramBufferedReader)));
  }
  
  private String a(BufferedReader paramBufferedReader)
    throws IOException
  {
    if (g == null) {
      g = new LinkedList();
    }
    String str = paramBufferedReader.readLine();
    if (str != null) {
      g.add(str);
    }
    return str;
  }
  
  private String b(String paramString)
  {
    return c(paramString);
  }
  
  private static String e(String paramString)
  {
    if (paramString != null)
    {
      int i = paramString.indexOf(":");
      if (i == -1) {
        throw a("Invalid license file");
      }
      return paramString.substring(i + ":".length()).trim();
    }
    return null;
  }
  
  private static String f(String paramString)
  {
    Date localDate = j(paramString);
    return aw.g.format(localDate);
  }
  
  private static Date j(String paramString)
  {
    try
    {
      return n.parse(paramString);
    }
    catch (ParseException localParseException) {}
    return new Date();
  }
  
  public byte[] a(MessageDigest paramMessageDigest)
    throws UnsupportedEncodingException
  {
    paramMessageDigest.update(k("iagms4wv805n13wj3"));
    paramMessageDigest.update(k("31kgw2or0myveb8yq91"));
    paramMessageDigest.update(a(0));
    paramMessageDigest.update(k("36xzg4lboedkeoqf811"));
    paramMessageDigest.update(k("36xzg4lboedkelo46lr"));
    paramMessageDigest.update(k("-bb4dw1s9uscwb1"));
    paramMessageDigest.update(a(7));
    paramMessageDigest.update(a(8));
    if (d())
    {
      paramMessageDigest.update(k("5j1bhimjm9oboxe6h14nh47"));
      paramMessageDigest.update(k("mwlw9w46mxsl96fjodecolv9odg7e7"));
    }
    byte[] arrayOfByte = paramMessageDigest.digest(k("28lqbdq6yls9p1vraqtfplx"));
    return arrayOfByte;
  }
  
  private byte[] k(String paramString)
    throws UnsupportedEncodingException
  {
    String str = c(paramString);
    return i(str).getBytes("UTF-8");
  }
  
  private byte[] a(int paramInt)
    throws UnsupportedEncodingException
  {
    if ((g != null) && (paramInt <= g.size())) {
      return ((String)g.get(paramInt)).getBytes("UTF-8");
    }
    return new byte[0];
  }
  
  private boolean d()
  {
    return g.size() >= 11;
  }
  
  public String f()
  {
    StringBuffer localStringBuffer = new StringBuffer();
    localStringBuffer.append(h(i(b("28lqbdq6yls9p1vraqtfplx"))));
    localStringBuffer.append(h(i(b("iagms4wv805n13wj3"))));
    localStringBuffer.append(h(i(b("31kgw2or0myveb8yq91"))));
    String str = i(b("36xzg4lboedkeoqf811"));
    localStringBuffer.append(str.charAt(0));
    localStringBuffer.append(h(i(b("36xzg4lboedkelo46lr"))));
    if (d())
    {
      localStringBuffer.append(h(i(b("5j1bhimjm9oboxe6h14nh47"))));
      localStringBuffer.append(h(i(b("mwlw9w46mxsl96fjodecolv9odg7e7"))));
    }
    return localStringBuffer.toString();
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.e
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper.jawt;

import com.jniwrapper.Function;
import com.jniwrapper.Int;
import com.jniwrapper.Parameter;
import com.jniwrapper.Pointer;
import com.jniwrapper.Pointer.Void;
import com.jniwrapper.Structure;

public class JAWT_DrawingSurface
  extends Structure
{
  private Pointer.Void j = new Pointer.Void();
  private Pointer.Void h = new Pointer.Void();
  private Pointer.Void e = new Pointer.Void();
  private Pointer.Void k = new Pointer.Void();
  private Pointer.Void n = new Pointer.Void();
  private Pointer.Void g = new Pointer.Void();
  private Pointer c;
  
  public JAWT_DrawingSurface()
  {
    init(new Parameter[] { j, h, e, k, n, g });
    
    c = new Pointer(this);
  }
  
  public JAWT_DrawingSurface(JAWT_DrawingSurface paramJAWT_DrawingSurface)
  {
    this();
    initFrom(paramJAWT_DrawingSurface);
  }
  
  public Pointer c()
  {
    return c;
  }
  
  public int lock()
  {
    Int localInt = new Int();
    e.asFunction().invoke(localInt, c);
    return (int)localInt.getValue();
  }
  
  public void getDrawingSurfaceInfo(Pointer paramPointer)
  {
    k.asFunction().invoke(paramPointer, c);
  }
  
  public void freeDrawingSurfaceInfo(Pointer paramPointer)
  {
    n.asFunction().invoke(null, paramPointer);
  }
  
  public void unlock()
  {
    g.asFunction().invoke(null, c);
  }
  
  public Object clone()
  {
    return new JAWT_DrawingSurface(this);
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.jawt.JAWT_DrawingSurface
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

public class Char
  extends Parameter
{
  public Char()
  {
    this('\000');
  }
  
  public Char(char paramChar)
  {
    super(new o(), 0);
    setValue(paramChar);
  }
  
  public Char(Char paramChar)
  {
    this(paramChar.getValue());
  }
  
  public char getValue()
  {
    return (char)getDataBuffer().readByte(getDataBufferOffset());
  }
  
  public void setValue(char paramChar)
  {
    if (paramChar > '�') {
      throw new IllegalArgumentException("value must be less than 255");
    }
    getDataBuffer().writeByte(getDataBufferOffset(), (byte)paramChar);
  }
  
  public long a()
  {
    return 4L;
  }
  
  public int getLength()
  {
    return 1;
  }
  
  public Object clone()
  {
    return new Char(this);
  }
  
  public Char toChar()
  {
    return new Char(getValue());
  }
  
  public boolean equals(Object paramObject)
  {
    if ((paramObject instanceof Char)) {
      return getValue() == ((Char)paramObject).getValue();
    }
    return super.equals(paramObject);
  }
  
  public int hashCode()
  {
    return getValue();
  }
  
  public void write(DataBuffer paramDataBuffer, int paramInt, boolean paramBoolean)
    throws MemoryAccessViolationException
  {
    paramDataBuffer.writeByte(paramInt, (byte)getValue());
  }
  
  public void read(DataBuffer paramDataBuffer, int paramInt, boolean paramBoolean)
    throws MemoryAccessViolationException
  {
    setValue((char)paramDataBuffer.readByte(paramInt));
  }
  
  public void push(DataBuffer paramDataBuffer, int paramInt, boolean paramBoolean)
    throws MemoryAccessViolationException
  {
    if (!paramBoolean) {
      paramDataBuffer.writeByte(paramInt, (byte)getValue());
    }
  }
  
  public void pop(DataBuffer paramDataBuffer, int paramInt, boolean paramBoolean)
    throws MemoryAccessViolationException
  {
    if (paramBoolean) {
      setValue((char)paramDataBuffer.readByte(paramInt));
    }
  }
  
  public String getDebugInfo()
  {
    return getClass().getName() + " value: " + String.valueOf(getValue());
  }
  
  public String toString()
  {
    return Character.toString(getValue());
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.Char
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

import java.io.PrintStream;
import java.text.DateFormat;
import java.text.MessageFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;

public class f
{
  public static final SimpleDateFormat g = new SimpleDateFormat("dd-MM-yyyy", Locale.ENGLISH);
  public String a;
  public String d;
  public as h;
  private long f = 0L;
  private aj c = null;
  
  public f(String paramString1, String paramString2, String paramString3, String paramString4)
  {
    d = paramString1;
    h = new c(d, paramString2, paramString3);
    a = paramString4;
  }
  
  public f(String paramString1, String paramString2, as paramas)
  {
    d = paramString1;
    a = paramString2;
    h = paramas;
  }
  
  public String b(String paramString)
  {
    if (c != null) {
      return c.i(paramString);
    }
    return null;
  }
  
  public synchronized void c()
  {
    try
    {
      Date localDate = new Date();
      
      long l = localDate.getTime();
      if ((f != 0L) && (l - f < 86400000L)) {
        return;
      }
      List localList = h.c();
      for (Iterator localIterator = localList.iterator(); localIterator.hasNext();) {
        try
        {
          ah localah = (ah)localIterator.next();
          String str = MessageFormat.format("Checking {0} license {1}:", new Object[] { d, localah.b() });
          a(str);
          aj localaj = localah.a();
          if (!localaj.c()) {
            throw a(d, "Signature is not valid.");
          }
          a(localaj, localDate);
          c = localah.a();
        }
        catch (RuntimeException localRuntimeException2)
        {
          a(localRuntimeException2);
        }
      }
      if (c == null) {
        throw a(d, "No valid license found.");
      }
      a(MessageFormat.format("{0} license valid.", new Object[] { d }));
      f = l;
    }
    catch (RuntimeException localRuntimeException1)
    {
      a(localRuntimeException1);
      throw localRuntimeException1;
    }
    catch (Error localError)
    {
      a(localError);
      throw localError;
    }
  }
  
  public void a(aj paramaj, Date paramDate)
  {
    String str1 = paramaj.i("Product");
    String str2 = paramaj.i("Version");
    String str3 = paramaj.i("Licensed to");
    String str4 = paramaj.i("License type");
    Date localDate1 = a(paramaj);
    String str5 = paramaj.i("License info");
    String str6 = paramaj.i("Product binding");
    String str7 = paramaj.g("Product binding info");
    
    long l = localDate1 != null ? localDate1.getTime() : 0L;
    Date localDate2 = b(paramaj);
    
    a("-- Product name: " + str1);
    a("-- Licensed version: " + str2);
    a("-- Licensed to: " + str3);
    a("-- License type: " + str4);
    if (str6 != null) {
      a("-- License bound to product: " + str6);
    }
    a("-- Generation date: " + a(localDate2));
    a("-- Expiration date: " + (localDate1 != null ? a(localDate1) : aj.c("1js3qp8y")));
    a("-- License info: " + str5);
    a("-- Current date: " + a(paramDate));
    a();
    if (!d.equals(str1)) {
      throw a(d, "Wrong product name.");
    }
    if (!str2.startsWith(a)) {
      throw a(d, "Wrong product version. Required: " + a + "x, found: " + str2 + '.');
    }
    if (str6 != null) {
      try
      {
        Class.forName(str7);
      }
      catch (ClassNotFoundException localClassNotFoundException)
      {
        throw a(d, "This license can only be used with " + str6);
      }
    }
    if ((localDate1 != null) && (paramDate.getTime() >= l)) {
      throw a(d, d());
    }
  }
  
  public void a(String paramString)
  {
    System.out.println(paramString);
  }
  
  public void a(String paramString, Throwable paramThrowable)
  {
    System.out.println(paramString);
    paramThrowable.printStackTrace();
  }
  
  public String d()
  {
    return "License has expired.";
  }
  
  public void a() {}
  
  private void a(Throwable paramThrowable)
  {
    try
    {
      a(paramThrowable.getMessage());
    }
    catch (Exception localException)
    {
      System.out.println(paramThrowable.getMessage());
    }
    for (Throwable localThrowable = paramThrowable; localThrowable != null; localThrowable = localThrowable.getCause()) {
      localThrowable.setStackTrace(new StackTraceElement[0]);
    }
  }
  
  private String a(Date paramDate)
  {
    return SimpleDateFormat.getDateInstance(2).format(paramDate);
  }
  
  public static RuntimeException a(String paramString1, String paramString2)
  {
    String str = MessageFormat.format("{0} license check failed: {1}", new Object[] { paramString1, paramString2 });
    
    return new RuntimeException(str);
  }
  
  private Date b(aj paramaj)
  {
    String str = paramaj.i("Generation date");
    if (str == null) {
      throw a(d, "No generation date field found in the license file");
    }
    try
    {
      return g.parse(str);
    }
    catch (ParseException localParseException)
    {
      throw a(d, "Couldn't parse license generation date: " + str);
    }
  }
  
  private Date a(aj paramaj)
  {
    String str = paramaj.i("Expiration date");
    if (str == null) {
      throw a(d, "No expiration date field found in the license file");
    }
    if (str.toUpperCase().equals(aj.c("1js3qp8y"))) {
      return null;
    }
    try
    {
      return g.parse(str);
    }
    catch (ParseException localParseException)
    {
      throw a(d, "Couldn't parse license expiration date: " + str);
    }
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.f
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper.util;

import com.jniwrapper.DefaultLibraryLoader;
import com.jniwrapper.Library;
import com.jniwrapper.NativeResourceCollector;
import java.applet.Applet;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;

public class AppletHelper
{
  private static AppletHelper a = new AppletHelper();
  
  public static AppletHelper getInstance()
  {
    return a;
  }
  
  public static void setInstance(AppletHelper paramAppletHelper)
  {
    a = paramAppletHelper;
  }
  
  private void b(Applet paramApplet)
    throws IOException
  {
    URL localURL = a(paramApplet);
    a(localURL);
  }
  
  private static URL a(Applet paramApplet)
    throws IOException
  {
    return a(paramApplet.getCodeBase(), a());
  }
  
  private void a(URL paramURL)
    throws IOException
  {
    File localFile = b();
    if (!localFile.exists()) {
      a(paramURL, localFile);
    }
    DefaultLibraryLoader.getInstance().addPath(localFile.getParentFile());
  }
  
  private void a(URL paramURL, File paramFile)
    throws IOException
  {
    BufferedInputStream localBufferedInputStream = new BufferedInputStream(paramURL.openStream());
    BufferedOutputStream localBufferedOutputStream = new BufferedOutputStream(new FileOutputStream(paramFile));
    
    StreamUtils.copy(localBufferedInputStream, localBufferedOutputStream, 1024);
    
    localBufferedInputStream.close();
    localBufferedOutputStream.close();
  }
  
  private File b()
    throws IOException
  {
    File localFile = File.createTempFile("someTemp", "txt");
    
    return new File(localFile.getParentFile(), a());
  }
  
  public void init(Applet paramApplet)
    throws IOException
  {
    b(paramApplet);
  }
  
  public void init(URL paramURL)
    throws IOException
  {
    a(paramURL);
  }
  
  public void start()
  {
    NativeResourceCollector.getInstance().start();
  }
  
  public void stop()
  {
    NativeResourceCollector.getInstance().stop();
  }
  
  private static String a()
  {
    return Library.NATIVE_NAME;
  }
  
  private static URL a(URL paramURL, String paramString)
    throws IOException
  {
    StringBuffer localStringBuffer = new StringBuffer();
    String str = paramURL.toString();
    localStringBuffer.append(str);
    if (!str.endsWith("/")) {
      localStringBuffer.append("/");
    }
    localStringBuffer.append(paramString);
    return new URL(localStringBuffer.toString());
  }
  
  public void loadLibrary(Applet paramApplet, String paramString)
    throws IOException
  {
    URL localURL = a(paramApplet.getCodeBase(), System.mapLibraryName(paramString));
    a(localURL);
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.util.AppletHelper
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

import java.nio.ByteBuffer;

public class g
  implements DataBuffer
{
  public static final int b = ;
  private ByteBuffer c;
  
  public g() {}
  
  public g(ByteBuffer paramByteBuffer)
  {
    c = paramByteBuffer;
  }
  
  public ByteBuffer getBuffer()
  {
    return c;
  }
  
  public void a(ByteBuffer paramByteBuffer)
  {
    c = paramByteBuffer;
  }
  
  public void writeByte(int paramInt, byte paramByte)
  {
    getBuffer().put(paramInt, paramByte);
  }
  
  public byte readByte(int paramInt)
  {
    return getBuffer().get(paramInt);
  }
  
  public void writeShort(int paramInt, short paramShort)
  {
    getBuffer().putShort(paramInt, paramShort);
  }
  
  public short readShort(int paramInt)
  {
    return getBuffer().getShort(paramInt);
  }
  
  public void writeInt(int paramInt1, int paramInt2)
  {
    getBuffer().putInt(paramInt1, paramInt2);
  }
  
  public int readInt(int paramInt)
  {
    return getBuffer().getInt(paramInt);
  }
  
  public void writeLong(int paramInt, long paramLong)
  {
    getBuffer().putLong(paramInt, paramLong);
  }
  
  public long readLong(int paramInt)
  {
    return getBuffer().getLong(paramInt);
  }
  
  public void writePointer(int paramInt, long paramLong)
  {
    ByteBuffer localByteBuffer = getBuffer();
    if (b > 4) {
      localByteBuffer.putLong(paramInt, paramLong);
    } else {
      localByteBuffer.putInt(paramInt, (int)paramLong);
    }
  }
  
  public long readPointer(int paramInt)
  {
    ByteBuffer localByteBuffer = getBuffer();
    if (b > 4) {
      return localByteBuffer.getLong(paramInt);
    }
    return localByteBuffer.getInt(paramInt);
  }
  
  public void writeCallbackReference(int paramInt, long paramLong)
  {
    ByteBuffer localByteBuffer = getBuffer();
    if (b > 4) {
      localByteBuffer.putLong(paramInt, paramLong);
    } else {
      localByteBuffer.putInt(paramInt, (int)paramLong);
    }
  }
  
  public long readCallbackReference(int paramInt)
  {
    ByteBuffer localByteBuffer = getBuffer();
    if (b > 4) {
      return localByteBuffer.getLong(paramInt);
    }
    return localByteBuffer.getInt(paramInt);
  }
  
  public void writeByteArray(int paramInt1, byte[] paramArrayOfByte, int paramInt2, int paramInt3)
  {
    ((ByteBuffer)getBuffer().position(paramInt1)).put(paramArrayOfByte, paramInt2, paramInt3);
  }
  
  public void readByteArray(int paramInt1, byte[] paramArrayOfByte, int paramInt2, int paramInt3)
  {
    ((ByteBuffer)getBuffer().position(paramInt1)).get(paramArrayOfByte, paramInt2, paramInt3);
  }
  
  public void writeByteArray(int paramInt, byte[] paramArrayOfByte)
  {
    writeByteArray(paramInt, paramArrayOfByte, 0, paramArrayOfByte.length);
  }
  
  public byte[] readByteArray(int paramInt1, int paramInt2)
  {
    byte[] arrayOfByte = new byte[paramInt2];
    readByteArray(paramInt1, arrayOfByte, 0, paramInt2);
    return arrayOfByte;
  }
  
  public void resize(int paramInt)
  {
    throw new UnsupportedOperationException("Method resize() is not implemented");
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.g
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

import java.math.BigInteger;

public class UInt64
  extends Int64
{
  public static final BigInteger MAX_UINT64 = new BigInteger("18446744073709551615");
  private static final BigInteger c = MAX_UINT64.add(BigInteger.ONE);
  
  public UInt64()
  {
    super(0L);
  }
  
  public UInt64(long paramLong)
  {
    if (paramLong < 0L) {
      throw new IllegalArgumentException("The value is less than zero");
    }
    setValue(paramLong);
  }
  
  public UInt64(IntegerParameter paramIntegerParameter)
  {
    this(paramIntegerParameter.getValue());
  }
  
  public UInt64(BigInteger paramBigInteger)
  {
    setValue(paramBigInteger);
  }
  
  public void setValue(BigInteger paramBigInteger)
  {
    if (paramBigInteger.compareTo(MAX_UINT64) > 0) {
      throw new IllegalArgumentException("The value " + paramBigInteger.toString() + " is bigger than maximum allowed value " + MAX_UINT64.toString());
    }
    if (paramBigInteger.compareTo(BigInteger.ZERO) < 0) {
      throw new IllegalArgumentException("The value is less than zero");
    }
    setValue(a(paramBigInteger));
  }
  
  public long getValue()
  {
    return super.getValue();
  }
  
  public BigInteger toBigInteger()
  {
    return a(getValue());
  }
  
  private static BigInteger a(long paramLong)
  {
    BigInteger localBigInteger1 = BigInteger.valueOf(paramLong);
    if (paramLong < 0L)
    {
      BigInteger localBigInteger2 = c.add(localBigInteger1);
      return localBigInteger2;
    }
    return localBigInteger1;
  }
  
  private static long a(BigInteger paramBigInteger)
  {
    if (paramBigInteger.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0)
    {
      BigInteger localBigInteger = c.subtract(paramBigInteger);
      return -localBigInteger.longValue();
    }
    return paramBigInteger.longValue();
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.UInt64
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

public abstract interface ArrayParameter
{
  public abstract Parameter getElement(int paramInt);
  
  public abstract void setElement(int paramInt, Parameter paramParameter);
  
  public abstract int getElementCount();
  
  public abstract void setElementCount(int paramInt);
  
  public abstract Parameter[] toParameterArray();
  
  public abstract void fromParameterArray(Parameter[] paramArrayOfParameter);
  
  public abstract void forceElementCount(int paramInt);
}

/* Location:
 * Qualified Name:     com.jniwrapper.ArrayParameter
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

import java.util.LinkedList;
import java.util.List;

public abstract class h
{
  public List i = new LinkedList();
  public int h = 0;
  public int d = 0;
  public Parameter[] g;
  public int e;
  public int c;
  public boolean a;
  
  public h(Parameter[] paramArrayOfParameter, int paramInt, boolean paramBoolean)
  {
    g = paramArrayOfParameter;
    e = (paramInt / 8);
    c = (paramInt / 4);
    a = paramBoolean;
  }
  
  public List c()
  {
    return i;
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.h
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

import java.nio.ByteBuffer;

public final class MemoryManager
{
  public static native ByteBuffer createBuffer(long paramLong, int paramInt);
  
  public static native long alloc(int paramInt);
  
  public static native void free(long paramLong);
  
  public static native long realloc(long paramLong, int paramInt);
  
  static
  {
    Library.ensureNativeCode();
    aw.e().c();
  }
}

/* Location:
 * Qualified Name:     com.jniwrapper.MemoryManager
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.jniwrapper;

import java.security.PrivilegedAction;

public 
1 2 3 4 5 6 7 8 9 10 11

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2017. Infinite Loop Ltd