Example #1
0
        /// <summary>
        ///     Applies a <see cref="Negative" /> operation to the <paramref name="node" />.
        /// </summary>
        /// <param name="node">The <paramref name="node" />.</param>
        /// <returns><see cref="object" />.</returns>
        /// <exception cref="Exception"></exception>
        internal static object Negative(Nodes.Monadic node)
        {
            try
            {
                try
                {
                    if (node.LHS.EvaluatedType == typeof(string))
                    {
                        var chars = ((string)node.LHS.EvaluatedValue).ToCharArray();
                        Array.Reverse(chars);
                        return(chars.ToString());
                    }

                    return(Convert.ToDouble(node.LHS.EvaluatedValue) * -1);
                }
                catch
                {
                    return(Convert.ToDouble(node.LHS.EvaluatedValue) * -1);
                }
            }
            catch (Exception e)
            {
                throw new Exception("Negative operation exception: " + e);
            }
        }
Example #2
0
 /// <summary>
 ///     Applies a <see cref="BitwiseNot" /> operation to the <paramref name="node" />.
 /// </summary>
 /// <param name="node">The <paramref name="node" />.</param>
 /// <returns><see cref="object" />.</returns>
 /// <exception cref="Exception"></exception>
 internal static object BitwiseNot(Nodes.Monadic node)
 {
     try
     {
         return(~Convert.ToInt64(node.LHS.EvaluatedValue));
     }
     catch (Exception e)
     {
         throw new Exception("Bitwise NOT operation exception: " + e);
     }
 }
Example #3
0
        /// <summary>
        ///     Applies a <see cref="Not" /> operation to the <paramref name="node" />.
        /// </summary>
        /// <param name="node">The <paramref name="node" />.</param>
        /// <returns>
        ///     <c>
        ///         <see langword="true" />
        ///     </c>
        ///     if the operation is successful,
        ///     <c>
        ///         <see langword="false" />
        ///     </c>
        ///     otherwise.
        /// </returns>
        /// <exception cref="Exception">
        /// </exception>
        internal static bool Not(Nodes.Monadic node)
        {
            try
            {
                if (node.LHS.EvaluatedType == typeof(bool))
                {
                    return(!(bool)node.LHS.EvaluatedValue);
                }

                throw new Exception();
            }
            catch (Exception e)
            {
                throw new Exception("NOT operation exception: " + e);
            }
        }
        /// <summary>
        ///     <see cref="UnaryExprn" />:= {"(" <see cref="Exprn" /> ")" |
        ///     <see cref="BaseExprn" /> | "!" <see cref="UnaryExprn" /> | "+"
        ///     <see cref="UnaryExprn" /> | "-" <see cref="UnaryExprn" /> | "~"
        ///     <see cref="UnaryExprn" /> }; NOTE: This function is purposefully
        ///     different from the layout of the other production functions.
        /// </summary>
        /// <returns>
        ///     <see cref="Nodes" />.<see cref="Nodes.Node" />. Monadic
        /// </returns>
        private static Nodes.Node UnaryExprn()
        {
            if (CurrentToken.TokenValue == '(')
            {
                //Consume the left bracket
                ConsumeToken();
                //Spins off everything inside the brackets as a new expression to evaluate
                var lhs = Exprn();
                //Consume the right bracket
                if (CurrentToken.TokenValue != ')')
                {
                    return(AddNode(new Nodes.Error("Matching closing bracket not found")));
                }

                ConsumeToken();
                return(lhs);
                //Throw error if right bracket not found
            }

            if ((CurrentToken != null) && (CurrentToken.TokenType == Token.TokenTypes.Unary))
            {
                //Create a new monadic node for the Unary operation and consume the token
                var monadic = new Nodes.Monadic(null, CurrentToken);
                ConsumeToken();

                //Set left hand side
                var mlhs = BaseExprn();
                if (mlhs == null)
                {
                    return(new Nodes.Error("Value LHS could not be evaluated"));
                }

                //If analysis successful, add to the monadic and return the monadic (will be added later)
                monadic.LHS = mlhs;
                return(monadic);
            }

            //Create a new node, attempt to find a last-resort base expression
            var node = BaseExprn();

            return(node == null ? new Nodes.Error("Could not find base expression") : AddNode(node));
        }
        /// <summary>
        ///     <see cref="AsmExprn" /> := {"*"}[":"Instruction] {[<see cref="Exprn" />
        ///     |<see cref="AsmExprn" />]|"?"};
        /// </summary>
        /// <returns><see cref="Nodes" />.<see cref="Nodes.Node" />.</returns>
        private static Nodes.Node AsmExprn()
        {
            //Stringbuilder for storing our ASM expression whilst we parse it
            var sb = new StringBuilder();

            //Consumes the token
            sb.Append(CurrentToken.TokenValue);
            ConsumeToken();

            //Get all idents
            if (CurrentToken.TokenType == Token.TokenTypes.Instruction)
            {
                //If ident found, consume it
                sb.Append(CurrentToken.TokenValue);
                ConsumeToken();
            }

            //Check for a GET command
            if (CurrentToken.TokenValue.ToString() == "?")
            {
                //Consume GET command token
                sb.Append(CurrentToken.TokenValue);
                ConsumeToken();

                //Return error if EOL not found
                if (CurrentToken.TokenType != Token.TokenTypes.Eol)
                {
                    return(Error("Could not find end of line token"));
                }

                //Consume EOL token if found
                sb.Append(CurrentToken.TokenValue);
                ConsumeToken();

                //Create our node and return
                return(AddNode(new Nodes.Node(new Token {
                    TokenValue = sb.ToString()
                })
                {
                    Value = sb.ToString(),
                    Token = { TokenValue = sb.ToString() }
                }));
            }

            //Try to analyse the left hand side
            var lhs = Exprn();

            if (lhs == null)
            {
                return(new Nodes.Error("LHS could not be evaluated"));
            }

            //Add left hand side to a new monadic - WHY?!?!
            var monadic = new Nodes.Monadic(lhs, new Token
            {
                TokenType  = Token.TokenTypes.None,
                TokenValue = sb.ToString()
            });

            //Check for EOL Token and consume
            if ((CurrentToken == null) || (CurrentToken?.TokenType != Token.TokenTypes.Eol))
            {
                return(Error("Could not find end of line token"));
            }

            ConsumeToken();

            return(AddNode(monadic));
        }