home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1997 October / PCO1097.ISO / FilesBBS / OS2 / NETREXX.ARJ / NETREXX.ZIP / NetRexx / netrexx / lang / RexxWords.class (.txt) < prev   
Encoding:
Java Class File  |  1997-08-03  |  4.9 KB  |  633 lines
  1. package netrexx.lang;
  2.  
  3. public final class RexxWords {
  4.    // $FF: renamed from: $0 java.lang.String
  5.    private static final String field_0 = "RexxWords.nrx";
  6.  
  7.    public static boolean abbrev(char[] var0, char[] var1, int var2) {
  8.       boolean var3 = false;
  9.       if (var0.length < var2 | var1.length < var2) {
  10.          return false;
  11.       } else if (var1.length > var0.length) {
  12.          return false;
  13.       } else if (var1.length == 0 & var2 == 0) {
  14.          return true;
  15.       } else {
  16.          int var4 = var1.length - 1;
  17.  
  18.          for(int var5 = 0; var5 <= var4; ++var5) {
  19.             if (var0[var5] != var1[var5]) {
  20.                return false;
  21.             }
  22.          }
  23.  
  24.          return true;
  25.       }
  26.    }
  27.  
  28.    public static char[] centre(char[] var0, int var1, char var2) {
  29.       int var5 = 0;
  30.       boolean var6 = false;
  31.       int var3 = var0.length - var1;
  32.       if (var3 == 0) {
  33.          return var0;
  34.       } else {
  35.          char[] var4 = new char[var1];
  36.          if (var3 > 0) {
  37.             System.arraycopy(var0, var3 / 2, var4, 0, var1);
  38.          } else {
  39.             var5 = -var3 / 2;
  40.             int var7 = var5 - 1;
  41.  
  42.             for(int var10 = 0; var10 <= var7; ++var10) {
  43.                var4[var10] = var2;
  44.             }
  45.  
  46.             System.arraycopy(var0, 0, var4, var5, var0.length);
  47.             int var8 = var4.length - 1;
  48.  
  49.             for(int var11 = var5 + var0.length; var11 <= var8; ++var11) {
  50.                var4[var11] = var2;
  51.             }
  52.          }
  53.  
  54.          return var4;
  55.       }
  56.    }
  57.  
  58.    public static char[] changestr(char[] var0, char[] var1, char[] var2) {
  59.       int var8 = 0;
  60.       boolean var9 = false;
  61.       int var3 = countstr(var0, var1);
  62.       int var4 = var1.length + var3 * (var2.length - var0.length);
  63.       char[] var5 = new char[var4];
  64.       int var6 = 0;
  65.       int var7 = 0;
  66.  
  67.       for(int var10 = var3; var10 > 0; var6 = var8 + var0.length - 1) {
  68.          --var10;
  69.          var8 = pos(var0, var1, var6 + 1);
  70.          int var11 = var8 - 2;
  71.  
  72.          for(int var14 = var6; var14 <= var11; ++var14) {
  73.             var5[var7] = var1[var14];
  74.             ++var7;
  75.          }
  76.  
  77.          int var12 = var2.length - 1;
  78.  
  79.          for(int var15 = 0; var15 <= var12; ++var15) {
  80.             var5[var7] = var2[var15];
  81.             ++var7;
  82.          }
  83.       }
  84.  
  85.       int var17 = var1.length - 1;
  86.  
  87.       for(int var16 = var6; var16 <= var17; ++var16) {
  88.          var5[var7] = var1[var16];
  89.          ++var7;
  90.       }
  91.  
  92.       return var5;
  93.    }
  94.  
  95.    public static int compare(char[] var0, char[] var1, char var2) {
  96.       boolean var4 = false;
  97.       int var3 = var0.length;
  98.       if (var1.length > var3) {
  99.          var3 = var1.length;
  100.       }
  101.  
  102.       int var5 = var3;
  103.  
  104.       for(int var6 = 1; var6 <= var5; ++var6) {
  105.          if (var6 > var0.length) {
  106.             if (var1[var6 - 1] != var2) {
  107.                return var6;
  108.             }
  109.          } else if (var6 > var1.length) {
  110.             if (var0[var6 - 1] != var2) {
  111.                return var6;
  112.             }
  113.          } else if (var0[var6 - 1] != var1[var6 - 1]) {
  114.             return var6;
  115.          }
  116.       }
  117.  
  118.       return 0;
  119.    }
  120.  
  121.    public static int countstr(char[] var0, char[] var1) {
  122.       int var2 = 0;
  123.  
  124.       for(int var3 = pos((char[])var0, (char[])var1, 1); var3 > 0; var3 = pos(var0, var1, var3 + var0.length)) {
  125.          ++var2;
  126.       }
  127.  
  128.       return var2;
  129.    }
  130.  
  131.    public static char[] delstr(char[] var0, int var1, int var2) {
  132.       if (var2 == 0) {
  133.          return var0;
  134.       } else if (var1 > var0.length) {
  135.          return var0;
  136.       } else {
  137.          int var3 = var1 + var2;
  138.          if (var3 > var0.length) {
  139.             var3 = var0.length + 1;
  140.          }
  141.  
  142.          int var4 = var1 + var0.length - var3;
  143.          char[] var5 = new char[var4];
  144.          if (var1 > 1) {
  145.             System.arraycopy(var0, 0, var5, 0, var1 - 1);
  146.          }
  147.  
  148.          if (var3 <= var0.length) {
  149.             System.arraycopy(var0, var3 - 1, var5, var1 - 1, var0.length - var3 + 1);
  150.          }
  151.  
  152.          return var5;
  153.       }
  154.    }
  155.  
  156.    public static char[] delword(char[] var0, int var1, int var2) {
  157.       if (var2 == 0) {
  158.          return var0;
  159.       } else {
  160.          int var3 = wordindex(var0, var1);
  161.          if (var3 == 0) {
  162.             return var0;
  163.          } else {
  164.             int var4 = wordindex(var0, var1 + var2);
  165.             if (var4 == 0) {
  166.                var4 = var0.length + 1;
  167.             }
  168.  
  169.             int var5 = var3 + var0.length - var4;
  170.             char[] var6 = new char[var5];
  171.             if (var3 > 1) {
  172.                System.arraycopy(var0, 0, var6, 0, var3 - 1);
  173.             }
  174.  
  175.             if (var4 <= var0.length) {
  176.                System.arraycopy(var0, var4 - 1, var6, var3 - 1, var0.length - var4 + 1);
  177.             }
  178.  
  179.             return var6;
  180.          }
  181.       }
  182.    }
  183.  
  184.    public static char[] insert(char[] var0, char[] var1, int var2, int var3, char var4) {
  185.       boolean var7 = false;
  186.       int var5 = var2 + var3;
  187.       if (var2 < var0.length) {
  188.          var5 = var5 + var0.length - var2;
  189.       }
  190.  
  191.       char[] var6 = new char[var5];
  192.       if (var2 > 0) {
  193.          if (var2 <= var0.length) {
  194.             System.arraycopy(var0, 0, var6, 0, var2);
  195.          } else {
  196.             System.arraycopy(var0, 0, var6, 0, var0.length);
  197.             int var8 = var2 - 1;
  198.  
  199.             for(int var9 = var0.length; var9 <= var8; ++var9) {
  200.                var6[var9] = var4;
  201.             }
  202.          }
  203.       }
  204.  
  205.       if (var3 > 0) {
  206.          if (var3 <= var1.length) {
  207.             System.arraycopy(var1, 0, var6, var2, var3);
  208.          } else {
  209.             System.arraycopy(var1, 0, var6, var2, var1.length);
  210.             int var11 = var3 - 1;
  211.  
  212.             for(int var10 = var1.length; var10 <= var11; ++var10) {
  213.                var6[var2 + var10] = var4;
  214.             }
  215.          }
  216.       }
  217.  
  218.       if (var2 < var0.length) {
  219.          System.arraycopy(var0, var2, var6, var2 + var3, var0.length - var2);
  220.       }
  221.  
  222.       return var6;
  223.    }
  224.  
  225.    public static char[] overlay(char[] var0, char[] var1, int var2, int var3, char var4) {
  226.       boolean var7 = false;
  227.       int var5 = var2 + var3 - 1;
  228.       if (var5 < var0.length) {
  229.          var5 = var0.length;
  230.       }
  231.  
  232.       char[] var6 = new char[var5];
  233.       if (var2 > 1) {
  234.          if (var2 - 1 <= var0.length) {
  235.             System.arraycopy(var0, 0, var6, 0, var2 - 1);
  236.          } else {
  237.             System.arraycopy(var0, 0, var6, 0, var0.length);
  238.             int var8 = var2 - 2;
  239.  
  240.             for(int var9 = var0.length; var9 <= var8; ++var9) {
  241.                var6[var9] = var4;
  242.             }
  243.          }
  244.       }
  245.  
  246.       if (var3 > 0) {
  247.          if (var3 <= var1.length) {
  248.             System.arraycopy(var1, 0, var6, var2 - 1, var3);
  249.          } else {
  250.             System.arraycopy(var1, 0, var6, var2 - 1, var1.length);
  251.             int var11 = var3 - 1;
  252.  
  253.             for(int var10 = var1.length; var10 <= var11; ++var10) {
  254.                var6[var2 - 1 + var10] = var4;
  255.             }
  256.          }
  257.       }
  258.  
  259.       if (var2 + var3 - 1 < var0.length) {
  260.          System.arraycopy(var0, var2 + var3 - 1, var6, var2 + var3 - 1, var0.length - (var2 + var3 - 1));
  261.       }
  262.  
  263.       return var6;
  264.    }
  265.  
  266.    public static final int nextblank(char[] var0, int var1) {
  267.       boolean var2 = false;
  268.       int var3 = var0.length;
  269.  
  270.       for(int var4 = var1; var4 <= var3; ++var4) {
  271.          if (var0[var4 - 1] == ' ') {
  272.             return var4;
  273.          }
  274.       }
  275.  
  276.       return 0;
  277.    }
  278.  
  279.    public static final int nextnonblank(char[] var0, int var1) {
  280.       boolean var2 = false;
  281.       int var3 = var0.length;
  282.  
  283.       for(int var4 = var1; var4 <= var3; ++var4) {
  284.          if (var0[var4 - 1] != ' ') {
  285.             return var4;
  286.          }
  287.       }
  288.  
  289.       return 0;
  290.    }
  291.  
  292.    public static int pos(char var0, String var1, int var2) {
  293.       return pos(var0, var1.toCharArray(), var2);
  294.    }
  295.  
  296.    public static int pos(char var0, char[] var1, int var2) {
  297.       boolean var3 = false;
  298.       int var4 = var1.length - 1;
  299.  
  300.       for(int var5 = var2 - 1; var5 <= var4; ++var5) {
  301.          if (var1[var5] == var0) {
  302.             return var5 + 1;
  303.          }
  304.       }
  305.  
  306.       return 0;
  307.    }
  308.  
  309.    public static int pos(String var0, String var1, int var2) {
  310.       return pos(var0.toCharArray(), var1.toCharArray(), var2);
  311.    }
  312.  
  313.    public static int pos(char[] var0, char[] var1, int var2) {
  314.       boolean var3 = false;
  315.       boolean var4 = false;
  316.       if (var0.length == 0) {
  317.          return 0;
  318.       } else {
  319.          int var5 = var1.length - var0.length + 1;
  320.  
  321.          label28:
  322.          for(int var7 = var2; var7 <= var5; ++var7) {
  323.             int var6 = var0.length - 1;
  324.  
  325.             for(int var8 = 0; var8 <= var6; ++var8) {
  326.                if (var0[var8] != var1[var7 + var8 - 1]) {
  327.                   continue label28;
  328.                }
  329.             }
  330.  
  331.             return var7;
  332.          }
  333.  
  334.          return 0;
  335.       }
  336.    }
  337.  
  338.    public static char[] space(char[] var0, int var1, char var2) {
  339.       int var6 = 0;
  340.       boolean var10 = false;
  341.       int var3 = 1;
  342.       int var4 = 0;
  343.       int var5 = 0;
  344.  
  345.       while(true) {
  346.          var3 = nextnonblank(var0, var3);
  347.          if (var3 == 0) {
  348.             break;
  349.          }
  350.  
  351.          ++var4;
  352.          var6 = nextblank(var0, var3 + 1);
  353.          if (var6 == 0) {
  354.             var5 = var5 + var0.length + 1 - var3;
  355.             break;
  356.          }
  357.  
  358.          var5 = var5 + var6 - var3;
  359.          var3 = var6;
  360.       }
  361.  
  362.       if (var4 == 0) {
  363.          return new char[0];
  364.       } else {
  365.          int var7 = (var4 - 1) * var1 + var5;
  366.          char[] var8 = new char[var7];
  367.          var3 = 1;
  368.          int var9 = 0;
  369.          int var11 = var4;
  370.  
  371.          for(int var16 = 1; var16 <= var11; ++var16) {
  372.             var3 = nextnonblank(var0, var3);
  373.             if (var3 == 0) {
  374.                break;
  375.             }
  376.  
  377.             do {
  378.                var8[var9] = var0[var3 - 1];
  379.                ++var3;
  380.                if (var3 > var0.length) {
  381.                   return var8;
  382.                }
  383.  
  384.                ++var9;
  385.             } while(var0[var3 - 1] != ' ');
  386.  
  387.             if (var16 == var4) {
  388.                break;
  389.             }
  390.  
  391.             for(int var12 = var1; var12 > 0; ++var9) {
  392.                --var12;
  393.                var8[var9] = var2;
  394.             }
  395.          }
  396.  
  397.          return var8;
  398.       }
  399.    }
  400.  
  401.    public static char[] subword(char[] var0, int var1, int var2) {
  402.       if (var2 == 0) {
  403.          return new char[0];
  404.       } else {
  405.          int var3 = wordindex(var0, var1);
  406.          if (var3 == 0) {
  407.             return new char[0];
  408.          } else {
  409.             int var4 = wordindex(var0, var1 + var2);
  410.             if (var4 == 0) {
  411.                var4 = var0.length + 1;
  412.             }
  413.  
  414.             int var7 = var3;
  415.             --var4;
  416.  
  417.             while(var4 >= var7 && var0[var4 - 1] == ' ') {
  418.                --var4;
  419.             }
  420.  
  421.             int var5 = var4 - var3 + 1;
  422.             char[] var6 = new char[var5];
  423.             System.arraycopy(var0, var3 - 1, var6, 0, var5);
  424.             return var6;
  425.          }
  426.       }
  427.    }
  428.  
  429.    public static int verify(char[] var0, char[] var1, char var2, int var3) {
  430.       return var2 == 'N' ? verifyn(var0, var1, var3) : verifym(var0, var1, var3);
  431.    }
  432.  
  433.    public static int verifym(char[] var0, char[] var1, int var2) {
  434.       boolean var4 = false;
  435.       char var5 = '\u0000';
  436.       int var6 = 0;
  437.       int var3 = var0.length;
  438.       if (var2 > var3) {
  439.          return 0;
  440.       } else if (var1.length == 0) {
  441.          return 0;
  442.       } else {
  443.          int var7 = var3;
  444.  
  445.          for(int var8 = var2; var8 <= var7; ++var8) {
  446.             var5 = var0[var8 - 1];
  447.             if (var5 == var1[0]) {
  448.                return var8;
  449.             }
  450.  
  451.             var6 = pos(var5, (char[])var1, 2);
  452.             if (var6 > 0) {
  453.                return var8;
  454.             }
  455.          }
  456.  
  457.          return 0;
  458.       }
  459.    }
  460.  
  461.    public static int verifyn(char[] var0, char[] var1, int var2) {
  462.       boolean var4 = false;
  463.       int var5 = 0;
  464.       int var3 = var0.length;
  465.       if (var2 > var3) {
  466.          return 0;
  467.       } else if (var1.length == 0) {
  468.          return var2;
  469.       } else {
  470.          int var6 = var3;
  471.  
  472.          for(int var7 = var2; var7 <= var6; ++var7) {
  473.             var5 = pos(var0[var7 - 1], (char[])var1, 1);
  474.             if (var5 == 0) {
  475.                return var7;
  476.             }
  477.          }
  478.  
  479.          return 0;
  480.       }
  481.    }
  482.  
  483.    public static char[] word(char[] var0, int var1) {
  484.       return subword(var0, var1, 1);
  485.    }
  486.  
  487.    public static int wordindex(char[] var0, int var1) {
  488.       int var3 = 0;
  489.       int var2 = 1;
  490.       var3 = 1;
  491.  
  492.       while(true) {
  493.          var2 = nextnonblank(var0, var2);
  494.          if (var2 == 0) {
  495.             return 0;
  496.          }
  497.  
  498.          if (var3 == var1) {
  499.             return var2;
  500.          }
  501.  
  502.          var2 = nextblank(var0, var2 + 1);
  503.          if (var2 == 0) {
  504.             return 0;
  505.          }
  506.  
  507.          ++var3;
  508.       }
  509.    }
  510.  
  511.    public static int wordlength(char[] var0, int var1) {
  512.       int var2 = wordindex(var0, var1);
  513.       if (var2 == 0) {
  514.          return 0;
  515.       } else {
  516.          int var3 = nextblank(var0, var2 + 1);
  517.          if (var3 == 0) {
  518.             var3 = var0.length + 1;
  519.          }
  520.  
  521.          return var3 - var2;
  522.       }
  523.    }
  524.  
  525.    public static int wordpos(char[] var0, char[] var1, int var2) {
  526.       int var7 = 0;
  527.       int var8 = 0;
  528.       int var9 = 0;
  529.       int var10 = 0;
  530.       int var11 = 0;
  531.       int var12 = 0;
  532.       int var3 = var0.length;
  533.       if (var3 == 0) {
  534.          return 0;
  535.       } else {
  536.          int var4 = nextnonblank(var0, 1);
  537.          if (var4 == 0) {
  538.             return 0;
  539.          } else {
  540.             int var5 = wordindex(var1, var2);
  541.             if (var5 == 0) {
  542.                return 0;
  543.             } else {
  544.                int var6 = var1.length;
  545.  
  546.                while(true) {
  547.                   var7 = var4;
  548.                   var8 = var5;
  549.  
  550.                   label64:
  551.                   while(true) {
  552.                      var9 = nextblank(var0, var7 + 1);
  553.                      if (var9 == 0) {
  554.                         var9 = var3 + 1;
  555.                      }
  556.  
  557.                      var10 = nextblank(var1, var8 + 1);
  558.                      if (var10 == 0) {
  559.                         var10 = var6 + 1;
  560.                      }
  561.  
  562.                      if (var10 - var8 == var9 - var7) {
  563.                         var11 = var8 - 1;
  564.                         int var13 = var9 - 2;
  565.                         var12 = var7 - 1;
  566.  
  567.                         while(true) {
  568.                            if (var12 > var13) {
  569.                               if (var9 > var3) {
  570.                                  return var2;
  571.                               }
  572.  
  573.                               var7 = nextnonblank(var0, var9);
  574.                               if (var7 == 0) {
  575.                                  return var2;
  576.                               }
  577.  
  578.                               if (var10 <= var6) {
  579.                                  var8 = nextnonblank(var1, var10);
  580.                                  if (var8 != 0) {
  581.                                     continue label64;
  582.                                  }
  583.                               }
  584.                               break;
  585.                            }
  586.  
  587.                            if (var0[var12] != var1[var11]) {
  588.                               break;
  589.                            }
  590.  
  591.                            ++var11;
  592.                            ++var12;
  593.                         }
  594.                      }
  595.  
  596.                      ++var2;
  597.                      var5 = nextblank(var1, var5 + 1);
  598.                      if (var5 != 0) {
  599.                         var5 = nextnonblank(var1, var5 + 1);
  600.                         if (var5 != 0) {
  601.                            break;
  602.                         }
  603.                      }
  604.  
  605.                      return 0;
  606.                   }
  607.                }
  608.             }
  609.          }
  610.       }
  611.    }
  612.  
  613.    public static int words(char[] var0) {
  614.       int var1 = 1;
  615.       int var2 = 0;
  616.  
  617.       do {
  618.          var1 = nextnonblank(var0, var1);
  619.          if (var1 == 0) {
  620.             break;
  621.          }
  622.  
  623.          ++var2;
  624.          var1 = nextblank(var0, var1 + 1);
  625.       } while(var1 != 0);
  626.  
  627.       return var2;
  628.    }
  629.  
  630.    private RexxWords() {
  631.    }
  632. }
  633.