Esempio n. 1
0
        /// <summary>
        ///     Read the specified parameter.
        /// </summary>
        /// <param name="parser">The parser to use.</param>
        /// <returns>The parsed parameter.</returns>
        private ParamTemplate ReadParam(SimpleParser parser)
        {
            var result = new ParamTemplate();

            if (!parser.LookAhead("{", true))
            {
                throw new EACompileError("Expected {");
            }
            parser.Advance();

            bool done   = false;
            var  buffer = new StringBuilder();

            while (!done)
            {
                if (parser.Peek() == '}')
                {
                    done = true;
                    parser.Advance();
                }
                else if (parser.Peek() == '{')
                {
                    throw new EACompileError("Unexpected {");
                }
                else if (parser.Peek() == '{')
                {
                    done = true;
                    parser.Advance();
                }
                else if (parser.Peek() == ',')
                {
                    result.AddType(buffer.ToString().Trim().ToLower());
                    parser.Advance();
                    buffer.Length = 0;
                }
                else
                {
                    buffer.Append(parser.ReadChar());
                }
            }

            String s = buffer.ToString().Trim();

            if (s.Length > 0)
            {
                result.AddType(s);
            }

            return(result);
        }
        /// <summary>
        ///     Read the specified parameter.
        /// </summary>
        /// <param name="parser">The parser to use.</param>
        /// <returns>The parsed parameter.</returns>
        private ParamTemplate ReadParam(SimpleParser parser)
        {
            var result = new ParamTemplate();

            if (!parser.LookAhead("{", true))
            {
                throw new EACompileError("Expected {");
            }
            parser.Advance();

            bool done = false;
            var buffer = new StringBuilder();

            while (!done)
            {
                if (parser.Peek() == '}')
                {
                    done = true;
                    parser.Advance();
                }
                else if (parser.Peek() == '{')
                {
                    throw new EACompileError("Unexpected {");
                }
                else if (parser.Peek() == '{')
                {
                    done = true;
                    parser.Advance();
                }
                else if (parser.Peek() == ',')
                {
                    result.AddType(buffer.ToString().Trim().ToLower());
                    parser.Advance();
                    buffer.Length = 0;
                }
                else
                {
                    buffer.Append(parser.ReadChar());
                }
            }

            String s = buffer.ToString().Trim();
            if (s.Length > 0)
            {
                result.AddType(s);
            }

            return result;
        }
Esempio n. 3
0
        /// <summary>
        ///     Construct a basic template object.
        /// </summary>
        /// <param name="thePrecedence">The precedence.</param>
        /// <param name="theSignature">The opcode signature.</param>
        /// <param name="theType">The opcode type.</param>
        /// <param name="isVariable">True, if this opcode is a variable.</param>
        /// <param name="theDataSize">The data size kept for this opcode.</param>
        /// <param name="theEvaluate">The evaluator delegate.</param>
        /// <param name="theIsPossibleReturnType">The return type delegate.</param>
        /// <param name="theRandomize">The randomizer delegate.</param>
        public BasicTemplate(int thePrecedence, String theSignature,
                             NodeType theType, bool isVariable,
                             int theDataSize,
                             DelEvaluate theEvaluate,
                             DelIsPossibleReturnType theIsPossibleReturnType,
                             DelRandomize theRandomize)
        {
            _precedence = thePrecedence;
            _signature  = theSignature;
            _varValue   = isVariable;
            _dataSize   = theDataSize;
            _nodeType   = theType;

            _delEvaluate             = theEvaluate;
            _delIsPossibleReturnType = theIsPossibleReturnType;
            _delRandomize            = theRandomize;

            if (theSignature.Trim().Equals("("))
            {
                // special case, we add a left-paren for the shunting yard alg.
                _name        = theSignature;
                _returnValue = null;
            }
            else
            {
                // non-special case, find the name of the function/operator
                var  parser = new SimpleParser(theSignature);
                bool pass   = false;

                parser.EatWhiteSpace();
                _name = parser.ReadToChars("(").Trim();
                parser.Advance();

                bool done = false;
                while (!done)
                {
                    if (parser.Peek() == ')')
                    {
                        parser.Advance();
                        done = true;
                    }
                    else if (parser.Peek() == ':')
                    {
                        parser.Advance();
                        pass = true;
                    }
                    else if (parser.Peek() == '{')
                    {
                        ParamTemplate temp = ReadParam(parser);
                        temp.PassThrough = pass;
                        pass             = false;
                        _param.Add(temp);
                    }
                    else
                    {
                        parser.Advance();
                        if (parser.EOL())
                        {
                            throw new EncogError("Invalid opcode template.");
                        }
                    }
                }

                // get the return type
                parser.EatWhiteSpace();
                if (!parser.LookAhead(":", true))
                {
                    throw new EACompileError("Return type not specified.");
                }
                parser.Advance();
                parser.EatWhiteSpace();
                _returnValue = ReadParam(parser);
            }
        }
        /// <summary>
        ///     Construct a basic template object.
        /// </summary>
        /// <param name="thePrecedence">The precedence.</param>
        /// <param name="theSignature">The opcode signature.</param>
        /// <param name="theType">The opcode type.</param>
        /// <param name="isVariable">True, if this opcode is a variable.</param>
        /// <param name="theDataSize">The data size kept for this opcode.</param>
        /// <param name="theEvaluate">The evaluator delegate.</param>
        /// <param name="theIsPossibleReturnType">The return type delegate.</param>
        /// <param name="theRandomize">The randomizer delegate.</param>
        public BasicTemplate(int thePrecedence, String theSignature,
                             NodeType theType, bool isVariable,
                             int theDataSize,
                             DelEvaluate theEvaluate,
                             DelIsPossibleReturnType theIsPossibleReturnType,
                             DelRandomize theRandomize)
        {
            _precedence = thePrecedence;
            _signature = theSignature;
            _varValue = isVariable;
            _dataSize = theDataSize;
            _nodeType = theType;

            _delEvaluate = theEvaluate;
            _delIsPossibleReturnType = theIsPossibleReturnType;
            _delRandomize = theRandomize;

            if (theSignature.Trim().Equals("("))
            {
                // special case, we add a left-paren for the shunting yard alg.
                _name = theSignature;
                _returnValue = null;
            }
            else
            {
                // non-special case, find the name of the function/operator
                var parser = new SimpleParser(theSignature);
                bool pass = false;

                parser.EatWhiteSpace();
                _name = parser.ReadToChars("(").Trim();
                parser.Advance();

                bool done = false;
                while (!done)
                {
                    if (parser.Peek() == ')')
                    {
                        parser.Advance();
                        done = true;
                    }
                    else if (parser.Peek() == ':')
                    {
                        parser.Advance();
                        pass = true;
                    }
                    else if (parser.Peek() == '{')
                    {
                        ParamTemplate temp = ReadParam(parser);
                        temp.PassThrough = pass;
                        pass = false;
                        _param.Add(temp);
                    }
                    else
                    {
                        parser.Advance();
                        if (parser.EOL())
                        {
                            throw new EncogError("Invalid opcode template.");
                        }
                    }
                }

                // get the return type
                parser.EatWhiteSpace();
                if (!parser.LookAhead(":", true))
                {
                    throw new EACompileError("Return type not specified.");
                }
                parser.Advance();
                parser.EatWhiteSpace();
                _returnValue = ReadParam(parser);
            }
        }