| /******************************************************************************* |
| * Copyright (c) 2007 University of Illinois at Urbana-Champaign and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * UIUC - Initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.photran.internal.core.parser; |
| |
| import org.eclipse.photran.internal.core.lexer.*; import org.eclipse.photran.internal.core.analysis.binding.ScopingNode; import org.eclipse.photran.internal.core.SyntaxException; import java.io.IOException; |
| |
| import java.util.AbstractList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.io.ByteArrayOutputStream; |
| import java.io.PrintStream; |
| |
| |
| import java.util.zip.Inflater; |
| |
| import org.eclipse.photran.internal.core.parser.Parser.Nonterminal; |
| import org.eclipse.photran.internal.core.parser.Parser.Production; |
| |
| |
| @SuppressWarnings("all") |
| final class ExprParsingTables extends ParsingTables |
| { |
| private static ExprParsingTables instance = null; |
| |
| public static ExprParsingTables getInstance() |
| { |
| if (instance == null) |
| instance = new ExprParsingTables(); |
| return instance; |
| } |
| |
| @Override |
| public int getActionCode(int state, org.eclipse.photran.internal.core.lexer.Token lookahead) |
| { |
| return ActionTable.getActionCode(state, lookahead); |
| } |
| |
| @Override |
| public int getActionCode(int state, int lookaheadTokenIndex) |
| { |
| return ActionTable.get(state, lookaheadTokenIndex); |
| } |
| |
| @Override |
| public int getGoTo(int state, Nonterminal nonterminal) |
| { |
| return GoToTable.getGoTo(state, nonterminal); |
| } |
| |
| @Override |
| public int getRecoveryCode(int state, org.eclipse.photran.internal.core.lexer.Token lookahead) |
| { |
| return RecoveryTable.getRecoveryCode(state, lookahead); |
| } |
| |
| /** |
| * The ACTION table. |
| * <p> |
| * The ACTION table maps a state and an input symbol to one of four |
| * actions: shift, reduce, accept, or error. |
| */ |
| protected static final class ActionTable |
| { |
| /** |
| * Returns the action the parser should take if it is in the given state |
| * and has the given symbol as its lookahead. |
| * <p> |
| * The result value should be interpreted as follows: |
| * <ul> |
| * <li> If <code>result & ACTION_MASK == SHIFT_ACTION</code>, |
| * shift the terminal and go to state number |
| * <code>result & VALUE_MASK</code>. |
| * <li> If <code>result & ACTION_MASK == REDUCE_ACTION</code>, |
| * reduce by production number <code>result & VALUE_MASK</code>. |
| * <li> If <code>result & ACTION_MASK == ACCEPT_ACTION</code>, |
| * parsing has completed successfully. |
| * <li> Otherwise, a syntax error has been found. |
| * </ul> |
| * |
| * @return a code for the action to take (see above) |
| */ |
| protected static int getActionCode(int state, org.eclipse.photran.internal.core.lexer.Token lookahead) |
| { |
| assert 0 <= state && state < Parser.NUM_STATES; |
| assert lookahead != null; |
| |
| Integer index = Parser.terminalIndices.get(lookahead.getTerminal()); |
| if (index == null) |
| return 0; |
| else |
| return get(state, index); |
| } |
| |
| protected static final int[] rowmap = { 0, 1, 2, 3, 4, 2, 5, 6, 7, 8, 9, 3, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 1, 37, 38, 4, 39, 40, 41, 42, 43, 44, 0, 6, 45, 0, 46, 5, 7, 47, 48, 49, 50, 7, 11, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 8, 9, 70, 71, 72, 73, 74, 75, 76, 77, 78, 10, 79, 12, 17, 80, 24, 81, 26, 82, 83, 84, 0, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 28, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 13, 109, 30, 31, 110, 36, 111, 112, 113, 114, 115, 116, 117, 0, 14, 118, 119, 120, 121, 15, 122, 37, 123, 124, 125, 126, 16, 127, 128, 129, 130, 131, 41, 132, 133, 18, 134, 42, 135, 0, 1, 136, 2, 137, 43, 138, 44, 139, 19, 140, 45, 3, 141, 48, 142, 143, 144, 145, 146, 147, 148, 49, 149, 150, 20, 151, 152, 153, 154, 2, 21, 155, 156, 157, 158, 159, 160, 161, 162, 22, 163, 164, 165, 166, 167, 50, 168, 169, 170, 51, 171, 172, 52, 173, 53, 174, 175, 176, 177, 178, 54, 55 }; |
| protected static final int[] columnmap = { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 3, 0, 0, 0, 0, 4, 0, 0, 5, 6, 0, 0, 0, 7, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 13, 0, 0, 0, 14, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 16, 17, 18, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 21, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 25, 0, 0, 26, 27, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 30, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 0, 0, 0, 34, 0, 0, 0, 0, 0, 0, 0, 35, 0, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, 38, 0, 0, 0, 0, 0, 0, 0, 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0 }; |
| |
| public static int get(int row, int col) |
| { |
| if (isErrorEntry(row, col)) |
| return 0; |
| else if (columnmap[col] % 2 == 0) |
| return lookupValue(rowmap[row], columnmap[col]/2) >>> 16; |
| else |
| return lookupValue(rowmap[row], columnmap[col]/2) & 0xFFFF; |
| } |
| |
| protected static boolean isErrorEntry(int row, int col) |
| { |
| final int INT_BITS = 32; |
| int sigmapRow = row; |
| |
| int sigmapCol = col / INT_BITS; |
| int bitNumberFromLeft = col % INT_BITS; |
| int sigmapMask = 0x1 << (INT_BITS - bitNumberFromLeft - 1); |
| |
| return (lookupSigmap(sigmapRow, sigmapCol) & sigmapMask) == 0; |
| } |
| |
| protected static int[][] sigmap = null; |
| |
| protected static void sigmapInit() |
| { |
| try |
| { |
| final int rows = 231; |
| final int cols = 8; |
| final int compressedBytes = 549; |
| final int uncompressedBytes = 7393; |
| |
| byte[] decoded = new byte[compressedBytes]; |
| base64Decode(decoded, |
| "eNrtWEFuwyAQHFNaoZ4cv8C95Rk++JhH+SF9TJ5W46SNawyzsE" + |
| "aRqlIpkToBhl12dhc4DDANWlj4YQe8+e93uPnT4KO9NOhgTngB" + |
| "PoH22mNw1hmcHVw/4+MNt3d8uuHY4tjH4fftgGb+WyhM9/+hdw" + |
| "shz89jAb/7IPzp+n50iA7Gf2WfZs8+jD+zH6h/GL9x139S/8z4" + |
| "Yp+TP0Nq/XL+D//8mt8L7w+S/pXbR3e+Ov7l/Nn+oX0QxpcpjS" + |
| "9Q+7H44/pyEZ0/5He+xb9DepD5Mfuv4ns7bI5+LMPL1KIRO0sw" + |
| "fauNg9oveX7p+j+nn8Il/M+S+HpE8Nh8dXzp8bT9tvyz7sc//r" + |
| "dxeXxXu5/0/grqu4r6RfNT5fgW5C9hfnoty29bBYnoa4j3Mn3d" + |
| "8rt6fvbBj+yfnf+39TViaapPKqi8vn8urq3/pf1PrD4U1S9MAh" + |
| "T1zWH1e7l/kv0PMBL7WmF/Uoe/vD9qivRJFJ9I+J/g2vWX+Qam" + |
| "/e7Ph0x9YfpG+wepfkX0l9bPLrc+z+x/hO8/sf5oN/6P4CfrH7" + |
| "L9G+ZXnX+18VNc/6zyr+p+kfpBMt8k51fVl4z81cgKqB1+gb5g" + |
| "5udk67P7d9j58vRVrv+6/UX2N+X5Q30/Ca6uXw97nym7H3r90q" + |
| "1fnh+FAnLE/TWS+hZF9csB/il6v8TT85OT8uP5TVs/Mn1R6I/a" + |
| "fux9tHJ9VPZ+zfQ7P3+w998o/gVH6h8Z"); |
| |
| byte[] buffer = new byte[uncompressedBytes]; |
| Inflater inflater = new Inflater(); |
| inflater.setInput(decoded, 0, compressedBytes); |
| inflater.inflate(buffer); |
| inflater.end(); |
| |
| sigmap = new int[rows][cols]; |
| for (int index = 0; index < uncompressedBytes-1; index += 4) |
| { |
| int byte1 = 0x000000FF & (int)buffer[index + 0]; |
| int byte2 = 0x000000FF & (int)buffer[index + 1]; |
| int byte3 = 0x000000FF & (int)buffer[index + 2]; |
| int byte4 = 0x000000FF & (int)buffer[index + 3]; |
| |
| int element = index / 4; |
| int row = element / cols; |
| int col = element % cols; |
| sigmap[row][col] = byte1 << 24 | byte2 << 16 | byte3 << 8 | byte4; |
| } |
| } |
| catch (Exception e) |
| { |
| throw new Error(e); |
| } |
| } |
| |
| protected static int lookupSigmap(int row, int col) |
| { |
| return sigmap[row][col]; |
| } |
| |
| protected static int[][] value = null; |
| |
| protected static void valueInit() |
| { |
| try |
| { |
| final int rows = 179; |
| final int cols = 21; |
| final int compressedBytes = 2683; |
| final int uncompressedBytes = 15037; |
| |
| byte[] decoded = new byte[compressedBytes]; |
| base64Decode(decoded, |
| "eNrVWkuMHFcV7TiJE8Z2LCUrQEJiE0ZIKBJRyMcWvK6nscGOwX" + |
| "biBQhYsMMSrEAxzu+xYEEQCkIggU0QIIJ/CAmS+G/PjMdjx7aE" + |
| "EAgisPNbJCFKCOD8CATMvXX6vHtfVXdP22aE3Fe3zjn3nve6pq" + |
| "q6Pt2T3tuRVxqT/KnkdbValK6V5Xu698hyqeS3J8528ist6N6T" + |
| "Fgq+M71bde1anJbI8l1wVG9ppDHJ91VvURuCpYPQ7KVx66GWrj" + |
| "dH+JNGGpP8jeR1PX1tD9+fltZ4CLrmCyQXSsp65pqspzniTRrh" + |
| "D/GmTgdIrdHpgKWHoNlD0lVyHVVvo426jLdjCaQ2NIdm+nzbBZ" + |
| "7yPqqx2Ec1X9ppvNKC9GW/j9KXmvvIr2f6QP1+a+Pa3js3kEyX" + |
| "cW1eT+cyJ+fEa6qTbgDrfqXT94U652y7qlc00sbqFeXUhmDU5J" + |
| "o6p9W8IzyskTYCZT83kMyCFZ2zWevFaQ05Pk9LvU4NYvogGDU5" + |
| "0qqey6gh+z1t6r/fJW8ctt/DGQ1ZzzPKqQ3BqMmRVvU8nKle1p" + |
| "DP+8uylevUMASjJpfPe+55Xy/Oacic56Rap4YhGDU50qqeV+fi" + |
| "Co20Pa6QI3ZFfeyuAKbbgKjDh17ppV9muRUqvKAh2/MF2SJ1ah" + |
| "DTcjBqcqRVPZdRI3zeq8lyv1eTfr9rt9zv6SMppo+lsbRK1n5V" + |
| "/TesAlIDU5VWphVxVfowNHppdbpdal26hIf00eolDdlHL8k71q" + |
| "lhCEZNjrSq51D2t9fvtz6uJyuRTJdpTVkD9vo3a6SxeLNyakMZ" + |
| "vdY0e0irei6xTEPmXCbVOjUMa3fW7CGt6nlcFv6oIUdCTmqNtA" + |
| "6MuvRa1XMo0Xs9hr3U1rFX2Ju+oVW60gPlCFHPaygyqTXSejDq" + |
| "0mtVz6HmPOaPNI75I/4ap93GfchfNBSZ1EAw6tJrVc+hZL33eQ" + |
| "z7qK3jttY+JnrpO+WIfq94Z7yTrEQZv6HUTVdynX7bs1eR7Tmx" + |
| "vXXtcNtTu9iejb/nuMdwXJFcRmxpepFwpO+XI2SNg4YiMn0SOn" + |
| "0KCA99pdeqnnNUb+zHsQRSG5qjXfPV6q8aiunTQGogGHX2fsZ6" + |
| "qMk9bXbEMQ15h7H0WSA1EIyaHGlVz2WmEa4d6QfD9nvaiv2ePp" + |
| "evHUPm7G7ufx/S3Vw8I2xuzln9U0ORSQ0Eoy69Vq23Z3bED2nI" + |
| "1shJDQSjLr1W9Ryq9dfd0NBfHPZZTl9ofYIet6UpRetUU+WIag" + |
| "p9OLTrR4z2jJAODN3vD7TuFZ+wpSlF66RyPZ9gwlFfO9yI0dZz" + |
| "YsfQ89KO1r3NKHPuHHafrN1+z0f993v37gHPMncPVvVe+7GGIp" + |
| "MaCEZdeq3qOZRs3d0ew25qVNLRYh/tZsJV7yM3Ivv2eAx7qFFJ" + |
| "p5peJFz1nG7EaNejdHq047Oxnkc9hqOK5DLimaYXCUe9nm5E9s" + |
| "14DDOKYaZ7v3W8t3s/+ujBhUrhO+QxHFIMh7r3Wsd7u/eijx5c" + |
| "qBS+Yx7DMcVwrJus473dhD56cKFS+KY8hinFMNW9zzre270Pff" + |
| "TgQqXwHfYYDiuSt+Y8zLSeHzHsWBr8fUh5LNW1ft+HzMOc4YjH" + |
| "cESRvPW3H2Faz4/ItQMewwFF8tacB5jW8yNybdJjmFQkb805yb" + |
| "SeH5Fr0x7DtCJ5a85ppvX8iFzb7zHsVyRvzbmfaT0/ItcOegwH" + |
| "Fclbcx5kWs+PyLVZj2FWkbw15yzTen6E4AlbmlIsO27OE0zr+R" + |
| "EX9r3ihX+O7Dw/6pyNv+cRj+ERauuUXqR3tX29u/w1WMY1Xhua" + |
| "o13z1XDKlqYUy45bz1NM6/kRgidtaUqx7Lg5TzKt50fMz36PXQ" + |
| "1FpDzH1Vqe42qEh77Sa1XPOWpejqVHPYZHqa1TepHe1cf3mMfw" + |
| "GLV1Si/Su7wv1qGYvhoLDewUmrzjerHB42jPCF8bZXvac9woz0" + |
| "fV9DBNlb6ex4/y/edM47ugmeK7oJneen4zP2/+S0MxPQikBoJR" + |
| "Z++3rIeaPG9mR/UzDekOQDDqfj1wmdM55t6eo71se8ZFGopMai" + |
| "AYdem1qudxUXhGQ47anNRAMOrSa1XPJX6lIZWc1EAw6tJrVc8l" + |
| "ntKQSk5qIBh16bWq5xLPakglJzUQjLr0WtXz8Ox8nJOr/2goMq" + |
| "mBYNSl16qeQ+Xj6hNYAqkNzdGuNauNK/KGuIGsxPz954bSb4jv" + |
| "P8PTGopMaiAYdem1qudQF/ld0HdblQvb7zcO2+/dTRqKTGogGH" + |
| "Xptarn3U2x0pAt3Eu5vtdaru811lu/7jHMa1XPYxVe1JAtnJMa" + |
| "CEZdeq3qeXixe5eGrHlOaiAYdem1qufdu+JKDVnzXuoSmG4Dss" + |
| "doeumPK9OtpuoZ9Ne01XVvNZDa0BztWrOa58Vv+uviup6rgWS6" + |
| "bNZ8Nd6iocikBsJDXXqt6nm8JTypIXstJzUQjLr0WtVziT9rSC" + |
| "UnNRCMuvRa1XOoxnnpjngHWYlkunS/RTpXr79cQ5FJDYSHuvRa" + |
| "1fO4vDqrIWfps3JvUyM1EIw6e79nPdTkPiQ7JrZodDqDEIy6X6" + |
| "/Zn9jS/g2FiV9JwNJD/jcUWavhv6Es1pCtsTg9CKQGglFn7w+t" + |
| "h1q63hwj3X/ONu4/Z4v7z9ne/eePzuc76tGu7+43lDMagxGMul" + |
| "+v2Udnzvv5o8M0VfrJRV7jht7bzMv23KExGMGo+/WafYmHNaSW" + |
| "kxoIRl16rer76Mx5H7LtPJ8WsD13/k+/E7hcQ1E+m5d7DQSjzt" + |
| "6fWw81+Wxmx0jPsL84v/0+L8fS3zQU0y+B1EAw6uwdtx5qcq7L" + |
| "jomtGnJOHYBg1P16zf7E1kvlsznSeenYME2V9lwa56XRfovMf9" + |
| "3JYbpqfUtYbdMYjGDU/XrNfrUtPKchd1A5qYFg1KXXqp5LtP5H" + |
| "kxl650FlE2f9/2patz2m/i/OUc4hk+f5eX9VQ5FJDQSjLr1W9b" + |
| "x6NV6mIWfCy9I0kBoIRp2949bzPkT1dw15l5zUQDDq0mtVz6Hm" + |
| "Oj4ndg27+rS7/7fP0ePDdLM74pwnhumq9ctNtVNjMIJR9+s1+x" + |
| "Jva0jt7XQcSA0Eo87eceuhJtej7LhUzp/xCg1FJjUQjLr0WtXz" + |
| "eEX1moZsmddke9ZIDQSjzt5x66Em2zM74gINeZec1EAw6tJrVc" + |
| "/jguoNDXnHN+TZsEZqIBh19v7aeqjJemZHXKIh77IkHQdSA8Go" + |
| "s3fceqjJfZ1zjPA5Oj5MN7tS+beGIpMaCEZdeq3qOdTFfT+ffn" + |
| "sh55A53L9rfVNxpYai7KMrvQaCUWfvuPVQk32UHdXrGrI1clID" + |
| "wahLr1U9r16PV2nIO14lzwg1UgPBqLP399ZDTdYzO+bj/jNeo6" + |
| "HIpAaCUZdeq3oer6m2a8jWGIBg1P16zX61/ZI5Jy/UUGRSA8Go" + |
| "S69VPY8L5+U5bpfGYASj7tdr9qtdIz2/Pzn0837mQs4h6emh7q" + |
| "da5883NRTlGvem10Aw6uwdtx5qcu3Ijkvm+LxaQ1HOn1d7DQSj" + |
| "zt5x66Em56XsqP6hIVsmJzUQjLr0WtVzqDn3+3Odi3615nz+/M" + |
| "bHd2goMqmBYNSl16qei/ovhcx2uA=="); |
| |
| byte[] buffer = new byte[uncompressedBytes]; |
| Inflater inflater = new Inflater(); |
| inflater.setInput(decoded, 0, compressedBytes); |
| inflater.inflate(buffer); |
| inflater.end(); |
| |
| value = new int[rows][cols]; |
| for (int index = 0; index < uncompressedBytes-1; index += 4) |
| { |
| int byte1 = 0x000000FF & (int)buffer[index + 0]; |
| int byte2 = 0x000000FF & (int)buffer[index + 1]; |
| int byte3 = 0x000000FF & (int)buffer[index + 2]; |
| int byte4 = 0x000000FF & (int)buffer[index + 3]; |
| |
| int element = index / 4; |
| int row = element / cols; |
| int col = element % cols; |
| value[row][col] = byte1 << 24 | byte2 << 16 | byte3 << 8 | byte4; |
| } |
| } |
| catch (Exception e) |
| { |
| throw new Error(e); |
| } |
| } |
| |
| protected static int lookupValue(int row, int col) |
| { |
| return value[row][col]; |
| } |
| |
| static |
| { |
| sigmapInit(); |
| valueInit(); |
| } |
| } |
| |
| /** |
| * The GOTO table. |
| * <p> |
| * The GOTO table maps a state and a nonterminal to a new state. |
| * It is used when the parser reduces. Suppose, for example, the parser |
| * is reducing by the production <code>A ::= B C D</code>. Then it |
| * will pop three symbols from the <code>stateStack</code> and three symbols |
| * from the <code>valueStack</code>. It will look at the value now on top |
| * of the state stack (call it <i>n</i>), and look up the entry for |
| * <i>n</i> and <code>A</code> in the GOTO table to determine what state |
| * it should transition to. |
| */ |
| protected static final class GoToTable |
| { |
| /** |
| * Returns the state the parser should transition to if the given |
| * state is on top of the <code>stateStack</code> after popping |
| * symbols corresponding to the right-hand side of the given production. |
| * |
| * @return the state to transition to (0 <= result < Parser.NUM_STATES) |
| */ |
| protected static int getGoTo(int state, Nonterminal nonterminal) |
| { |
| assert 0 <= state && state < Parser.NUM_STATES; |
| assert nonterminal != null; |
| |
| return get(state, nonterminal.getIndex()); |
| } |
| |
| protected static final int[] rowmap = { 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 3, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 6, 0, 0, 0, 1, 0, 7, 8, 9, 2, 0, 0, 1, 0, 10, 0, 11, 0, 1, 12, 0, 2, 0, 0, 0, 0, 0, 13, 2, 0, 0, 0, 0, 0, 0, 0, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 16, 17, 0, 3, 4, 0, 0, 0, 18, 1, 19, 0, 0, 0, 20, 21, 22, 0, 3, 0, 23, 0, 3, 4, 4, 0, 0, 0, 0, 0, 0, 24, 0, 0, 1, 0, 0, 5, 25, 0, 2, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 26, 5, 0, 0, 0, 0, 6, 7, 27, 28, 0, 6, 29, 0, 30, 31, 0, 0, 7, 0, 32, 0, 8, 33, 34, 9, 35, 0, 36, 37, 8, 38, 0, 39, 9, 40, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 2, 42, 0, 0, 0, 10, 0, 43, 11, 12, 0, 10, 44, 45, 0, 0, 11, 46, 0, 12, 13, 13, 0, 47, 0, 14, 15, 14, 0, 15, 48, 0, 49, 0, 50, 51, 0, 52, 0, 0, 16, 17, 0, 16, 53, 0, 54, 0, 17, 0, 18, 19, 0, 0, 0 }; |
| protected static final int[] columnmap = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 7, 0, 0, 9, 0, 0, 0, 0, 0, 10, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 14, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 24, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 0, 0, 0, 0, 28, 0, 29, 0, 0, 9, 0, 0, 4, 0, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 35, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0 }; |
| |
| public static int get(int row, int col) |
| { |
| if (isErrorEntry(row, col)) |
| return -1; |
| else if (columnmap[col] % 2 == 0) |
| return lookupValue(rowmap[row], columnmap[col]/2) >>> 16; |
| else |
| return lookupValue(rowmap[row], columnmap[col]/2) & 0xFFFF; |
| } |
| |
| protected static boolean isErrorEntry(int row, int col) |
| { |
| final int INT_BITS = 32; |
| int sigmapRow = row; |
| |
| int sigmapCol = col / INT_BITS; |
| int bitNumberFromLeft = col % INT_BITS; |
| int sigmapMask = 0x1 << (INT_BITS - bitNumberFromLeft - 1); |
| |
| return (lookupSigmap(sigmapRow, sigmapCol) & sigmapMask) == 0; |
| } |
| |
| protected static int[][] sigmap = null; |
| |
| protected static void sigmapInit() |
| { |
| try |
| { |
| final int rows = 231; |
| final int cols = 16; |
| final int compressedBytes = 453; |
| final int uncompressedBytes = 14785; |
| |
| byte[] decoded = new byte[compressedBytes]; |
| base64Decode(decoded, |
| "eNrtW0uOwyAMNRELNKss5gD0Jj5a1BPMkUd0fkSTtPxsA/FbRI" + |
| "0qGvDnPRtSC7ACWHDg4Qselu+PJlzwcWPuAJt9A4QfoP0dcQCz" + |
| "v0WYG8F+EWL7xVZy+zH+cW1o/4VmdR4U556P/be88J9Dl5Y/tT" + |
| "CSNtlmsb8r/jIT9fy4aipW8vdfNBzET4jpwL8APPnLTAH79R/p" + |
| "V8jp3fqBev2uI1siYeT90//3VP2/xb9SSBg19ceNzX5elPOI83" + |
| "xN4Z87Ef9k+l+I/879nzd/hxLz1/qZV7/b65cs/yi6iJ8n/PeE" + |
| "v5PGK3T/oEb/0/gPWOv3lvw5L/8m+r+g/nJZs+g7fhi8UN4/fa" + |
| "T3b9i8fxu9frU05w+d9f/Yrf0VV4jfEphpfOST/ff6/IDPf25Y" + |
| "e29SJljgokDh51PXLwiKPuuXWv07GL+2P3/g0g8p/bc1IxucP4" + |
| "2r/7U5c+5/HKJ/qfV/Xv5iavxkvj9mmXiQhf+a51/P/MXxfE/I" + |
| "n4rp+vfp9I+++e97/3LM+mMk/pRbf239QKDfM+z/EdVfUvmPxO" + |
| "uXjv++6xcB/ujs/yd0/dfo8TM6/+r+ybX1f4T6jV7/Nf7E8Ali" + |
| "nnPW"); |
| |
| byte[] buffer = new byte[uncompressedBytes]; |
| Inflater inflater = new Inflater(); |
| inflater.setInput(decoded, 0, compressedBytes); |
| inflater.inflate(buffer); |
| inflater.end(); |
| |
| sigmap = new int[rows][cols]; |
| for (int index = 0; index < uncompressedBytes-1; index += 4) |
| { |
| int byte1 = 0x000000FF & (int)buffer[index + 0]; |
| int byte2 = 0x000000FF & (int)buffer[index + 1]; |
| int byte3 = 0x000000FF & (int)buffer[index + 2]; |
| int byte4 = 0x000000FF & (int)buffer[index + 3]; |
| |
| int element = index / 4; |
| int row = element / cols; |
| int col = element % cols; |
| sigmap[row][col] = byte1 << 24 | byte2 << 16 | byte3 << 8 | byte4; |
| } |
| } |
| catch (Exception e) |
| { |
| throw new Error(e); |
| } |
| } |
| |
| protected static int lookupSigmap(int row, int col) |
| { |
| return sigmap[row][col]; |
| } |
| |
| protected static int[][] value = null; |
| |
| protected static void valueInit() |
| { |
| try |
| { |
| final int rows = 55; |
| final int cols = 18; |
| final int compressedBytes = 589; |
| final int uncompressedBytes = 3961; |
| |
| byte[] decoded = new byte[compressedBytes]; |
| base64Decode(decoded, |
| "eNrNlM9rE0EUx7/BlthLsFBNDgkJJj1IJXhobCF402t6EFTwoG" + |
| "L9AQr+KLRU7Q+qGA9SKIV6LEUURKRFW7E99NBisNIigvjrpu3/" + |
| "kb7Mzu7O7s5sssnQNPA2M+zw2e/7vvcGYRQQRwZ9iCCGLJLIow" + |
| "MJHMMbXMA5hHAaLTiEE+jELRxBFGm04ygOoBUHkcIZtOEwbpfL" + |
| "KFBkKCIUWYo8RQK99OQcWlU4F3GvbP3QZa0YB2FaxQ0OYvRMUl" + |
| "T0rFU4FCEKQ89NDLn0HEfK5qCH5dXN8jppcqyv2ZxJjLg4OSXn" + |
| "lA9nCqNqDj9t5cV2bs5ZQw/bRyk4h1acY512cCo+ixzTZ5NDz/" + |
| "MGx/SZntxnXGJ5XbHzwlW3P7Ry5nXZ1oN+dvpaucrPzEv5XlX3" + |
| "97jh0rPg0XPd6Y/IMX3GF0+9SoY/uCPz2aPnLudsyjhOPTIO7j" + |
| "vzkvWhJ6+B6nXHN0/dS0LdB911V3J+qDkYrq0P8UDah779jIeK" + |
| "ev1T1itddS4eCXnt+PlD/4q58J1TpoftxmrSM+43p3yv0jNR23" + |
| "xVnb8wnlJeRT7vT+iefyybd35aPe/PdOmRz7vbZ6me5z5zGoQz" + |
| "LXIwY9/zATk5gfNiH/gzK7l/5tycgHVvRM9Lz1y80uUP7+fX+v" + |
| "PC22D949DzrkE9RbtemK+Hw98vCo592PM+XFL687EpffhJE2fZ" + |
| "4/OK5n5erduf9X1w/3zW5POGJs5XgbOlxx/+ne+a6/6z3rrz97" + |
| "+aWvffmur1R3lv/G3KvfFfE2db4OwCwEsTuA=="); |
| |
| byte[] buffer = new byte[uncompressedBytes]; |
| Inflater inflater = new Inflater(); |
| inflater.setInput(decoded, 0, compressedBytes); |
| inflater.inflate(buffer); |
| inflater.end(); |
| |
| value = new int[rows][cols]; |
| for (int index = 0; index < uncompressedBytes-1; index += 4) |
| { |
| int byte1 = 0x000000FF & (int)buffer[index + 0]; |
| int byte2 = 0x000000FF & (int)buffer[index + 1]; |
| int byte3 = 0x000000FF & (int)buffer[index + 2]; |
| int byte4 = 0x000000FF & (int)buffer[index + 3]; |
| |
| int element = index / 4; |
| int row = element / cols; |
| int col = element % cols; |
| value[row][col] = byte1 << 24 | byte2 << 16 | byte3 << 8 | byte4; |
| } |
| } |
| catch (Exception e) |
| { |
| throw new Error(e); |
| } |
| } |
| |
| protected static int lookupValue(int row, int col) |
| { |
| return value[row][col]; |
| } |
| |
| static |
| { |
| sigmapInit(); |
| valueInit(); |
| } |
| } |
| |
| /** |
| * The error recovery table. |
| * <p> |
| * See {@link #attemptToRecoverFromSyntaxError()} for a description of the |
| * error recovery algorithm. |
| * <p> |
| * This table takes the state on top of the stack and the current lookahead |
| * symbol and returns what action should be taken. The result value should |
| * be interpreted as follows: |
| * <ul> |
| * <li> If <code>result & ACTION_MASK == DISCARD_STATE_ACTION</code>, |
| * pop a symbol from the parser stacks; a "known" sequence |
| * of symbols has not been found. |
| * <li> If <code>result & ACTION_MASK == DISCARD_TERMINAL_ACTION</code>, |
| * a "known" sequence of symbols has been found, and we |
| * are looking for the error lookahead symbol. Shift the terminal. |
| * <li> If <code>result & ACTION_MASK == RECOVER_ACTION</code>, we have |
| * matched the error recovery production |
| * <code>Production.values[result & VALUE_MASK]</code>, so reduce |
| * by that production (including the lookahead symbol), and then |
| * continue with normal parsing. |
| * </ul> |
| * If it is not possible to recover from a syntax error, either the state |
| * stack will be emptied or the end of input will be reached before a |
| * RECOVER_ACTION is found. |
| * |
| * @return a code for the action to take (see above) |
| */ |
| protected static final class RecoveryTable |
| { |
| protected static int getRecoveryCode(int state, org.eclipse.photran.internal.core.lexer.Token lookahead) |
| { |
| assert 0 <= state && state < Parser.NUM_STATES; |
| assert lookahead != null; |
| |
| Integer index = Parser.terminalIndices.get(lookahead.getTerminal()); |
| if (index == null) |
| return 0; |
| else |
| return get(state, index); |
| } |
| |
| protected static final int[] rowmap = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; |
| protected static final int[] columnmap = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; |
| |
| public static int get(int row, int col) |
| { |
| if (isErrorEntry(row, col)) |
| return 0; |
| else if (columnmap[col] % 2 == 0) |
| return lookupValue(rowmap[row], columnmap[col]/2) >>> 16; |
| else |
| return lookupValue(rowmap[row], columnmap[col]/2) & 0xFFFF; |
| } |
| |
| protected static boolean isErrorEntry(int row, int col) |
| { |
| final int INT_BITS = 32; |
| int sigmapRow = row; |
| |
| int sigmapCol = col / INT_BITS; |
| int bitNumberFromLeft = col % INT_BITS; |
| int sigmapMask = 0x1 << (INT_BITS - bitNumberFromLeft - 1); |
| |
| return (lookupSigmap(sigmapRow, sigmapCol) & sigmapMask) == 0; |
| } |
| |
| protected static int[][] sigmap = null; |
| |
| protected static void sigmapInit() |
| { |
| try |
| { |
| final int rows = 231; |
| final int cols = 8; |
| final int compressedBytes = 30; |
| final int uncompressedBytes = 7393; |
| |
| byte[] decoded = new byte[compressedBytes]; |
| base64Decode(decoded, |
| "eNrtwQENAAAAwqD3T20ON6AAAAAAAAAATgwc4QAB"); |
| |
| byte[] buffer = new byte[uncompressedBytes]; |
| Inflater inflater = new Inflater(); |
| inflater.setInput(decoded, 0, compressedBytes); |
| inflater.inflate(buffer); |
| inflater.end(); |
| |
| sigmap = new int[rows][cols]; |
| for (int index = 0; index < uncompressedBytes-1; index += 4) |
| { |
| int byte1 = 0x000000FF & (int)buffer[index + 0]; |
| int byte2 = 0x000000FF & (int)buffer[index + 1]; |
| int byte3 = 0x000000FF & (int)buffer[index + 2]; |
| int byte4 = 0x000000FF & (int)buffer[index + 3]; |
| |
| int element = index / 4; |
| int row = element / cols; |
| int col = element % cols; |
| sigmap[row][col] = byte1 << 24 | byte2 << 16 | byte3 << 8 | byte4; |
| } |
| } |
| catch (Exception e) |
| { |
| throw new Error(e); |
| } |
| } |
| |
| protected static int lookupSigmap(int row, int col) |
| { |
| return sigmap[row][col]; |
| } |
| |
| protected static int[][] value = null; |
| |
| protected static void valueInit() |
| { |
| try |
| { |
| final int rows = 1; |
| final int cols = 1; |
| final int compressedBytes = 7; |
| final int uncompressedBytes = 5; |
| |
| byte[] decoded = new byte[compressedBytes]; |
| base64Decode(decoded, |
| "eNpjYAACAA=="); |
| |
| byte[] buffer = new byte[uncompressedBytes]; |
| Inflater inflater = new Inflater(); |
| inflater.setInput(decoded, 0, compressedBytes); |
| inflater.inflate(buffer); |
| inflater.end(); |
| |
| value = new int[rows][cols]; |
| for (int index = 0; index < uncompressedBytes-1; index += 4) |
| { |
| int byte1 = 0x000000FF & (int)buffer[index + 0]; |
| int byte2 = 0x000000FF & (int)buffer[index + 1]; |
| int byte3 = 0x000000FF & (int)buffer[index + 2]; |
| int byte4 = 0x000000FF & (int)buffer[index + 3]; |
| |
| int element = index / 4; |
| int row = element / cols; |
| int col = element % cols; |
| value[row][col] = byte1 << 24 | byte2 << 16 | byte3 << 8 | byte4; |
| } |
| } |
| catch (Exception e) |
| { |
| throw new Error(e); |
| } |
| } |
| |
| protected static int lookupValue(int row, int col) |
| { |
| return value[row][col]; |
| } |
| |
| static |
| { |
| sigmapInit(); |
| valueInit(); |
| } |
| } |
| |
| } |
