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