protected void AssertTokenExist(Token token)
        {
            if (token == null)
            {
                var last = _stream.Last();

                // Next char position
                var start = last.Position.Start.ToTuple();
                var end   = last.Position.End.ToTuple();
                start.Item2 += 1;
                end.Item2   += 1;
                var prettyPos = new Position(start, end);

                throw SyntaxError.Make(SyntaxErrorMessages.UNEXPECTED_EOS(), prettyPos);
            }
        }
        private AssemblyOperation ParseAssemblyOperation()
        {
            var asterisk = NextToken(false);

            if (asterisk.IsOperator(Operator.Asterisk))
            {
                _stream.Next();
            }
            else
            {
                asterisk = null;
            }

            var reg = ParseRegister();

            var allowedOps = new HashSet <string>()
            {
                Operator.Assign,
                Operator.AssignPlus,
                Operator.AssignMinus,
                Operator.AssignShiftRight,
                Operator.AssignShiftLeft,
                Operator.AssignOr,
                Operator.AssignAnd,
                Operator.AssignXor,
                Operator.AssignLess,
                Operator.AssignGreater,
                Operator.AssignCond
            };
            var op = NextToken();

            if (op.Type != TokenType.Operator || !allowedOps.Contains(op.Value))
            {
                throw SyntaxError.Make(SyntaxErrorMessages.INVALID_TOKEN, op);
            }

            var node = new AssemblyOperation(op);

            if (asterisk != null)
            {
                var deref = new Dereference(asterisk);
                deref.AddChild(reg);

                node.AddChild(deref);
            }
            else
            {
                node.AddChild(reg);

                asterisk = NextToken(false);
                if (asterisk.IsOperator(Operator.Asterisk))
                {
                    _stream.Next();
                }
                else
                {
                    asterisk = null;
                }
            }

            // If we have two dereferences in the statement ParseRegister will fail
            reg = ParseRegister();

            if (asterisk != null)
            {
                var deref = new Dereference(asterisk);
                deref.AddChild(reg);

                node.AddChild(deref);
            }
            else
            {
                node.AddChild(reg);
            }

            if (!op.IsOperator(Operator.Assign) && asterisk != null)
            {
                throw SyntaxError.Make(SyntaxErrorMessages.INVALID_ASM_DEREFERENCE_USE(), node.Position);
            }

            return(node);
        }