/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * This file is part of Beaver Parser Generator.                       *
 * Copyright (C) 2003,2004 Alexander Demenchuk <alder@softanvil.com>.  *
 * All rights reserved.                                                *
 * See the file "LICENSE" for the terms and conditions for copying,    *
 * distribution and modification of Beaver.                            *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

package beaver;

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.zip.InflaterInputStream;

/**
 * Parsing Tables
 */
public final class ParsingTables
{
	/** A table with all actions */
	private final short[] actions;

	/**
	 * A table containing the lookahead for each entry in "actions" table.
	 * Used to detect "collisions".
	 */
	final short[] lookaheads;

	/**
	 * For each state, the offset into "actions" table that is used to find action for a terminal
	 * that has been fetched from the scanner.
	 */
	final int[] actn_offsets;

	/**
	 * For each state, the offset into "actions" table that is used to find a next parser's state
	 * using a nonterminal that has been created by a reduced production.
	 */
	private final int[] goto_offsets;

	/** Default action for each state */
	private final short[] default_actions;

	/**
	 * A table with encoded production information.
	 * <p/>
	 * Each slot in this table is a "structure":
	 * <pre>
	 *   short lhs_symbol_id ; // Symbol on the left-hand side of the production
	 *   short rhs_length    ; // Number of right-hand side symbols in the production
	 * </pre>
	 * where lhs_symbol_id uses high 16 bit of this structure, and rhs_length - lower 16 bits
	 */
	final int[] rule_infos;

	/** ID of the "error" nonterminal */
	final short error_symbol_id;

	/** Indicates whether action tables were compressed. */
	final boolean compressed;
	
	/** Number of terminal symbols. */
	final int n_term;

	public ParsingTables(Class impl_class)
	{
		this(getSpecAsResourceStream(impl_class));
	}
	
	/**
	 * Ensures that parser tables are loaded.
	 *
	 * @param impl_class class of the instance of the Parser
	 */
	public ParsingTables(String spec)
	{
		this(new ByteArrayInputStream(decode(spec)));
	}
	
	private ParsingTables(InputStream in)
	{
		try
		{
			DataInputStream data = new DataInputStream(new InflaterInputStream(in));
			try
			{
				int len = data.readInt();
				actions = new short[len];
				for (int i = 0; i < len; i++)
				{
					actions[i] = data.readShort();
				}
				lookaheads = new short[len];
				for (int i = 0; i < len; i++)
				{
					lookaheads[i] = data.readShort();
				}
				
				len = data.readInt();
				actn_offsets = new int[len];
				for (int i = 0; i < len; i++)
				{
					actn_offsets[i] = data.readInt();
				}
				goto_offsets = new int[len];
				for (int i = 0; i < len; i++)
				{
					goto_offsets[i] = data.readInt();
				}
				
				len = data.readInt();
				compressed = len != 0;
				if (compressed)
				{
					default_actions = new short[len];
					for (int i = 0; i < len; i++)
					{
						default_actions[i] = data.readShort();
					}
				}
				else
				{
					default_actions = null;
				}
				
				int min_nt_id = Integer.MAX_VALUE;
				len = data.readInt();
				rule_infos = new int[len];
				for (int i = 0; i < len; i++)
				{
					rule_infos[i] = data.readInt();
					min_nt_id = Math.min(min_nt_id, rule_infos[i] >>> 16);
				}
				n_term = min_nt_id;
				
				error_symbol_id = data.readShort();
			}
			finally
			{
				data.close();
			}
		}
		catch (IOException e)
		{
			throw new IllegalStateException("cannot initialize parser tables: " + e.getMessage());
		}
	}
	
	/**
	 * Scans lookaheads expected in a given state for a terminal symbol.
	 * Used in error recovery when an unexpected terminal is replaced with one that is expected.
	 * 
	 * @param state in which error occured
	 * @return ID of the expected terminal symbol or -1 if there is none
	 */
	final short findFirstTerminal(int state)
	{
		int offset = actn_offsets[state];
		for (short term_id = offset < 0 ? (short) -offset : 0; term_id < n_term; term_id++)
		{
			int index = offset + term_id;
			if (index >= lookaheads.length)
				break;
			if (lookaheads[index] == term_id)
				return term_id;
		}
		return -1;
	}

	/**
	 * Find the appropriate action for a parser in a given state with a specified terminal look-ahead.
	 *
	 * @param state     of a parser
	 * @param lookahead
	 * @return parser action
	 */
	final short findParserAction(int state, short lookahead)
	{
		int index = actn_offsets[state];
		if (index != UNUSED_OFFSET)
		{
			index += lookahead;
			if (0 <= index && index < actions.length && lookaheads[index] == lookahead)
			{
				return actions[index];
			}
		}
		return compressed ? default_actions[state] : 0;
	}

	/**
	 * Find the appropriate action for a parser in a given state with a specified nonterminal look-ahead.
	 * In this case the only possible outcomes are either a state to shift to or an accept action.
	 *
	 * @param state     of a parser
	 * @param lookahead
	 * @return parser action
	 */
	final short findNextState(int state, short lookahead)
	{
		int index = goto_offsets[state];
		if (index != UNUSED_OFFSET)
		{
			index += lookahead;
			if (0 <= index && index < actions.length && lookaheads[index] == lookahead)
			{
				return actions[index];
			}
		}
		return compressed ? default_actions[state] : 0;
	}

	static final int UNUSED_OFFSET = Integer.MIN_VALUE;
	
	static byte[] decode(String spec)
	{
		char[] chars = spec.toCharArray();
		if (chars.length % 4 != 0)
			throw new IllegalArgumentException("corrupted encoding");
		int len = chars.length / 4 * 3;
		byte[] bytes = new byte[chars[chars.length - 1] == '=' ? chars[chars.length - 2] == '=' ? len - 2 : len - 1 : len];
		
		len -= 3;
		int ci = 0, bi = 0;
		while (bi < len)
		{
			int acc = decode(chars[ci++]) << 18 | decode(chars[ci++]) << 12 | decode(chars[ci++]) << 6 | decode(chars[ci++]);
			bytes[bi++] = (byte) (acc >> 16);
			bytes[bi++] = (byte) (acc >> 8 & 0xFF);
			bytes[bi++] = (byte) (acc & 0xFF);
		}
		int acc = decode(chars[ci++]) << 18 | decode(chars[ci++]) << 12 | decode(chars[ci++]) << 6 | decode(chars[ci++]);
		bytes[bi++] = (byte) (acc >> 16);
		if (bi < bytes.length)
		{
			bytes[bi++] = (byte) (acc >> 8 & 0xFF);
			if (bi < bytes.length)
			{
				bytes[bi++] = (byte) (acc & 0xFF);
			}
		}
		return bytes;
	}
	
	static int decode(char c)
	{
		if (c <= '9')
		{
			if (c >= '0')
				return c - '0';
			if (c == '#')
				return 62;
			if (c == '$')
				return 63;
		}
		else if (c <= 'Z')
		{
			if (c >= 'A')
				return c - 'A' + 10;
			if (c == '=')
				return 0;
		}
		else if ('a' <= c && c <= 'z')
			return c - 'a' + 36;
		throw new IllegalStateException("illegal encoding character '" + c + "'");
	}
	
	static InputStream getSpecAsResourceStream(Class impl_class)
	{
		String name = impl_class.getName();
		name = name.substring(name.lastIndexOf('.') + 1) + ".spec";
		InputStream spec_stream = impl_class.getResourceAsStream(name);
		if (spec_stream == null)
			throw new IllegalStateException("parser specification not found");
		return spec_stream;
	}
}

