extra logging for IDEA-164040
[idea/community.git] / tools / lexer / jflex-changes.patch
1 Index: jflex/src/main/java/jflex/Emitter.java
2 IDEA additional info:
3 Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
4 <+>UTF-8
5 ===================================================================
6 --- jflex/src/main/java/jflex/Emitter.java      (revision de2312d6891de7fdf2752ad8e0a45983202ad5e0)
7 +++ jflex/src/main/java/jflex/Emitter.java      (revision 5b6b151f542d88ffb2ea4363c6ee8f23c7a49b09)
8 @@ -10,7 +10,9 @@
9  package jflex;
10  
11  import java.io.*;
12 -import java.util.*;
13 +import java.util.Arrays;
14 +import java.util.LinkedHashMap;
15 +import java.util.Map;
16  import java.util.regex.Matcher;
17  import java.util.regex.Pattern;
18  
19 @@ -373,7 +375,7 @@
20    
21    private void emitNextInput() {
22      println("          if (zzCurrentPosL < zzEndReadL) {");
23 -    println("            zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL);");
24 +    println("            zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL/*, zzEndReadL*/);");
25      println("            zzCurrentPosL += Character.charCount(zzInput);");
26      println("          }");
27      println("          else if (zzAtEOF) {");
28 @@ -395,14 +397,14 @@
29      println("              break zzForAction;");  
30      println("            }");
31      println("            else {");
32 -    println("              zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL);");
33 +    println("              zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL/*, zzEndReadL*/);");
34      println("              zzCurrentPosL += Character.charCount(zzInput);");
35      println("            }");
36      println("          }"); 
37    }
38  
39    private void emitHeader() {
40 -    println("/* The following code was generated by JFlex " + Main.version + " */");
41 +    println("/* The following code was generated by JFlex " + Main.version + " tweaked for IntelliJ platform */");
42      println("");
43    } 
44  
45 @@ -544,7 +546,7 @@
46    }
47  
48  
49 -  private void emitCharMapInitFunction(int packedCharMapPairs) {
50 +  private void emitCharMapInitFunction() {
51  
52      CharClasses cl = parser.getCharClasses();
53      
54 @@ -558,10 +560,14 @@
55      println("   * @return         the unpacked character translation table");
56      println("   */");
57      println("  private static char [] zzUnpackCMap(String packed) {");
58 -    println("    char [] map = new char[0x" + Integer.toHexString(cl.getMaxCharCode() + 1) + "];");
59 +    println("    int size = 0;");
60 +    println("    for (int i = 0, length = packed.length(); i < length; i += 2) {");
61 +    println("      size += packed.charAt(i);");
62 +    println("    }");
63 +    println("    char[] map = new char[size];");
64      println("    int i = 0;  /* index in packed string  */");
65      println("    int j = 0;  /* index in unpacked array */");
66 -    println("    while (i < " + 2 * packedCharMapPairs + ") {");
67 +    println("    while (i < packed.length()) {");
68      println("      int  count = packed.charAt(i++);");
69      println("      char value = packed.charAt(i++);");
70      println("      do map[j++] = value; while (--count > 0);");
71 @@ -613,85 +619,46 @@
72     * the number of char map array entries per value is
73     * ceil(count / 0xFFFF)
74     */
75 -  private int emitCharMapArray() {       
76 +  private void emitCharMapArray() {
77      CharClasses cl = parser.getCharClasses();
78  
79      if ( cl.getMaxCharCode() < 256 ) {
80        emitCharMapArrayUnPacked();
81 -      return 0; // the char map array will not be packed
82      }
83  
84      // ignores cl.getMaxCharCode(), emits all intervals instead
85  
86      intervals = cl.getIntervals();
87 -    
88 +
89 -    println("");
90 -    println("  /** ");
91 -    println("   * Translates characters to character classes");
92 -    println("   */");
93 -    println("  private static final String ZZ_CMAP_PACKED = ");
94 +    char[] exploded = new char[cl.getMaxCharCode() + 1];
95 +    for (int i = 0, k = 0; i < intervals.length && k < exploded.length; i ++) {
96 +      int count = intervals[i].end - intervals[i].start + 1;
97 +      int value = colMap[intervals[i].charClass];
98 -  
99 +
100 -    int n = 0;  // numbers of entries in current line    
101 -    print("    \"");
102 -    
103 -    int i = 0, numPairs = 0;
104 -    int count, value;
105 -    while ( i < intervals.length ) {
106 -      count = intervals[i].end-intervals[i].start+1;
107 -      value = colMap[intervals[i].charClass];
108 -
109 -      // count could be >= 0x10000
110 -      while (count > 0xFFFF) {
111 -        printUC(0xFFFF);
112 -        printUC(value);
113 -        count -= 0xFFFF;
114 -        numPairs++;
115 -        n++;       
116 +      while (count-- > 0) {
117 +        exploded[k++] = (char) value;
118        }
119 -      numPairs++;
120 -      printUC(count);
121 -      printUC(value);
122 -
123 -      if (i < intervals.length-1) {
124 -        if ( ++n >= 10 ) { 
125 -          println("\"+");
126 -          print("    \"");
127 -          n = 0;
128 -        }
129 +    }
130 -      }
131  
132 -      i++;
133 -    }
134 +    int[] sizes = EmitterCM.findBestSizes(exploded, 3);
135 +    Object[] o = EmitterCM.generateForSizes(exploded, sizes);
136 +    int totalSize = EmitterCM.getTotalBytes((char[][]) o[0], sizes, (int[]) o[1]);
137 -      
138 +
139 -    println("\";");
140 -    println();
141 -
142 +    println("");
143      println("  /** ");
144      println("   * Translates characters to character classes");
145 +    println("   * Chosen bits are " + Arrays.toString(sizes));
146 +    println("   * Total runtime size is " + totalSize + " bytes");
147      println("   */");
148 -    println("  private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED);");
149 +
150 +    println("  public static int ZZ_CMAP(int ch) {\n" +
151 +            "    return " + EmitterCM.genAccess("ZZ_CMAP_" + "A", "ch", 16, sizes, (int[]) o[3], (int[]) o[4], (boolean[]) o[2]) + ";\n" +
152 +            "  }");
153      println();
154 -    return numPairs;
155 -  }
156  
157 -
158 -  /**
159 -   * Print number as octal/unicode escaped string character.
160 -   * 
161 -   * @param c   the value to print
162 -   * @prec  0 <= c <= 0xFFFF 
163 -   */
164 -  private void printUC(int c) {
165 -    if (c > 255) {
166 -      out.print("\\u");
167 -      if (c < 0x1000) out.print("0");
168 -      out.print(Integer.toHexString(c));
169 +    String tables = EmitterCM.genTables((char[][]) o[0], sizes, (int[]) o[1], (boolean[]) o[2]);
170 +    println(tables);
171 -    }
172 +  }
173 -    else {
174 -      out.print("\\");
175 -      out.print(Integer.toOctalString(c));
176 -    }    
177 -  }
178  
179  
180    private void emitRowMapArray() {
181 @@ -949,7 +916,7 @@
182        println("      for (zzCurrentPosL = zzStartRead  ;");
183        println("           zzCurrentPosL < zzMarkedPosL ;");
184        println("           zzCurrentPosL += zzCharCount ) {");
185 -      println("        zzCh = Character.codePointAt(zzBufferL, zzCurrentPosL, zzMarkedPosL);");
186 +      println("        zzCh = Character.codePointAt(zzBufferL, zzCurrentPosL/*, zzMarkedPosL*/);");
187        println("        zzCharCount = Character.charCount(zzCh);");
188        println("        switch (zzCh) {");
189        println("        case '\\u000B':"); 
190 @@ -993,7 +960,7 @@
191          println("        // peek one character ahead if it is \\n (if we have counted one line too much)");
192          println("        boolean zzPeek;");
193          println("        if (zzMarkedPosL < zzEndReadL)");
194 -        println("          zzPeek = zzBufferL[zzMarkedPosL] == '\\n';");
195 +        println("          zzPeek = zzBufferL.charAt(zzMarkedPosL) == '\\n';");
196          println("        else if (zzAtEOF)");
197          println("          zzPeek = false;");
198          println("        else {");
199 @@ -1004,7 +971,7 @@
200          println("          if (eof) ");
201          println("            zzPeek = false;");
202          println("          else ");
203 -        println("            zzPeek = zzBufferL[zzMarkedPosL] == '\\n';");
204 +        println("            zzPeek = zzBufferL.charAt(zzMarkedPosL) == '\\n';");
205          println("        }");
206          println("        if (zzPeek) yyline--;");
207          println("      }");
208 @@ -1016,7 +983,7 @@
209        // if match was empty, last value of zzAtBOL can be used
210        // zzStartRead is always >= 0
211        println("      if (zzMarkedPosL > zzStartRead) {");
212 -      println("        switch (zzBufferL[zzMarkedPosL-1]) {");
213 +      println("        switch (zzBufferL.charAt(zzMarkedPosL-1)) {");
214        println("        case '\\n':");
215        println("        case '\\u000B':"); 
216        println("        case '\\u000C':"); 
217 @@ -1027,7 +994,7 @@
218        println("          break;"); 
219        println("        case '\\r': "); 
220        println("          if (zzMarkedPosL < zzEndReadL)");
221 -      println("            zzAtBOL = zzBufferL[zzMarkedPosL] != '\\n';");
222 +      println("            zzAtBOL = zzBufferL.charAt(zzMarkedPosL) != '\\n';");
223        println("          else if (zzAtEOF)");
224        println("            zzAtBOL = false;");
225        println("          else {");
226 @@ -1038,7 +1005,7 @@
227        println("            if (eof) ");
228        println("              zzAtBOL = false;");
229        println("            else ");
230 -      println("              zzAtBOL = zzBufferL[zzMarkedPosL] != '\\n';");
231 +      println("              zzAtBOL = zzBufferL.charAt(zzMarkedPosL) != '\\n';");
232        println("          }");      
233        println("          break;"); 
234        println("        default:"); 
235 @@ -1073,7 +1040,11 @@
236  
237    
238    private void emitGetRowMapNext() {
239 -    println("          int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ];");
240 +    CharClasses cl = parser.getCharClasses();
241 +
242 +    boolean unpacked = cl.getMaxCharCode() < 256;
243 +
244 +    println("          int zzNext = zzTransL[ zzRowMapL[zzState] + "+ (unpacked? "zzCMapL[zzInput]" : "ZZ_CMAP(zzInput)") +" ];");
245      println("          if (zzNext == "+DFA.NO_TARGET+") break zzForAction;");
246      println("          zzState = zzNext;");
247      println();
248 @@ -1157,6 +1128,9 @@
249    }
250  
251    private void emitActions() {
252 +    CharClasses cl = parser.getCharClasses();
253 +    boolean unpacked = cl.getMaxCharCode() < 256;
254 +
255      println("        switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {");
256  
257      int i = actionTable.size()+1;
258 @@ -1170,27 +1144,27 @@
259        if (action.lookAhead() == Action.FIXED_BASE) {
260          println("            // lookahead expression with fixed base length");
261          println("            zzMarkedPos = Character.offsetByCodePoints");
262 -        println("                (zzBufferL, zzStartRead, zzEndRead - zzStartRead, zzStartRead, " + action.getLookLength() + ");");
263 +        println("                (zzBufferL/*, zzStartRead, zzEndRead - zzStartRead*/, zzStartRead, " + action.getLookLength() + ");");
264        }
265        
266        if (action.lookAhead() == Action.FIXED_LOOK || 
267            action.lookAhead() == Action.FINITE_CHOICE) {
268          println("            // lookahead expression with fixed lookahead length");
269          println("            zzMarkedPos = Character.offsetByCodePoints");
270 -        println("                (zzBufferL, zzStartRead, zzEndRead - zzStartRead, zzMarkedPos, -" + action.getLookLength() + ");");
271 +        println("                (zzBufferL/*, zzStartRead, zzEndRead - zzStartRead*/, zzMarkedPos, -" + action.getLookLength() + ");");
272        }
273        
274        if (action.lookAhead() == Action.GENERAL_LOOK) {
275          println("            // general lookahead, find correct zzMarkedPos");
276          println("            { int zzFState = "+dfa.entryState[action.getEntryState()]+";");
277          println("              int zzFPos = zzStartRead;");
278 -        println("              if (zzFin.length <= zzBufferL.length) { zzFin = new boolean[zzBufferL.length+1]; }");
279 +        println("              if (zzFin.length <= zzBufferL.length()) { zzFin = new boolean[zzBufferL.length()+1]; }");
280          println("              boolean zzFinL[] = zzFin;");
281          println("              while (zzFState != -1 && zzFPos < zzMarkedPos) {");
282          println("                zzFinL[zzFPos] = ((zzAttrL[zzFState] & 1) == 1);");
283 -        println("                zzInput = Character.codePointAt(zzBufferL, zzFPos, zzMarkedPos);");
284 +        println("                zzInput = Character.codePointAt(zzBufferL, zzFPos/*, zzMarkedPos*/);");
285          println("                zzFPos += Character.charCount(zzInput);");
286 -        println("                zzFState = zzTransL[ zzRowMapL[zzFState] + zzCMapL[zzInput] ];");
287 +        println("                zzFState = zzTransL[ zzRowMapL[zzFState] + " + (unpacked ? "zzCMapL[zzInput]" : "ZZ_CMAP(zzInput)") + " ];");
288          println("              }");
289          println("              if (zzFState != -1) { zzFinL[zzFPos++] = ((zzAttrL[zzFState] & 1) == 1); } ");
290          println("              while (zzFPos <= zzMarkedPos) {");
291 @@ -1200,9 +1174,9 @@
292          println("              zzFState = "+dfa.entryState[action.getEntryState()+1]+";");
293          println("              zzFPos = zzMarkedPos;");
294          println("              while (!zzFinL[zzFPos] || (zzAttrL[zzFState] & 1) != 1) {");
295 -        println("                zzInput = Character.codePointBefore(zzBufferL, zzFPos, zzStartRead);");
296 +        println("                zzInput = Character.codePointBefore(zzBufferL, zzFPos/*, zzStartRead*/);");
297          println("                zzFPos -= Character.charCount(zzInput);");
298 -        println("                zzFState = zzTransL[ zzRowMapL[zzFState] + zzCMapL[zzInput] ];");
299 +        println("                zzFState = zzTransL[ zzRowMapL[zzFState] + " + (unpacked ? "zzCMapL[zzInput]" : "ZZ_CMAP(zzInput)") + " ];");
300          println("              };");
301          println("              zzMarkedPos = zzFPos;");
302          println("            }");
303 @@ -1230,10 +1204,10 @@
304      EOFActions eofActions = parser.getEOFActions();
305  
306      if ( scanner.eofCode != null ) 
307 -      println("            zzDoEOF();");
308 +      println("        zzDoEOF();");
309        
310      if ( eofActions.numActions() > 0 ) {
311 -      println("            switch (zzLexicalState) {");
312 +      println("        switch (zzLexicalState) {");
313        
314        // pick a start value for break case labels. 
315        // must be larger than any value of a lex state:
316 @@ -1420,7 +1394,7 @@
317  
318      emitLexicalStates();
319     
320 -    int packedCharMapPairs = emitCharMapArray();
321 +    emitCharMapArray();
322      
323      emitActionTable();
324      
325 @@ -1444,7 +1418,7 @@
326      
327      emitConstructorDecl();
328          
329 -    emitCharMapInitFunction(packedCharMapPairs);
330 +    emitCharMapInitFunction();
331  
332      if (scanner.debugOption) {
333        println("");
334 Index: jflex/src/main/java/jflex/EmitterCM.java
335 IDEA additional info:
336 Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
337 <+>UTF-8
338 ===================================================================
339 --- jflex/src/main/java/jflex/EmitterCM.java    (revision 5b6b151f542d88ffb2ea4363c6ee8f23c7a49b09)
340 +++ jflex/src/main/java/jflex/EmitterCM.java    (revision 5b6b151f542d88ffb2ea4363c6ee8f23c7a49b09)
341 @@ -0,0 +1,328 @@
342 +package jflex;
343 +
344 +import java.io.StringWriter;
345 +
346 +/**
347 + * Based on generatecharacter/GenerateCharacter.java
348 + * from http://hg.openjdk.java.net tailored to our needs
349 + *
350 + * @author gregsh
351 + */
352 +class EmitterCM {
353 +
354 +  static int[] findBestSizes(char[] map, int partitions) {
355 +    int[] curMin = {Integer.MAX_VALUE};
356 +    int[][] minSizes = {null};
357 +    while (partitions > 0) {
358 +      permuteSizesAndFindBest(map, new int[partitions--], curMin, minSizes);
359 +    }
360 +    if (minSizes[0] == null) {
361 +      throw new IllegalArgumentException("best sizes not found");
362 +    }
363 +    return minSizes[0];
364 +  }
365 +
366 +  private static void permuteSizesAndFindBest(char[] map, int[] sizes, int[] curMin, int[][] minSizes) {
367 +    int bitsTotal = 0; // 21 for 0x10ffff
368 +    for (int i = map.length; i > 0; i >>= 1) {
369 +      bitsTotal++;
370 +    }
371 +
372 +    int last = sizes.length - 1;
373 +
374 +    for (int j = last, sum = 0; true ; j = last, sum = 0) {
375 +      for (int i = 0; i <= last; i++) {
376 +        if (sizes[i] == 0 && i != last) { sum = 0; break; }
377 +        sum += sizes[i];
378 +      }
379 +      if (sum == bitsTotal) {
380 +        int newMin = tryGenerateTables(map, sizes);
381 +        //System.out.println(Arrays.toString(sizes) + " -> " + newMin);
382 +        if (curMin[0] > newMin) {
383 +          curMin[0] = newMin;
384 +          minSizes[0] = sizes.clone();
385 +        }
386 +      }
387 +
388 +      while (j >= 0 && sizes[j] == bitsTotal) j --;
389 +      if (j < 0) break;
390 +
391 +      for (int j0 = j; j0 < last; j0++) {
392 +        sizes[j0 + 1] = 0;
393 +      }
394 +      sizes[j]++;
395 +    }
396 +  }
397 +
398 +  private static int tryGenerateTables(char[] map, int[] sizes) {
399 +    try {
400 +      Object[] o = generateForSizes(map, sizes);
401 +      char[][] tables = (char[][])o[0];
402 +      int[] bytes = (int[])o[1];
403 +      return getTotalBytes(tables, sizes, bytes);
404 +    }
405 +    catch (IllegalArgumentException e) {
406 +      return Integer.MAX_VALUE;
407 +    }
408 +  }
409 +
410 +  static int getTotalBytes(char[][] tables, int[] sizes, int[] bytes) {
411 +    int totalBytes = 0;
412 +    for (int k = 0; k < sizes.length - 1; k++) {
413 +      totalBytes += tables[k].length * bytes[k] << 1;
414 +    }
415 +    totalBytes += ((((tables[sizes.length - 1].length * 32) + 31) >> 5) << 1);
416 +    return totalBytes;
417 +  }
418 +
419 +
420 +  private static char[][] buildTable(char[] map, int size) {
421 +    int n = map.length;
422 +    if (((n >> size) << size) != n) {
423 +      throw new IllegalArgumentException("Length " + n + " is not a multiple of " + (1 << size));
424 +    }
425 +    int m = 1 << size;
426 +    // We know the final length of the new map up front.
427 +    char[] newmap = new char[n >> size];
428 +    // The buffer is used temporarily to hold data for the compressed table
429 +    // because we don't know its final length yet.
430 +    char[] buffer = new char[n];
431 +    int ptr = 0;
432 +    OUTER:
433 +    for (int i = 0; i < n; i += m) {
434 +      // For every block of size m in the original map...
435 +      MIDDLE:
436 +      for (int j = 0; j < ptr; j += m) {
437 +        // Find out whether there is already a block just like it in the buffer.
438 +        for (int k = 0; k < m; k++) {
439 +          if (buffer[j + k] != map[i + k])
440 +            continue MIDDLE;
441 +        }
442 +        // There is a block just like it at position j, so just
443 +        // put its index into the new map (thereby sharing it).
444 +        newmap[i >> size] = (char)(j >> size);
445 +        continue OUTER;
446 +      } // end MIDDLE
447 +      // There is no block just like it already, so add it to
448 +      // the buffer and put its index into the new map.
449 +      System.arraycopy(map, i, buffer, ptr, m);
450 +      newmap[i >> size] = (char)(ptr >> size);
451 +      ptr += m;
452 +    } // end OUTER
453 +    // Now we know how char the compressed table should be,
454 +    // so create a new array and copy data from the temporary buffer.
455 +    char[] newdata = new char[ptr];
456 +    System.arraycopy(buffer, 0, newdata, 0, ptr);
457 +    // Return the new map and the new data table.
458 +    return new char[][]{newmap, newdata};
459 +  }
460 +
461 +
462 +  static Object[] generateForSizes(char[] map, int[] sizes) {
463 +    int sum = 0;
464 +    int[] shifts = new int[sizes.length];
465 +    for (int k = sizes.length - 1; k >= 0; k--) {
466 +      shifts[k] = sum;
467 +      sum += sizes[k];
468 +    }
469 +    if ((1 << sum) < map.length || (1 << (sum - 1)) >= map.length) {
470 +      throw new IllegalArgumentException("Bit field widths total to " + sum +
471 +                               ": wrong total for map of size " + map.length);
472 +    }
473 +    // need a table for each set of lookup bits in char
474 +    char[][] tables = new char[sizes.length][];
475 +    // the last table is the map
476 +    tables[sizes.length - 1] = map;
477 +    for (int j = sizes.length - 1; j > 0; j--) {
478 +      //if (verbose && bins == 0)
479 +      //  System.err.println("Building map " + (j + 1) + " of bit width " + sizes[j]);
480 +      char[][] temp = buildTable(tables[j], sizes[j]);
481 +      tables[j - 1] = temp[0];
482 +      tables[j] = temp[1];
483 +    }
484 +    boolean[] preshifted = new boolean[sizes.length];
485 +    int[] zeroextend = new int[sizes.length];
486 +    int[] bytes = new int[sizes.length];
487 +    for (int j = 0; j < sizes.length - 1; j++) {
488 +      int len = tables[j + 1].length;
489 +      int size = sizes[j + 1];
490 +      if (len > 0x100 && (len >> size) <= 0x100) {
491 +        len >>= size;
492 +        preshifted[j] = false;
493 +      }
494 +      else if (len > 0x10000 && (len >> size) <= 0x10000) {
495 +        len >>= size;
496 +        preshifted[j] = false;
497 +      }
498 +      else {
499 +        preshifted[j] = true;
500 +      }
501 +      if (len > 0x7F && len <= 0xFF) {
502 +      }
503 +      else if (len > 0x7FFF && len <= 0xFFFF) {
504 +        zeroextend[j] = 0xFFFF;
505 +      }
506 +      else {
507 +        zeroextend[j] = 0;
508 +      }
509 +      if (len <= 0x100) bytes[j] = 1;
510 +      else if (len <= 0x10000) bytes[j] = 2;
511 +      else bytes[j] = 4;
512 +    }
513 +    preshifted[sizes.length - 1] = true;
514 +    zeroextend[sizes.length - 1] = 0;
515 +    bytes[sizes.length - 1] = 0;
516 +
517 +    return new Object[] { tables, bytes, preshifted, shifts, zeroextend};
518 +  }
519 +
520 +  static String genAccess(String tbl, String var, int bits, int[] sizes, int[] shifts, int[] zeroextend, boolean[] preshifted) {
521 +    String access = null;
522 +    int bitoffset = bits == 1 ? 5 : bits == 2 ? 4 : bits == 4 ? 3 : 0;
523 +    for (int k = 0; k < sizes.length; k++) {
524 +      String tableName = "ZZ_CMAP_" + String.valueOf((char) ('Z' - k));
525 +      int offset = ((k < sizes.length - 1) ? 0 : bitoffset);
526 +      int shift = shifts[k] + offset;
527 +      String shifted = (shift == 0) ? var : "(" + var + ">>" + shift + ")";
528 +      int mask = (1 << (sizes[k] - offset)) - 1;
529 +      String masked = (k == 0) ? shifted :
530 +              "(" + shifted + "&0x" + Integer.toHexString(mask) + ")";
531 +      String index = (k == 0) ? masked :
532 +              (mask == 0) ? access : "(" + access + "|" + masked + ")";
533 +      String indexNoParens = (index.charAt(0) != '(') ? index :
534 +              index.substring(1, index.length() - 1);
535 +      String tblname = (k == sizes.length - 1) ? tbl : tableName;
536 +      String fetched = tblname + "[" + indexNoParens + "]";
537 +      String zeroextended = (zeroextend[k] == 0) ? fetched :
538 +              "(" + fetched + "&0x" + Integer.toHexString(zeroextend[k]) + ")";
539 +      int adjustment = preshifted[k] ? 0 :
540 +              sizes[k + 1] - ((k == sizes.length - 2) ? bitoffset : 0);
541 +      String adjusted = (preshifted[k] || adjustment == 0) ? zeroextended :
542 +              "(" + zeroextended + "<<" + adjustment + ")";
543 +      String bitshift = (bits == 1) ? "(" + var + "&0x1F)" :
544 +              (bits == 2) ? "((" + var + "&0xF)<<1)" :
545 +                      (bits == 4) ? "((" + var + "&7)<<2)" : null;
546 +      String extracted = ((k < sizes.length - 1) || (bits >= 8)) ? adjusted :
547 +              "((" + adjusted + ">>" + bitshift + ")&" +
548 +                      (bits == 4 ? "0xF" : String.valueOf((1 << bits) - 1)) + ")";
549 +      access = extracted;
550 +    }
551 +    return access;
552 +  }
553 +
554 +
555 +  static String genTables(char[][] tables, int[] sizes, int[] bytes, boolean[] preshifted) {
556 +    StringBuffer result = new StringBuffer();
557 +
558 +    for (int k = 0; k < sizes.length - 1; k++) {
559 +      String tableName = "ZZ_CMAP_" + String.valueOf((char)('Z' - k));
560 +      genTable(result, tableName, tables[k], 0, bytes[k] << 3, preshifted[k], sizes[k + 1]);
561 +      result.append("\n");
562 +    }
563 +    genTable(result, "ZZ_CMAP_" + "A", tables[sizes.length - 1], 0, 16, false, 0);
564 +
565 +    return result.toString();
566 +  }
567 +
568 +  private static void genTable(StringBuffer result, String name,
569 +                               char[] table, int extract, int bits,
570 +                               boolean preshifted, int shift) {
571 +
572 +    String atype = "char";
573 +    int entriesPerChar = 1;
574 +    boolean noConversion = atype.equals("char");
575 +    boolean shiftEntries = preshifted && shift != 0;
576 +
577 +    result.append("  /*");
578 +    result.append(" The ").append(name).append(" table has ").append(table.length).append(" entries */\n");
579 +    result.append("  static final ");
580 +    result.append(atype);
581 +    result.append(" ").append(name).append("[");
582 +    result.append("] = zzUnpackCMap(\n");
583 +    StringWriter theString = new MyStringWriter();
584 +    int entriesInCharSoFar = 0;
585 +    char ch = '\u0000';
586 +    for (int j = 0; j < table.length; ++j) {
587 +      int entry = table[j] >> extract;
588 +      if (shiftEntries) entry <<= shift;
589 +      if (entry >= (1L << bits)) {
590 +        throw new IllegalArgumentException("Entry too big");
591 +      }
592 +      // Pack multiple entries into a character
593 +      ch = (char) (((int) ch >> bits) | (entry << (entriesPerChar - 1) * bits));
594 +      ++entriesInCharSoFar;
595 +      if (entriesInCharSoFar == entriesPerChar) {
596 +        // Character is full
597 +        theString.append(ch);
598 +        entriesInCharSoFar = 0;
599 +        ch = '\u0000';
600 +      }
601 +    }
602 +    if (entriesInCharSoFar > 0) {
603 +      while (entriesInCharSoFar < entriesPerChar) {
604 +        ch = (char) ((int) ch >> bits);
605 +        ++entriesInCharSoFar;
606 +      }
607 +      theString.append(ch);
608 +    }
609 +    theString.flush();
610 +    result.append(theString.getBuffer());
611 +    if (noConversion) {
612 +      result.append(")");
613 +    }
614 +    result.append(";\n");
615 +  }
616 +
617 +  private static class MyStringWriter extends StringWriter {
618 +    char cur;
619 +    int count;
620 +
621 +    @Override
622 +    public StringWriter append(char c) {
623 +      if (cur == c && count <= 0xffff) {
624 +        count++;
625 +      }
626 +      else {
627 +        if (count > 0) {
628 +          appendImpl((char) count);
629 +          appendImpl(cur);
630 +        }
631 +        cur = c;
632 +        count = 1;
633 +      }
634 +      return this;
635 +    }
636 +
637 +    @Override
638 +    public void flush() {
639 +      if (count > 0) {
640 +        appendImpl((char) count);
641 +        appendImpl(cur);
642 +        count = 0;
643 +      }
644 +      if (limit > 0) {
645 +        super.append('"');
646 +        limit = 0;
647 +      }
648 +    }
649 +
650 +    int limit;
651 +
652 +    void appendImpl(char c) {
653 +      if (getBuffer().length() >= limit) {
654 +        if (limit > 0) super.append("\"+\n");
655 +        limit = getBuffer().length() + 78;
656 +        super.append("    \"");
657 +      }
658 +      if (c > 255) {
659 +        super.append("\\u");
660 +        if (c < 0x1000) super.append("0");
661 +        super.append(Integer.toHexString(c));
662 +      }
663 +      else {
664 +        super.append("\\");
665 +        super.append(Integer.toOctalString(c));
666 +      }
667 +    }
668 +  }
669 +}