home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1997 May / PCO_5_97.ISO / FilesBBS / OS2 / NETREXX.ARJ / NETREXX.ZIP / NetRexx / netrexx / lang / RexxCharX.class (.txt) < prev    next >
Encoding:
Java Class File  |  1996-12-14  |  15.3 KB  |  640 lines
  1. package netrexx.lang;
  2.  
  3. public final class RexxCharX {
  4.    public static final int MIN_RADIX = 2;
  5.    public static final int MAX_RADIX = 36;
  6.    public static final char MIN_VALUE = '\u0000';
  7.    public static final char MAX_VALUE = '\uffff';
  8.    private static long[] isLowerCaseTable = new long[]{0L, 576460743713488896L, 0L, -36028799166447616L, 6172933889249159850L, -3122495741643543723L, 2761033308231184681L, -6329340151129091520L, 11184810L, -22522413363298304L, 2170637221884L, 0L, 0L, 0L, -17592185978880L, 1032063467880447L, -281474976710656L, -6148914690341797889L, -6148914691236560894L, 156089602710049044L, 0L, -8589934592L, 255L, 0L, -6148914691236517206L, -6148914691236517206L, -6148914693967009110L, 192153584101141162L, 71777214282006783L, 4611405638684049471L, 62770015039848703L, 61925590106570972L};
  9.    private static long[] isUpperCaseTable = new long[]{0L, 134217726L, 0L, 2139095039L, -6172933889249159851L, 3122495741643543722L, 1274187284968361686L, 6057998273580016784L, 5592405L, 0L, 0L, 0L, 0L, 0L, 17575006099264L, 93819265613824L, 281474976702462L, 6148914689804861440L, 6148914691236495361L, 78044801355024522L, -562949953421312L, 8388607L, 0L, 0L, 6148914691236517205L, 6148914691236517205L, 6148914689806259541L, 96076792050570581L, -71777217515815168L, 280378317225728L, 2234065794919104256L, 2233819500287893248L};
  10.    private static long[] isDefinedTable01C0through06FF = new long[]{-270215977642229761L, 16777215L, -65536L, -279275953455105L, 4395899027455L, -1L, 4913427206346113087L, -17179879440L, 4503588160110591L, -8194L, -536936449L, -65409L, 234134404065073567L, -562949953421312L, -4320133121L, -288511851128421633L, 8734520370987023L, 576460745995194368L, -211110526976001L, 9007199254740991999L, 288019269919145983L};
  11.    private static long[] isDefinedTable0900through0EFF = new long[]{-864691128455135250L, 562949938692095L, -3186861885341720594L, 576460544811219359L, -3211631683292264476L, 9006925953907079L, -869759877059465234L, 281204393851839L, -878767076314341394L, 562690925803919L, -4341532606274353172L, 2251250066275783L, -4327961440926441490L, 281212990012895L, -4327961440926441492L, 281214063754719L, -4323457841299070996L, 281212992110031L, 0L, 0L, -8646911284551352322L, 268435455L, 4323434403644581270L, 872365919L};
  12.    private static long[] isDefinedTable1080through11FF = new long[]{-4294967296L, 612489549322321983L, -1L, -2080374785L, -1065151889409L, 288230376151711743L};
  13.    private static long[] isDefinedTable1E00through27BF = new long[]{-1L, -1L, -4160749569L, 288230376151711743L, -3233808385L, 4611686017001275199L, -9007199254740993L, 9213520412398321631L, -140737488355329L, -3945047720460161L, 8791798087679L, 17179803648L, 144115188075855871L, -524288L, -65529L, 8796093022207L, -1L, -1L, -1L, 1125899906842623L, -3L, 576460752303423487L, 0L, 0L, 137438953471L, -4294965249L, -1L, 8796093022207L, -1L, -1L, -4290772993L, 281474976710655L, -66060289L, 281474976710655L, 0L, 0L, -1099511630882L, -18013305452384257L, 9223090561863385087L};
  14.    private static long[] isDefinedTable3000through33FF = new long[]{-9151314442816847873L, -2L, -6473908225L, Long.MAX_VALUE, -527765581332512L, -1L, 4294934527L, 0L, -3758096385L, -8070450536542896113L, 562949953421311L, 9223372036854714367L, -1L, -540431955284459521L, -1L, 9223372033633550335L};
  15.    private static long[] isDefinedTableFB00throughFFFF = new long[]{6881500229564629119L, -37L, 1125899906842623L, -524288L, -1L, -1L, -1L, -1L, -1L, -65536L, -196609L, 1152640029630136575L, -281410552201216L, -11523431615431137L, -1L, -6917529027641081857L, -2L, -6442450945L, Long.MAX_VALUE, 2305983193137609980L};
  16.    private static long[] isLetterTable0000through06FF = new long[]{0L, 576460743847706622L, 0L, -36028797027352577L, -1L, -1L, -1L, -270215977642229761L, 16777215L, -65536L, -279275953455105L, 4395899027455L, -1L, 4913427206346113087L, -17179879440L, 4503588160110591L, -8194L, -536936449L, -65409L, 234134404065073567L, -562949953421312L, -4320133121L, -288511851128421633L, 8734520370987023L, 576460745995194368L, -215504278519809L, 9007199254740991999L, 70368744144895L};
  17.    private static long[] isLetterTable0900through0EFF = new long[]{-864691128455135250L, 281749839888383L, -3186861885341720594L, 576179344712415647L, -3211631683292264476L, 8725725855103367L, -869759877059465234L, 4295048127L, -878767076314341394L, 281490827000207L, -4341532606274353172L, 1970324845379015L, -4327961440926441490L, 12891209183L, -4327961440926441492L, 13964951007L, -4323457841299070996L, 12893306319L, 0L, 0L, -8646911284551352322L, 201392127L, 4323434403644581270L, 805322591L};
  18.    private static long[] isLetterTable1080through11FF;
  19.    private static long[] isLetterTable1E00through1FFF;
  20.    private static long[] isLetterTable3000through33FF;
  21.    private static long[] isLetterTableFB00throughFFFF;
  22.    private static long[] isLDTable0000through06FF;
  23.    private static long[] isLDTable0900through0EFF;
  24.    private static long[] isLDTable1080through11FF;
  25.    private static long[] isLDTable1E00through1FFF;
  26.    private static long[] isLDTable3000through33FF;
  27.    private static long[] isLDTableFB00throughFFFF;
  28.    private static long[] toLowerCaseTable;
  29.    private static long[] toUpperCaseTable;
  30.    private char value;
  31.  
  32.    public static boolean isLowerCase(char var0) {
  33.       return ((var0 < 1536 ? isLowerCaseTable[var0 >> 6] : ((var0 & '∩╕Ç') == 7680 ? isLowerCaseTable[var0 - 6144 >> 6] : ((var0 & '\uffc0') == 64256 ? 16253055L : ((var0 & '\uffc0') == 65344 ? 134217726L : 0L)))) >> (var0 & 63) & 1L) != 0L;
  34.    }
  35.  
  36.    public static boolean isUpperCase(char var0) {
  37.       return ((var0 < 1536 ? isUpperCaseTable[var0 >> 6] : ((var0 & '∩╕Ç') == 7680 ? isUpperCaseTable[var0 - 6144 >> 6] : (var0 >= 4256 && var0 <= 4303 ? -4294967233L : ((var0 & '\uffc0') == 65280 ? 576460743713488896L : 0L)))) >> (var0 & 63) & 1L) != 0L;
  38.    }
  39.  
  40.    public static boolean isTitleCase(char var0) {
  41.       return var0 == 453 || var0 == 456 || var0 == 459 || var0 == 498;
  42.    }
  43.  
  44.    public static boolean isDigit(char var0) {
  45.       if (var0 >= '0' && var0 <= '9') {
  46.          return true;
  47.       } else {
  48.          switch (var0 >> 8) {
  49.             case 6:
  50.                return var0 >= 1632 && var0 <= 1641 || var0 >= 1776 && var0 <= 1785;
  51.             case 9:
  52.                if (var0 >= 2406 && var0 <= 2415 || var0 >= 2534 && var0 <= 2543) {
  53.                   return true;
  54.                }
  55.  
  56.                return false;
  57.             case 10:
  58.                if (var0 >= 2662 && var0 <= 2671 || var0 >= 2790 && var0 <= 2799) {
  59.                   return true;
  60.                }
  61.  
  62.                return false;
  63.             case 11:
  64.                if (var0 >= 2918 && var0 <= 2927 || var0 >= 3047 && var0 <= 3055) {
  65.                   return true;
  66.                }
  67.  
  68.                return false;
  69.             case 12:
  70.                if (var0 >= 3174 && var0 <= 3183 || var0 >= 3302 && var0 <= 3311) {
  71.                   return true;
  72.                }
  73.  
  74.                return false;
  75.             case 13:
  76.                if (var0 >= 3430 && var0 <= 3439) {
  77.                   return true;
  78.                }
  79.  
  80.                return false;
  81.             case 14:
  82.                if (var0 >= 3664 && var0 <= 3673 || var0 >= 3792 && var0 <= 3801) {
  83.                   return true;
  84.                }
  85.  
  86.                return false;
  87.             case 255:
  88.                if (var0 >= '∩╝É' && var0 <= '∩╝Ö') {
  89.                   return true;
  90.                }
  91.  
  92.                return false;
  93.             default:
  94.                return false;
  95.          }
  96.       }
  97.    }
  98.  
  99.    public static boolean isDefined(char var0) {
  100.       if (var0 < 502) {
  101.          return true;
  102.       } else if (var0 < 1792) {
  103.          return (isDefinedTable01C0through06FF[var0 - 448 >> 6] >> (var0 & 63) & 1L) != 0L;
  104.       } else if (var0 >= 2304 && var0 <= 3839) {
  105.          return (isDefinedTable0900through0EFF[var0 - 2304 >> 6] >> (var0 & 63) & 1L) != 0L;
  106.       } else if (var0 >= 4224 && var0 <= 4607) {
  107.          return (isDefinedTable1080through11FF[var0 - 4224 >> 6] >> (var0 & 63) & 1L) != 0L;
  108.       } else if (var0 >= 7680 && var0 <= 10175) {
  109.          return (isDefinedTable1E00through27BF[var0 - 7680 >> 6] >> (var0 & 63) & 1L) != 0L;
  110.       } else if (var0 >= 12288 && var0 <= 13311) {
  111.          return (isDefinedTable3000through33FF[var0 - 12288 >> 6] >> (var0 & 63) & 1L) != 0L;
  112.       } else if (var0 >= '∩¼Ç') {
  113.          return (isDefinedTableFB00throughFFFF[var0 - '∩¼Ç' >> 6] >> (var0 & 63) & 1L) != 0L;
  114.       } else {
  115.          return var0 >= 13312 && var0 <= 'Θ╛Ñ' || var0 >= '∩ñÇ' && var0 <= '∩¿¡';
  116.       }
  117.    }
  118.  
  119.    public static boolean isLetter(char var0) {
  120.       if (var0 < 1792) {
  121.          return (isLetterTable0000through06FF[var0 >> 6] >> (var0 & 63) & 1L) != 0L;
  122.       } else if (var0 >= 2304 && var0 <= 3839) {
  123.          return (isLetterTable0900through0EFF[var0 - 2304 >> 6] >> (var0 & 63) & 1L) != 0L;
  124.       } else if (var0 >= 4224 && var0 <= 4607) {
  125.          return (isLetterTable1080through11FF[var0 - 4224 >> 6] >> (var0 & 63) & 1L) != 0L;
  126.       } else if (var0 >= 7680 && var0 <= 8191) {
  127.          return (isLetterTable1E00through1FFF[var0 - 7680 >> 6] >> (var0 & 63) & 1L) != 0L;
  128.       } else if (var0 >= 12352 && var0 <= 13311) {
  129.          return (isLetterTable3000through33FF[var0 - 12288 >> 6] >> (var0 & 63) & 1L) != 0L;
  130.       } else if (var0 >= '∩¼Ç') {
  131.          return (isLetterTableFB00throughFFFF[var0 - '∩¼Ç' >> 6] >> (var0 & 63) & 1L) != 0L;
  132.       } else {
  133.          return var0 >= 13312 && var0 <= 'Θ╛Ñ' || var0 >= '∩ñÇ' && var0 <= '∩¿¡';
  134.       }
  135.    }
  136.  
  137.    public static boolean isLetterOrDigit(char var0) {
  138.       if (var0 < 1792) {
  139.          return (isLDTable0000through06FF[var0 >> 6] >> (var0 & 63) & 1L) != 0L;
  140.       } else if (var0 >= 2304 && var0 <= 3839) {
  141.          return (isLDTable0900through0EFF[var0 - 2304 >> 6] >> (var0 & 63) & 1L) != 0L;
  142.       } else if (var0 >= 4224 && var0 <= 4607) {
  143.          return (isLDTable1080through11FF[var0 - 4224 >> 6] >> (var0 & 63) & 1L) != 0L;
  144.       } else if (var0 >= 7680 && var0 <= 8191) {
  145.          return (isLDTable1E00through1FFF[var0 - 7680 >> 6] >> (var0 & 63) & 1L) != 0L;
  146.       } else if (var0 >= 12352 && var0 <= 13311) {
  147.          return (isLDTable3000through33FF[var0 - 12288 >> 6] >> (var0 & 63) & 1L) != 0L;
  148.       } else if (var0 >= '∩¼Ç') {
  149.          return (isLDTableFB00throughFFFF[var0 - '∩¼Ç' >> 6] >> (var0 & 63) & 1L) != 0L;
  150.       } else {
  151.          return var0 >= 13312 && var0 <= 'Θ╛Ñ' || var0 >= '∩ñÇ' && var0 <= '∩¿¡';
  152.       }
  153.    }
  154.  
  155.    public static boolean isJavaLetter(char var0) {
  156.       return isLetter(var0) || var0 == '$' || var0 == '_';
  157.    }
  158.  
  159.    public static boolean isJavaLetterOrDigit(char var0) {
  160.       return isLetterOrDigit(var0) || var0 == '$' || var0 == '_';
  161.    }
  162.  
  163.    public static char toLowerCase(char var0) {
  164.       if (var0 >= 65 && var0 <= 90) {
  165.          return (char)(var0 + 32);
  166.       } else if (var0 < 192) {
  167.          return (char)var0;
  168.       } else if (var0 < 256) {
  169.          if (var0 >= 223) {
  170.             return (char)var0;
  171.          } else {
  172.             return (char)(var0 == 215 ? var0 : (char)(var0 + 32));
  173.          }
  174.       } else {
  175.          if (((var0 < 1536 ? toLowerCaseTable[var0 - 256 >> 6] : ((var0 & '∩╕Ç') == 7680 ? toLowerCaseTable[var0 - 6400 >> 6] : (var0 >= 4256 && var0 <= 4293 ? -4294967233L : ((var0 & '\uffc0') == 8512 ? 281470681743360L : (var0 >= 9398 && var0 <= 9423 ? -18014398509416449L : ((var0 & '\uffc0') == 65280 ? 576460743713488896L : 0L)))))) >> (var0 & 63) & 1L) != 0L) {
  176.             switch (var0 >> 8) {
  177.                case 1:
  178.                   switch (var0 & 255) {
  179.                      case 120:
  180.                         return '├┐';
  181.                      case 129:
  182.                         return '╔ô';
  183.                      case 134:
  184.                         return '╔ö';
  185.                      case 138:
  186.                         return '╔ù';
  187.                      case 142:
  188.                         return '╔ÿ';
  189.                      case 143:
  190.                         return '╔Ö';
  191.                      case 144:
  192.                         return '╔¢';
  193.                      case 147:
  194.                         return '╔á';
  195.                      case 148:
  196.                         return '╔ú';
  197.                      case 150:
  198.                         return '╔⌐';
  199.                      case 151:
  200.                         return '╔¿';
  201.                      case 156:
  202.                         return '╔»';
  203.                      case 157:
  204.                         return '╔▓';
  205.                      case 169:
  206.                         return '╩â';
  207.                      case 174:
  208.                         return '╩ê';
  209.                      case 177:
  210.                         return '╩è';
  211.                      case 178:
  212.                         return '╩ï';
  213.                      case 183:
  214.                         return '╩Æ';
  215.                      case 196:
  216.                         return '╟å';
  217.                      case 199:
  218.                         return '╟ë';
  219.                      case 202:
  220.                         return '╟î';
  221.                      case 241:
  222.                         return '╟│';
  223.                      default:
  224.                         return (char)(var0 + 1);
  225.                   }
  226.                case 2:
  227.                   return (char)(var0 + 1);
  228.                case 3:
  229.                   switch (var0 & 255) {
  230.                      case 134:
  231.                         return '╬¼';
  232.                      case 136:
  233.                         return '╬¡';
  234.                      case 137:
  235.                         return '╬«';
  236.                      case 138:
  237.                         return '╬»';
  238.                      case 140:
  239.                         return '╧î';
  240.                      case 142:
  241.                         return '╧ì';
  242.                      case 143:
  243.                         return '╧Ä';
  244.                      default:
  245.                         if (var0 < 944) {
  246.                            return (char)(var0 + 32);
  247.                         }
  248.  
  249.                         return (char)(var0 + 1);
  250.                   }
  251.                case 4:
  252.                   if (var0 < 1040) {
  253.                      return (char)(var0 + 80);
  254.                   }
  255.  
  256.                   if (var0 < 1120) {
  257.                      return (char)(var0 + 32);
  258.                   }
  259.  
  260.                   return (char)(var0 + 1);
  261.                case 5:
  262.                case 16:
  263.                   return (char)(var0 + 48);
  264.                case 30:
  265.                   return (char)(var0 + 1);
  266.                case 31:
  267.                   switch (var0 & 255) {
  268.                      case 186:
  269.                         return 'ß╜░';
  270.                      case 187:
  271.                         return 'ß╜▒';
  272.                      case 188:
  273.                         return 'ß╛│';
  274.                      case 200:
  275.                         return 'ß╜▓';
  276.                      case 201:
  277.                         return 'ß╜│';
  278.                      case 202:
  279.                         return 'ß╜┤';
  280.                      case 203:
  281.                         return 'ß╜╡';
  282.                      case 204:
  283.                         return 'ß┐â';
  284.                      case 218:
  285.                         return 'ß╜╢';
  286.                      case 219:
  287.                         return 'ß╜╖';
  288.                      case 234:
  289.                         return 'ß╜║';
  290.                      case 235:
  291.                         return 'ß╜╗';
  292.                      case 236:
  293.                         return 'ß┐Ñ';
  294.                      case 248:
  295.                         return 'ß╜╕';
  296.                      case 249:
  297.                         return 'ß╜╣';
  298.                      case 250:
  299.                         return 'ß╜╝';
  300.                      case 251:
  301.                         return 'ß╜╜';
  302.                      case 252:
  303.                         return 'ß┐│';
  304.                      default:
  305.                         return (char)(var0 - 8);
  306.                   }
  307.                case 33:
  308.                   return (char)(var0 + 16);
  309.                case 36:
  310.                   return (char)(var0 + 26);
  311.                case 255:
  312.                   return (char)(var0 + 32);
  313.             }
  314.          }
  315.  
  316.          return (char)var0;
  317.       }
  318.    }
  319.  
  320.    public static char toUpperCase(char var0) {
  321.       if (var0 >= 97 && var0 <= 122) {
  322.          return (char)(var0 + -32);
  323.       } else if (var0 < 224) {
  324.          return (char)var0;
  325.       } else if (var0 < 256) {
  326.          if (var0 == 247) {
  327.             return (char)var0;
  328.          } else {
  329.             return var0 == 255 ? '┼╕' : (char)(var0 - 32);
  330.          }
  331.       } else {
  332.          if (((var0 < 1536 ? toUpperCaseTable[var0 - 256 >> 6] : ((var0 & '∩╕Ç') == 7680 ? toUpperCaseTable[var0 - 6400 >> 6] : ((var0 & '\uffc0') == 8512 ? -281474976710656L : ((var0 & '\uffc0') == 9408 ? 4398046445568L : ((var0 & '\uffc0') == 65344 ? 134217726L : 0L))))) >> (var0 & 63) & 1L) != 0L) {
  333.             switch (var0 >> 8) {
  334.                case 1:
  335.                   if (var0 == 383) {
  336.                      return 'S';
  337.                   }
  338.  
  339.                   if (var0 != 454 && var0 != 457 && var0 != 460 && var0 != 499) {
  340.                      return (char)(var0 - 1);
  341.                   }
  342.  
  343.                   return (char)(var0 - 2);
  344.                case 2:
  345.                   if (var0 < 576) {
  346.                      return (char)(var0 - 1);
  347.                   }
  348.  
  349.                   switch (var0 & 255) {
  350.                      case 83:
  351.                         return '╞ü';
  352.                      case 84:
  353.                         return '╞å';
  354.                      case 87:
  355.                         return '╞è';
  356.                      case 88:
  357.                         return '╞Ä';
  358.                      case 89:
  359.                         return '╞Å';
  360.                      case 91:
  361.                         return '╞É';
  362.                      case 96:
  363.                         return '╞ô';
  364.                      case 99:
  365.                         return '╞ö';
  366.                      case 104:
  367.                         return '╞ù';
  368.                      case 105:
  369.                         return '╞û';
  370.                      case 111:
  371.                         return '╞£';
  372.                      case 114:
  373.                         return '╞¥';
  374.                      case 131:
  375.                         return '╞⌐';
  376.                      case 136:
  377.                         return '╞«';
  378.                      case 138:
  379.                         return '╞▒';
  380.                      case 139:
  381.                         return '╞▓';
  382.                      case 146:
  383.                         return '╞╖';
  384.                      default:
  385.                         return (char)var0;
  386.                   }
  387.                case 3:
  388.                   switch (var0 & 255) {
  389.                      case 172:
  390.                         return '╬å';
  391.                      case 173:
  392.                         return '╬ê';
  393.                      case 174:
  394.                         return '╬ë';
  395.                      case 175:
  396.                         return '╬è';
  397.                      case 194:
  398.                         return '╬ú';
  399.                      case 204:
  400.                         return '╬î';
  401.                      case 205:
  402.                         return '╬Ä';
  403.                      case 206:
  404.                         return '╬Å';
  405.                      case 208:
  406.                         return '╬Æ';
  407.                      case 209:
  408.                         return '╬ÿ';
  409.                      case 213:
  410.                         return '╬ª';
  411.                      case 214:
  412.                         return '╬á';
  413.                      case 240:
  414.                         return '╬Ü';
  415.                      case 241:
  416.                         return '╬í';
  417.                      default:
  418.                         if (var0 < 992) {
  419.                            return (char)(var0 - 32);
  420.                         }
  421.  
  422.                         return (char)(var0 - 1);
  423.                   }
  424.                case 4:
  425.                   if (var0 < 1104) {
  426.                      return (char)(var0 - 32);
  427.                   }
  428.  
  429.                   if (var0 < 1120) {
  430.                      return (char)(var0 - 80);
  431.                   }
  432.  
  433.                   return (char)(var0 - 1);
  434.                case 5:
  435.                   return (char)(var0 - 48);
  436.                case 30:
  437.                   return (char)(var0 - 1);
  438.                case 31:
  439.                   switch (var0 & 255) {
  440.                      case 112:
  441.                         return 'ß╛║';
  442.                      case 113:
  443.                         return 'ß╛╗';
  444.                      case 114:
  445.                         return 'ß┐ê';
  446.                      case 115:
  447.                         return 'ß┐ë';
  448.                      case 116:
  449.                         return 'ß┐è';
  450.                      case 117:
  451.                         return 'ß┐ï';
  452.                      case 118:
  453.                         return 'ß┐Ü';
  454.                      case 119:
  455.                         return 'ß┐¢';
  456.                      case 120:
  457.                         return 'ß┐╕';
  458.                      case 121:
  459.                         return 'ß┐╣';
  460.                      case 122:
  461.                         return 'ß┐¬';
  462.                      case 123:
  463.                         return 'ß┐½';
  464.                      case 124:
  465.                         return 'ß┐║';
  466.                      case 125:
  467.                         return 'ß┐╗';
  468.                      case 179:
  469.                         return 'ß╛╝';
  470.                      case 195:
  471.                         return 'ß┐î';
  472.                      case 229:
  473.                         return 'ß┐¼';
  474.                      case 243:
  475.                         return 'ß┐╝';
  476.                      default:
  477.                         return (char)(var0 + 8);
  478.                   }
  479.                case 33:
  480.                   return (char)(var0 - 16);
  481.                case 36:
  482.                   return (char)(var0 - 26);
  483.                case 255:
  484.                   return (char)(var0 - 32);
  485.             }
  486.          }
  487.  
  488.          return (char)var0;
  489.       }
  490.    }
  491.  
  492.    public static char toTitleCase(char var0) {
  493.       if ((var0 & '\uffc0') != 448) {
  494.          return toUpperCase(var0);
  495.       } else if (var0 >= 452 && var0 <= 454) {
  496.          return '╟à';
  497.       } else if (var0 >= 455 && var0 <= 457) {
  498.          return '╟ê';
  499.       } else if (var0 >= 458 && var0 <= 460) {
  500.          return '╟ï';
  501.       } else {
  502.          return var0 >= 497 && var0 <= 499 ? '╟▓' : toUpperCase(var0);
  503.       }
  504.    }
  505.  
  506.    public static int digit(char var0, int var1) {
  507.       int var2 = -1;
  508.       if (var1 >= 2 && var1 <= 36) {
  509.          if (var0 >= '0' && var0 <= '9') {
  510.             var2 = var0 - 48;
  511.          } else if (var0 >= 'A' && var0 <= 'Z') {
  512.             var2 = var0 + -55;
  513.          } else if (var0 >= 'a' && var0 <= 'z') {
  514.             var2 = var0 + -87;
  515.          } else {
  516.             switch (var0 >> 8) {
  517.                case 6:
  518.                   if (var0 >= 1632 && var0 <= 1641) {
  519.                      var2 = var0 - 1632;
  520.                   } else if (var0 >= 1776 && var0 <= 1785) {
  521.                      var2 = var0 - 1776;
  522.                   }
  523.                   break;
  524.                case 9:
  525.                   if (var0 >= 2406 && var0 <= 2415) {
  526.                      var2 = var0 - 2406;
  527.                   } else if (var0 >= 2534 && var0 <= 2543) {
  528.                      var2 = var0 - 2534;
  529.                   }
  530.                   break;
  531.                case 10:
  532.                   if (var0 >= 2662 && var0 <= 2671) {
  533.                      var2 = var0 - 2662;
  534.                   } else if (var0 >= 2790 && var0 <= 2799) {
  535.                      var2 = var0 - 2790;
  536.                   }
  537.                   break;
  538.                case 11:
  539.                   if (var0 >= 2918 && var0 <= 2927) {
  540.                      var2 = var0 - 2918;
  541.                   } else if (var0 >= 3047 && var0 <= 3055) {
  542.                      var2 = var0 - 3046;
  543.                   }
  544.                   break;
  545.                case 12:
  546.                   if (var0 >= 3174 && var0 <= 3183) {
  547.                      var2 = var0 - 3174;
  548.                   } else if (var0 >= 3302 && var0 <= 3311) {
  549.                      var2 = var0 - 3302;
  550.                   }
  551.                   break;
  552.                case 13:
  553.                   if (var0 >= 3430 && var0 <= 3439) {
  554.                      var2 = var0 - 3430;
  555.                   }
  556.                   break;
  557.                case 14:
  558.                   if (var0 >= 3664 && var0 <= 3673) {
  559.                      var2 = var0 - 3664;
  560.                   } else if (var0 >= 3792 && var0 <= 3801) {
  561.                      var2 = var0 - 3792;
  562.                   }
  563.                   break;
  564.                case 255:
  565.                   if (var0 >= '∩╝É' && var0 <= '∩╝Ö') {
  566.                      var2 = var0 - '∩╝É';
  567.                   }
  568.             }
  569.          }
  570.       }
  571.  
  572.       return var2 < var1 ? var2 : -1;
  573.    }
  574.  
  575.    public static boolean isSpace(char var0) {
  576.       switch (var0) {
  577.          case '\t':
  578.          case '\n':
  579.          case '\f':
  580.          case '\r':
  581.          case ' ':
  582.             return true;
  583.          default:
  584.             return false;
  585.       }
  586.    }
  587.  
  588.    public static char forDigit(int var0, int var1) {
  589.       if (var0 < var1 && var0 >= 0) {
  590.          if (var1 >= 2 && var1 <= 36) {
  591.             return var0 < 10 ? (char)(48 + var0) : (char)(97 + var0 - 10);
  592.          } else {
  593.             return '\u0000';
  594.          }
  595.       } else {
  596.          return '\u0000';
  597.       }
  598.    }
  599.  
  600.    public RexxCharX(char var1) {
  601.       this.value = var1;
  602.    }
  603.  
  604.    public char charValue() {
  605.       return this.value;
  606.    }
  607.  
  608.    public int hashCode() {
  609.       return this.value;
  610.    }
  611.  
  612.    public boolean equals(Object var1) {
  613.       if (var1 != null && var1 instanceof Character) {
  614.          return this.value == (Character)var1;
  615.       } else {
  616.          return false;
  617.       }
  618.    }
  619.  
  620.    public String toString() {
  621.       char[] var1 = new char[]{this.value};
  622.       return String.valueOf(var1);
  623.    }
  624.  
  625.    static {
  626.       isLetterTable1080through11FF = isDefinedTable1080through11FF;
  627.       isLetterTable1E00through1FFF = isDefinedTable1E00through27BF;
  628.       isLetterTable3000through33FF = isDefinedTable3000through33FF;
  629.       isLetterTableFB00throughFFFF = new long[]{6881500229564629119L, -37L, 1125899906842623L, -524288L, -1L, -1L, -1L, -1L, -1L, -65536L, -196609L, 1152640029630136575L, 0L, -11540474045136896L, -1L, 2305843009213693951L, 576460743713488896L, -274743689218L, Long.MAX_VALUE, 486341884L};
  630.       isLDTable0000through06FF = new long[]{287948901175001088L, 576460743847706622L, 0L, -36028797027352577L, -1L, -1L, -1L, -270215977642229761L, 16777215L, -65536L, -279275953455105L, 4395899027455L, -1L, 4913427206346113087L, -17179879440L, 4503588160110591L, -8194L, -536936449L, -65409L, 234134404065073567L, -562949953421312L, -4320133121L, -288511851128421633L, 8734520370987023L, 576460745995194368L, -211110526976001L, 9007199254740991999L, 288019269919145983L};
  631.       isLDTable0900through0EFF = new long[]{-864691128455135250L, 562949938692095L, -3186861885341720594L, 576460544811219359L, -3211631683292264476L, 9006925953907079L, -869759877059465234L, 281204393851839L, -878767076314341394L, 562690925803919L, -4341532606274353172L, 2251250066275783L, -4327961440926441490L, 281212990012895L, -4327961440926441492L, 281214063754719L, -4323457841299070996L, 281212992110031L, 0L, 0L, -8646911284551352322L, 268435455L, 4323434403644581270L, 872365919L};
  632.       isLDTable1080through11FF = isDefinedTable1080through11FF;
  633.       isLDTable1E00through1FFF = isDefinedTable1E00through27BF;
  634.       isLDTable3000through33FF = isDefinedTable3000through33FF;
  635.       isLDTableFB00throughFFFF = new long[]{6881500229564629119L, -37L, 1125899906842623L, -524288L, -1L, -1L, -1L, -1L, -1L, -65536L, -196609L, 1152640029630136575L, 0L, -11540474045136896L, -1L, 2305843009213693951L, 576460743780532224L, -274743689218L, Long.MAX_VALUE, 486341884L};
  636.       toLowerCaseTable = new long[]{-6173215364225870507L, 3122495741643543722L, 1274187282820877526L, 6059124173486861744L, 5592405L, 0L, 0L, 0L, 0L, 0L, 17575006099264L, 93819265613824L, 281474976702462L, 6148914689804861440L, 6148914691236495361L, 78044801355024522L, -562949953421312L, 8388607L, 0L, 0L, 6148914691236517205L, 6148914691236517205L, 6148914689806259541L, 96076792050570581L, -71777217515815168L, 280378317225728L, 2234065794919104256L, 2233819500287893248L};
  637.       toUpperCaseTable = new long[]{6100313345257810602L, -3122495741643544235L, 2472794134709276968L, -6328495726735828128L, 11184810L, 1269983369232384L, 265480L, 0L, 0L, 0L, -299067162755072L, 1032063467880447L, -281474976710656L, -6148914690341797889L, -6148914691236560894L, 156089602710049044L, 0L, -8589934592L, 127L, 0L, -6148914691236517206L, -6148914691236517206L, -6148914694097032534L, 192153584101141162L, 71777214282006783L, 4611405638678478911L, 3097319977189631L, 2251950137737224L};
  638.    }
  639. }
  640.