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