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