source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Parser/Parser.cs @ 14323

using System.Collections.Generic;
using System.Globalization;
using HeuristicLab.Algorithms.PushGP.Expressions;

namespace HeuristicLab.Algorithms.PushGP
{
    public class Parser
    {
        private readonly CultureInfo cultureInfo = CultureInfo.CreateSpecificCulture("en-US");

        private const string OpenBrace = "(";
        private const string CloseBrace = ")";
        private readonly char[] symbolTrim = new[] { '\r', '\n' };

        public Expression Parse(string source, int startIndex = 0)
        {
            var symbols = source.Split(' ');

            int endIndex;
            return this.Parse(symbols, 0, out endIndex);
        }

        private Expression Parse(string[] symbols, int startIndex, out int endIndex)
        {
            var expressions = new List<Expression>();

            for (var i = startIndex; i < symbols.Length; i++)
            {
                var symbol = symbols[i].TrimEnd(symbolTrim);
                if (string.IsNullOrWhiteSpace(symbol))
                {
                    continue;
                }

                if (symbol == OpenBrace)
                {
                    var subExpression = Parse(symbols, i + 1, out endIndex);
                    expressions.Insert(0, subExpression);
                    i = endIndex;
                    continue;
                }
                else if (symbol == CloseBrace)
                {
                    endIndex = i;
                    return expressions.Count != 0
                        ? new ExecExpandExpression(expressions.ToArray())
                        : new CodeNoopExpression() as Expression;
                }

                if (string.IsNullOrWhiteSpace(symbol))
                {
                    continue;
                }

                // literal
                Expression expression;
                if (TryParseLiteral(symbol, out expression))
                {
                    expressions.Insert(0, expression);
                    continue;
                }

                // instruction
                OpCode opCode;
                if (SymbolTable.TryGetOpCode(symbol, out opCode))
                {
                    expression = ExpressionCreatorTable.GetCreator(opCode).Invoke();
                    expressions.Insert(0, expression);
                    continue;
                }

                // identifier - custom instruction or named literals
                expressions.Insert(0, new NameDefineXExecExpression(symbol));
            }

            endIndex = symbols.Length - 1;
            return expressions.Count == 1
                ? expressions[0]
                : new ExecExpandExpression(expressions.ToArray());
        }

        private bool TryParseLiteral(string word, out Expression expression)
        {
            long longValue;
            if (long.TryParse(word, out longValue))
            {
                expression = new IntegerPushExpression(longValue);
                return true;
            }

            double floatValue;
            if (double.TryParse(word, NumberStyles.Float, cultureInfo, out floatValue))
            {
                expression = new FloatPushExpression(floatValue);
                return true;
            }

            bool booleanValue;
            if (bool.TryParse(word, out booleanValue))
            {
                expression = new BooleanPushExpression(booleanValue);
                return true;
            }

            expression = null;
            return false;
        }
    }
}