home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1997 October / PCO1097.ISO / FilesBBS / OS2 / NETREXX.ARJ / NETREXX.ZIP / NetRexx / netrexx / lang / RexxUtil.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-08-03  |  6.3 KB  |  569 lines
  1. package netrexx.lang;
  2.  
  3. public final class RexxUtil extends Rexx {
  4.    protected static final Rexx one = new Rexx(1);
  5.    protected static final Rexx sixteen = new Rexx(16);
  6.    private static final Rexx $$24 = new Rexx('0');
  7.    // $FF: renamed from: $0 java.lang.String
  8.    private static final String field_0 = "RexxUtil.nrx";
  9.  
  10.    public static final char[] translate(char[] var0, char[] var1, char[] var2, char var3) {
  11.       boolean var5 = false;
  12.       char var7 = '\u0000';
  13.       char var9 = '\u0000';
  14.       if (var2.length == 0) {
  15.          return var0;
  16.       } else {
  17.          int var4 = -1;
  18.          int var10 = var2.length - 1;
  19.  
  20.          for(int var14 = 0; var14 <= var10; ++var14) {
  21.             if (var2[var14] > var4) {
  22.                var4 = var2[var14];
  23.             }
  24.          }
  25.  
  26.          char[] var6 = new char[var4 + 1];
  27.          int var11 = var4;
  28.  
  29.          for(int var15 = 0; var15 <= var11; ++var15) {
  30.             var6[var15] = (char)var15;
  31.          }
  32.  
  33.          byte var12 = 0;
  34.  
  35.          for(int var16 = var2.length - 1; var16 >= var12; --var16) {
  36.             if (var16 >= var1.length) {
  37.                var7 = var3;
  38.             } else {
  39.                var7 = var1[var16];
  40.             }
  41.  
  42.             var6[var2[var16]] = var7;
  43.          }
  44.  
  45.          char[] var8 = new char[var0.length];
  46.          int var13 = var0.length - 1;
  47.  
  48.          for(int var17 = 0; var17 <= var13; ++var17) {
  49.             var9 = var0[var17];
  50.             if (var9 > var4) {
  51.                var8[var17] = (char)var9;
  52.             } else {
  53.                var8[var17] = var6[var9];
  54.             }
  55.          }
  56.  
  57.          return var8;
  58.       }
  59.    }
  60.  
  61.    public static final char[] d2x(Rexx var0, int var1) {
  62.       Object var2 = null;
  63.       Object var3 = null;
  64.       boolean var4 = false;
  65.       byte var5 = 0;
  66.       int var6 = 0;
  67.       boolean var8 = false;
  68.       int var9 = 0;
  69.       boolean var10 = false;
  70.       int var11 = 0;
  71.       Object var12 = null;
  72.       if (var0.ind == -2) {
  73.          throw new NumberFormatException(Rexx.toString(var0));
  74.       } else {
  75.          RexxSet var15;
  76.          if (var0.mant.length > 9) {
  77.             var15 = new RexxSet(var0.mant.length);
  78.          } else {
  79.             var15 = null;
  80.          }
  81.  
  82.          Rexx var16;
  83.          if (var0.ind == -1) {
  84.             if (var1 < 0) {
  85.                throw new BadArgumentException(Rexx.toString(var0));
  86.             }
  87.  
  88.             var16 = var0.OpMinus(var15).OpSub(var15, one);
  89.             var4 = true;
  90.             var5 = 70;
  91.          } else {
  92.             var16 = var0;
  93.             var4 = false;
  94.             var5 = 48;
  95.          }
  96.  
  97.          if (var1 < 0) {
  98.             var6 = var16.mant.length;
  99.          } else {
  100.             var6 = var1;
  101.          }
  102.  
  103.          char[] var7 = new char[var6];
  104.          byte var13 = 0;
  105.  
  106.          for(int var20 = var7.length - 1; var20 >= var13; --var20) {
  107.             var9 = var16.OpRem(var15, sixteen).toint();
  108.             var16 = var16.OpDivI(var15, sixteen);
  109.             if (var4) {
  110.                var7[var20] = Rexx.Hexes[15 - var9];
  111.             } else {
  112.                var7[var20] = Rexx.Hexes[var9];
  113.             }
  114.  
  115.             if (var16.ind == 0) {
  116.                if (var1 < 0) {
  117.                   if (var20 == 0) {
  118.                      return var7;
  119.                   }
  120.  
  121.                   var11 = var7.length - var20;
  122.                   char[] var24 = new char[var11];
  123.                   System.arraycopy(var7, var20, var24, 0, var11);
  124.                   return var24;
  125.                }
  126.  
  127.                byte var14 = 0;
  128.  
  129.                for(int var22 = var20 - 1; var22 >= var14; --var22) {
  130.                   var7[var22] = (char)var5;
  131.                }
  132.                break;
  133.             }
  134.          }
  135.  
  136.          return var7;
  137.       }
  138.    }
  139.  
  140.    public static final char[] x2b(Rexx var0) {
  141.       boolean var2 = false;
  142.       int var3 = 0;
  143.       int var4 = 0;
  144.       char[] var1 = new char[var0.chars.length * 4];
  145.       int var5 = var0.chars.length;
  146.  
  147.       for(int var6 = 0; var5 > 0; ++var6) {
  148.          --var5;
  149.          var3 = hexint(var0.chars[var6]);
  150.          if (var3 < 0) {
  151.             throw new BadArgumentException(Rexx.toString(Rexx.toRexx("Bad hexadecimal").OpCcblank((RexxSet)null, var0)));
  152.          }
  153.  
  154.          var4 = var6 * 4;
  155.          if (var3 > 7) {
  156.             var1[var4] = '1';
  157.          } else {
  158.             var1[var4] = '0';
  159.          }
  160.  
  161.          if ((var3 & 4) != 0) {
  162.             var1[var4 + 1] = '1';
  163.          } else {
  164.             var1[var4 + 1] = '0';
  165.          }
  166.  
  167.          if ((var3 & 2) != 0) {
  168.             var1[var4 + 2] = '1';
  169.          } else {
  170.             var1[var4 + 2] = '0';
  171.          }
  172.  
  173.          if ((var3 & 1) != 0) {
  174.             var1[var4 + 3] = '1';
  175.          } else {
  176.             var1[var4 + 3] = '0';
  177.          }
  178.       }
  179.  
  180.       return var1;
  181.    }
  182.  
  183.    public static final char x2c(Rexx var0) {
  184.       int var1 = 0;
  185.       int var3 = 0;
  186.       int var4 = var0.chars.length - 2;
  187.  
  188.       for(var1 = 0; var1 <= var4 && var0.chars[var1] == '0'; ++var1) {
  189.       }
  190.  
  191.       int var2 = 0;
  192.  
  193.       for(int var5 = var0.chars.length - 1; var1 <= var5; ++var1) {
  194.          var3 = hexint(var0.chars[var1]);
  195.          if (var3 < 0) {
  196.             throw new BadArgumentException(Rexx.toString(Rexx.toRexx("Bad hexadecimal").OpCcblank((RexxSet)null, var0)));
  197.          }
  198.  
  199.          var2 = var2 * 16 + var3;
  200.          if (var2 > 65535) {
  201.             throw new BadArgumentException(Rexx.toString(Rexx.toRexx("Too big").OpCcblank((RexxSet)null, var0)));
  202.          }
  203.       }
  204.  
  205.       return (char)var2;
  206.    }
  207.  
  208.    public static final char[] x2d(Rexx var0, int var1) {
  209.       int var3 = 0;
  210.       Object var5 = null;
  211.       boolean var7 = false;
  212.       int var8 = 0;
  213.       boolean var2 = false;
  214.       if (var1 == 0 | var0.chars.length == 0) {
  215.          return Rexx.tochararray($$24);
  216.       } else {
  217.          if (var1 < 0) {
  218.             var3 = 0;
  219.          } else if (var1 > var0.chars.length) {
  220.             var3 = 0;
  221.          } else {
  222.             var3 = var0.chars.length - var1;
  223.             if (var0.chars[var3] > '7' | var0.chars[var3] < '0') {
  224.                var2 = true;
  225.             }
  226.          }
  227.  
  228.          int var4 = var0.chars.length * 5 / 4 + 1;
  229.          RexxSet var11;
  230.          if (var4 > 9) {
  231.             var11 = new RexxSet(var4);
  232.          } else {
  233.             var11 = null;
  234.          }
  235.  
  236.          Rexx var6 = new Rexx(0);
  237.          int var9 = var0.chars.length - 1;
  238.  
  239.          for(int var12 = var3; var12 <= var9; ++var12) {
  240.             var8 = hexint(var0.chars[var12]);
  241.             if (var8 < 0) {
  242.                throw new BadArgumentException(Rexx.toString(Rexx.toRexx("Bad hexadecimal").OpCcblank((RexxSet)null, var0)));
  243.             }
  244.  
  245.             if (var2) {
  246.                var8 = 15 - var8;
  247.             }
  248.  
  249.             var6 = var6.OpMult(var11, sixteen).OpAdd(var11, new Rexx(var8));
  250.          }
  251.  
  252.          if (var2) {
  253.             var6 = var6.OpAdd(var11, one).OpMinus(var11);
  254.          }
  255.  
  256.          return Rexx.tochararray(var6);
  257.       }
  258.    }
  259.  
  260.    public static final double doublePow(double var0, int var2) {
  261.       boolean var3 = false;
  262.       int var6 = 0;
  263.       if (var2 == 0) {
  264.          return (double)1.0F;
  265.       } else {
  266.          if (var2 > 0) {
  267.             var3 = false;
  268.          } else {
  269.             var2 = -var2;
  270.             var3 = true;
  271.          }
  272.  
  273.          double var4 = (double)1.0F;
  274.          var6 = 1;
  275.  
  276.          while(true) {
  277.             var2 += var2;
  278.             if (var2 < 0) {
  279.                var4 *= var0;
  280.             }
  281.  
  282.             if (var6 == 31) {
  283.                if (Double.isInfinite(var4)) {
  284.                   throw new NumberFormatException("Overflow");
  285.                }
  286.  
  287.                if (var3) {
  288.                   return (double)1.0F / var4;
  289.                }
  290.  
  291.                return var4;
  292.             }
  293.  
  294.             var4 *= var4;
  295.             ++var6;
  296.          }
  297.       }
  298.    }
  299.  
  300.    public static final float floatPow(double var0, int var2) {
  301.       float var3 = (float)doublePow(var0, var2);
  302.       if (Float.isInfinite(var3)) {
  303.          throw new NumberFormatException("Overflow");
  304.       } else {
  305.          return var3;
  306.       }
  307.    }
  308.  
  309.    public static final Rexx doubleToRexx(double var0, int var2) {
  310.       boolean var5 = false;
  311.       Object var14 = null;
  312.       long var3 = Double.doubleToLongBits(var0);
  313.       if (var3 >= 0L) {
  314.          var5 = false;
  315.       } else {
  316.          var5 = true;
  317.          var3 &= Long.MAX_VALUE;
  318.       }
  319.  
  320.       if (var3 == 0L) {
  321.          return new Rexx(0);
  322.       } else {
  323.          long var6 = var3 % 4503599627370496L;
  324.          long var8 = var6 | 4503599627370496L;
  325.          long var10 = var3 / 4503599627370496L;
  326.          if (var10 == 2047L) {
  327.             return var6 == 0L ? Rexx.toRexx("Infinity") : Rexx.toRexx("NaN");
  328.          } else {
  329.             RexxSet var12 = new RexxSet(var2 + 2);
  330.             Rexx var13 = (new Rexx(var8)).OpDiv(var12, new Rexx("4503599627370496"));
  331.             if (var10 != 0L) {
  332.                Rexx var16 = (new Rexx((byte)2)).OpPow(var12, new Rexx(var10 - 1023L));
  333.                var13 = var13.OpMult(var12, var16);
  334.             }
  335.  
  336.             var12.digits = var2;
  337.             if (var5 && var13.ind == 1) {
  338.                var13.ind = -1;
  339.             }
  340.  
  341.             return var13.OpDiv(var12, one);
  342.          }
  343.       }
  344.    }
  345.  
  346.    public static final char[] trunc(Rexx var0, int var1) {
  347.       Object var2 = null;
  348.       RexxSet var4;
  349.       if (var0.mant.length > 9) {
  350.          var4 = new RexxSet(var0.mant.length);
  351.       } else {
  352.          var4 = null;
  353.       }
  354.  
  355.       var0 = var0.OpPlus(var4);
  356.       return nonexp(var0, var1, false);
  357.    }
  358.  
  359.    public static final char[] nonexp(Rexx var0, int var1, boolean var2) {
  360.       Object var4 = null;
  361.       Object var7 = null;
  362.       boolean var8 = false;
  363.       int var3 = var0.mant.length + var1;
  364.       if (var0.exp > 0) {
  365.          var3 += var0.exp;
  366.       }
  367.  
  368.       RexxSet var11;
  369.       if (var3 > 9) {
  370.          var11 = new RexxSet(var3);
  371.       } else {
  372.          var11 = null;
  373.       }
  374.  
  375.       var0.exp += var1;
  376.       boolean var5 = false;
  377.       byte var6 = var0.ind;
  378.       if (var2 && var0.exp < 0 && var0.mant.length + var0.exp >= 0) {
  379.          var5 = var0.mant[var0.mant.length + var0.exp] >= '5';
  380.       }
  381.  
  382.       var0 = var0.OpDivI(var11, one);
  383.       if (var5) {
  384.          if (var6 == -1) {
  385.             var0 = var0.OpSub(var11, one);
  386.          } else {
  387.             var0 = var0.OpAdd(var11, one);
  388.          }
  389.       }
  390.  
  391.       if (var0.ind == 0) {
  392.          var0.exp = var1;
  393.       }
  394.  
  395.       if (var0.exp > 0) {
  396.          char[] var12 = new char[var0.mant.length + var0.exp];
  397.          System.arraycopy(var0.mant, 0, var12, 0, var0.mant.length);
  398.          int var9 = var12.length - 1;
  399.  
  400.          for(int var13 = var0.mant.length; var13 <= var9; ++var13) {
  401.             var12[var13] = '0';
  402.          }
  403.  
  404.          var0.mant = var12;
  405.          var0.exp = 0;
  406.       }
  407.  
  408.       var0.exp -= var1;
  409.       return var0.layoutnum();
  410.    }
  411.  
  412.    public static final char[] format(Rexx var0, int var1, int var2, int var3, int var4, char var5) {
  413.       Object var6 = null;
  414.       Object var7 = null;
  415.       int var8 = 0;
  416.       int var9 = 0;
  417.       Object var10 = null;
  418.       boolean var11 = false;
  419.       boolean var12 = false;
  420.       Object var13 = null;
  421.       int var14 = 0;
  422.       int var15 = 0;
  423.       int var16 = 0;
  424.       RexxSet var19;
  425.       if (var0.mant.length > 9) {
  426.          var19 = new RexxSet(var0.mant.length);
  427.       } else {
  428.          var19 = null;
  429.       }
  430.  
  431.       var0 = var0.OpPlus(var19);
  432.       char[] var20;
  433.       if (var4 == -1) {
  434.          if (var2 == -1) {
  435.             if (var0.exp >= 0) {
  436.                var2 = 0;
  437.             } else {
  438.                var2 = -var0.exp;
  439.             }
  440.          }
  441.  
  442.          var20 = nonexp(var0, var2, true);
  443.       } else {
  444.          if (var2 >= 0) {
  445.             while(true) {
  446.                if (var5 == 'S') {
  447.                   var8 = var0.mant.length - 1;
  448.                } else {
  449.                   var9 = (var0.exp + var0.mant.length - 1) % 3;
  450.                   if (var9 < 0) {
  451.                      var9 += 3;
  452.                   }
  453.  
  454.                   ++var9;
  455.                   if (var9 >= var0.mant.length) {
  456.                      var8 = 0;
  457.                   } else {
  458.                      var8 = var0.mant.length - var9;
  459.                   }
  460.                }
  461.  
  462.                if (var8 == var2) {
  463.                   break;
  464.                }
  465.  
  466.                if (var8 < var2) {
  467.                   char[] var25 = new char[var0.mant.length + var2 - var8];
  468.                   System.arraycopy(var0.mant, 0, var25, 0, var0.mant.length);
  469.                   int var17 = var25.length - 1;
  470.  
  471.                   for(int var26 = var0.mant.length; var26 <= var17; ++var26) {
  472.                      var25[var26] = '0';
  473.                   }
  474.  
  475.                   var0.mant = var25;
  476.                   var0.exp -= var2 - var8;
  477.                   if (var0.exp < -999999999) {
  478.                      throw new ExponentOverflowException();
  479.                   }
  480.                   break;
  481.                }
  482.  
  483.                var12 = var0.mant[var0.mant.length - (var8 - var2)] >= '5';
  484.                char[] var24 = new char[var0.mant.length - (var8 - var2)];
  485.                System.arraycopy(var0.mant, 0, var24, 0, var24.length);
  486.                var0.mant = var24;
  487.                var0.exp += var8 - var2;
  488.                if (var0.exp > 999999999) {
  489.                   throw new ExponentOverflowException();
  490.                }
  491.  
  492.                if (!var12) {
  493.                   break;
  494.                }
  495.  
  496.                Rexx var28 = new Rexx(1);
  497.                var28.ind = var0.ind;
  498.                var28.exp = var0.exp;
  499.                var0 = var0.OpAdd(var19, var28);
  500.             }
  501.          }
  502.  
  503.          if (var5 == 'S') {
  504.             var0.form = 0;
  505.          } else {
  506.             var0.form = 1;
  507.          }
  508.  
  509.          var0.dig = var4;
  510.          var20 = var0.layoutnum();
  511.       }
  512.  
  513.       if (var1 > 0) {
  514.          var14 = RexxWords.pos('.', var20, 1);
  515.          if (var14 > 0) {
  516.             --var14;
  517.          } else if (var4 == -1) {
  518.             var14 = var20.length;
  519.          } else {
  520.             var14 = RexxWords.pos('E', var20, 1);
  521.             if (var14 > 0) {
  522.                --var14;
  523.             } else {
  524.                var14 = var20.length;
  525.             }
  526.          }
  527.  
  528.          if (var14 > var1) {
  529.             throw new BadArgumentException(String.valueOf(var1));
  530.          }
  531.  
  532.          if (var14 < var1) {
  533.             var20 = (new Rexx(var20, true)).right(new Rexx(var20.length + var1 - var14)).toCharArray();
  534.          }
  535.       }
  536.  
  537.       if (var3 > 0) {
  538.          var15 = RexxWords.pos('E', var20, 1);
  539.          if (var15 == 0) {
  540.             var20 = (new Rexx(var20, true)).left(new Rexx(var20.length + var3 + 2)).toCharArray();
  541.          } else {
  542.             var16 = var20.length - var15 - 1;
  543.             if (var16 > var3) {
  544.                throw new BadArgumentException(String.valueOf(var3));
  545.             }
  546.  
  547.             if (var16 < var3) {
  548.                var20 = (new Rexx(var20, true)).insert(Rexx.toRexx(""), new Rexx(var15 + 1), new Rexx(var3 - var16), new Rexx('0')).toCharArray();
  549.             }
  550.          }
  551.       }
  552.  
  553.       return var20;
  554.    }
  555.  
  556.    private static int hexint(char var0) {
  557.       if (var0 >= '0' && var0 <= '9') {
  558.          return var0 - 48;
  559.       } else if (var0 >= 'A' && var0 <= 'F') {
  560.          return var0 - 65 + 10;
  561.       } else {
  562.          return var0 >= 'a' && var0 <= 'f' ? var0 - 97 + 10 : -1;
  563.       }
  564.    }
  565.  
  566.    private RexxUtil() {
  567.    }
  568. }
  569.