///////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////

using System;
using System.Collections;
using System.Text.RegularExpressions;

namespace Microsoft.Singularity.Applications
{
    /**
     * This is a general lr parser driver.
     * Parses the programming by first lexing it into a number
     * of tokens for a token stack. Then parser then pops tokens off
     * this stack, consults the parse tables and push the corresponding
     * nonterminals and states on the operand stack. This is the same
     * algorithm from the dragon book with some tweaks to support optional
     * tokens (i.e. newlines).
     **/
    abstract class Parser
    {
        private const int END_INPUT_MARKER_ID = 2;

        protected Action[,] actionTable = null;
        protected State[,] gotoTable = null;
        protected Production[] productionTable = null;
        protected TokenType[] tokenList = null;


        public class ParseException : Exception
        {
            public ParseException(Token token, String error)
                : base("Parse error on line " + token.lineNumber + ", char " + token.charIndex + ": " + error) { }
        }

        public Object parse(String input)
        {
            Stack leftStack = new Stack();
            leftStack.Push(new State(0));

            ArrayList list = Lex(ref input);
            list.Reverse(); //could return a stack out of lex instead
            Stack rightStack = new Stack(list);
            while (rightStack.Count != 0) {
                State st = (State)leftStack.Pop();
                Token tok = (Token)rightStack.Pop();
                Action action = actionTable[st.id, tok.id];
                while (tok.optional && action == null && rightStack.Count != 0) {
                    tok = (Token)rightStack.Pop();
                    action = actionTable[st.id, tok.id];
                }

                if (action == null) {
                    if (tok.id == END_INPUT_MARKER_ID) {
                        throw new ParseException(tok, " unexpected EOF");
                    }
                    throw new ParseException(tok, tok.value + " unexpected input");
                }

                if (action.type == ActionType.SHIFT) {
                    leftStack.Push(st);
                    leftStack.Push(tok);
                    leftStack.Push(new State(action.stateOrProduction));
                } else if (action.type == ActionType.REDUCE) {
                    Production production = productionTable[action.stateOrProduction];
                    Object value = production.reduction(leftStack);
                    StackElement topLeft = (StackElement)leftStack.Pop();
                    State previousState;
                    if (topLeft is State) {
                        previousState = (State)topLeft;
                    } else {
                        leftStack.Push(topLeft);
                        previousState = st; /* took an epsilon transition */
                    }
                    State nextState = gotoTable[previousState.id, production.nonterminalType];
                    if (nextState == null) throw new Exception("missing state");
                    leftStack.Push(previousState);
                    leftStack.Push(new Nonterminal(production.nonterminalType, value));
                    leftStack.Push(nextState);
                    rightStack.Push(tok);
                } else if (action.type == ActionType.ACCEPT) {
                    break;
                }
            }
            Nonterminal result = (Nonterminal)leftStack.Pop();
            return result.value;
        }

        private static int CountOccurrences(String input, char c, out int last)
        {
            int count = 0;
            last = -1;
            for (int i = 0; i < input.Length; ++i) {
                if (c == input[i]) {
                    ++count;
                    last = i;
                }
            }
            return count;
        }

        private static bool IsNewLine(char t) { return t == '\n'; }
        public ArrayList Lex(ref String input)
        {
            ArrayList tokens = new ArrayList();
            int lineNumber = 1;
            int charIndex = 1;
        outer:
            while (input.Length != 0) {
                foreach (TokenType spec in tokenList) {
                    Match match = spec.regex.Match(input);
                    if (match == null || !match.Success) continue;
                    input = input.Remove(0, match.Value.Length);
                    if (spec.lexer != null) {
                        Token token = new Token(spec.type, match.Value, lineNumber, charIndex);
                        spec.lexer(token);
                        if (token.value != null)
                            tokens.Add(token);
                    } else {
                        tokens.Add(new Token(spec.type, match.Value, lineNumber, charIndex));
                    }
                    int lastIndex;
                    int occurrences = CountOccurrences(match.Value, '\n', out lastIndex);
                    if (occurrences > 0) {
                        lineNumber += occurrences;
                        charIndex = match.Value.Length - (lastIndex + 1);
                    } else {
                        charIndex += match.Value.Length;
                    }
                    goto outer;
                }
                throw new Exception("unknown input: " + input);
            }
            tokens.Add(new Token(END_INPUT_MARKER_ID, null, lineNumber, charIndex));
            return tokens;
        }

        public delegate Object Reducer(Stack stack);
        public delegate void Lexer(Token tok);

        public class Production
        {
            public int nonterminalType;
            public Reducer reduction;
            public Production(int nonterminalType, Reducer reduction)
            {
                this.nonterminalType = nonterminalType;
                this.reduction = reduction;
            }
        }

        public class StackElement
        {
            public readonly int id;
            public Object value;
            public StackElement(int id) { this.id = id; }
            public override string ToString()
            {
                return id.ToString();
            }
        }
        public class State : StackElement
        {
            public State(int number) : base(number) { }

        }
        public class Token : StackElement
        {
            public readonly int lineNumber;
            public readonly int charIndex;
            public bool optional = false;
            public Token(int type, Object value, int lineNumber, int charIndex)
                : base(type)
            {
                this.value = value;
                this.lineNumber = lineNumber;
                this.charIndex = charIndex;
            }

            public override string ToString()
            {
                return value + ":" + id;
            }
        }
        private class Nonterminal : StackElement
        {
            public Nonterminal(int type, Object value) : base(type) { this.value = value; }
        }

        public enum ActionType { SHIFT, REDUCE, ACCEPT }
        public class Action
        {
            public ActionType type;
            public int stateOrProduction;
            public Action(ActionType type, int stateOrProduction)
            {
                this.type = type; this.stateOrProduction = stateOrProduction;
            }
            public override int GetHashCode()
            {
                return type.GetHashCode() ^ stateOrProduction.GetHashCode();
            }
            public override bool Equals(object obj)
            {
                if (!(obj is Action)) return false;
                Action that = obj as Action;
                return this.type == that.type && this.stateOrProduction == that.stateOrProduction;
            }

            public override string ToString()
            {
                return type + " " + stateOrProduction;
            }
        }

        protected class TokenType
        {
            public int type;
            public Regex regex;
            public Lexer lexer;
            public TokenType(int type, Regex regex, Lexer lexer)
            {
                this.type = type; this.regex = regex; this.lexer = lexer;
            }
        }
    }
}