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