C++ TokenStream::Consume方法代码示例

/**
 * @return true if the token stream in its present state can convert
 * the token stream to a case expression.
 *
 * @param parser   -- Parser that is used to parse out whole elements.
 * @param stream   -- The token stream.
 * @param elements -- The element output, first element is the condition, every 
 *                    other element should be case element containers, and the
 *                    last element could be a default element. 
 * @return true if the stream of tokens can be accepted, false otherwise.
 */ 
bool Case_::CanAccept_( Parser const& parser
                      , TokenStream& stream 
                      , std::vector<strine::Element>& elements
                      ) const
{
    bool can_accept =  MatchToken_(stream, "(") 
                    && MatchToken_(stream, "case");  
    
    if (can_accept && stream.HasTokens())
    {
        Element current_element;
        can_accept =parser.ParseAny(stream, current_element);
        elements.push_back(current_element);
    }
    else
    {
        can_accept = false;
    }

    while(can_accept && stream.HasTokens())
    {
        stream.Push();
 
        bool isEnd = MatchToken_(stream, ")");
        if (isEnd)
        {
            stream.Consume();
            break;
        }

        // Reset the stream, attempt to parse a list.
        stream.Rollback(); 

        // Right now I'm not sure what symbol to use for an "ANY"- needs to 
        // be something self-explanatory.
        bool isAlmostEnd = MatchToken_(stream, "->");
        if (isAlmostEnd)
        {
            stream.Consume();
            assert(0);
            break;
        }

        stream.Rollback();
       
        // Typically we'll have a condition.
        can_accept =  (MatchToken_(stream, "["))
                   && CanAcceptListRemainder_(parser, stream, elements); 
    }

    return can_accept;
}

/**
 * Parse out the token stream.
 *
 * @param parser   Not used.
 * @param in       The input token stream.
 * @param elements The elements.
 * @return the element that was parsed.
 */
Element Function_::Parse_( Parser const& /* parser */
                         , TokenStream& in
                         , std::vector<Element> const& elements) const
{
    in.Consume();

    std::shared_ptr<Function_> f(new Function_()); 

    size_t const NUMBER_OF_ARGS = (elements.empty()) ? 0 : elements.size() - 1; 

    std::vector<Variable> parms;
    bool isAVariable  = false;
    for(size_t i=0; i<NUMBER_OF_ARGS; ++i)
    {
        Variable v = CastToVariable(elements[i], isAVariable);
        if (isAVariable)
        {
            parms.push_back(v);
        }
    }
    f->SetArguments(parms);
    
    if (false == elements.empty())
    {
        f->SetBody( elements[elements.size() - 1] );
    }
    else
    {
        f->SetBody(Nil());
    }

    return Function(f, SourceLocation());
}

/**
 * Parse out the token stream.
 *
 * @param in -- The input token stream.
 * @return the element that was parsed.
 */
Element Error_::Parse_( Parser const& 
                      , TokenStream& in
                      , std::vector<strine::Element> const& elements) const
{
    in.Consume();

    std::shared_ptr<Error_> s(new Error_());

    std::shared_ptr<String_ > str = std::dynamic_pointer_cast<String_>(elements[0].ElementHandle());

    if (0 != str)
    {
        s->SetIdentifier(str->Value());
    }

    if (elements.size() >= 3)
    {
        std::shared_ptr<Number_ > number = std::dynamic_pointer_cast<Number_>(elements[1].ElementHandle());
        if (0 != number)
        {
            s->SetRow(number->IntValue());
        }

        number = std::dynamic_pointer_cast<Number_>(elements[2].ElementHandle());
        if (0 != number)
        {
            s->SetColumn(number->IntValue());
        }
    }

    return Error(s, SourceLocation());
}

/**
 * Parse out the token stream.
 *
 * @param in -- The input token stream.
 * @return the element that was parsed.
 */
Element Case_::Parse_( Parser const& 
                     , TokenStream& in
                     , std::vector<strine::Element> const& elements) const
{
    in.Consume();

    Case_* s = new Case_();
    s->SetCondition(elements[0]);

    size_t const ELEMENTS_SIZE = elements.size();
    for(size_t i=1; i<ELEMENTS_SIZE; i += 2)
    {
        size_t nextIndex = i + 1;
        
        // Check to see if you have a fallthrough case.
        if (nextIndex >= ELEMENTS_SIZE)
        {
            s->SetFallthrough(elements[i]);
        }

        // Just a regular ol' element pairing.
        else
        {
             s->Add(elements[i], elements[nextIndex]);
        }

    }

    return Case(s, SourceLocation());
}

/**
 * Parse out the token stream.
 *
 * @param in -- The input token stream.
 * @return the element that was parsed.
 */
Element Quoted_::Parse_( Parser const& 
                       , TokenStream& in
                       , std::vector<Element> const& elements) const
{
    in.Consume();
    Quoted quoted;
    quoted.SetElement(elements[0]); 
    return quoted;
}

/**
 * Parse out the token stream.
 *
 * @param in -- The input token stream.
 * @return the element that was parsed.
 */
Element Evaluate_::Parse_( Parser const& 
                         , TokenStream& in
                         , std::vector<strine::Element> const& elements) const
{
    in.Consume();

    std::shared_ptr<Evaluate_> s (new Evaluate_(this->strine));
    s->SetElement(elements[0]);

    return Evaluate(s, SourceLocation());
}

/**
 * Parse out the token stream.
 *
 * @param in -- The input token stream.
 * @return the element that was parsed.
 */
Element Set_::Parse_( Parser const&
                      , TokenStream& in
                      , std::vector<strine::Element> const& elements) const
{
    in.Consume();

    Set_* s = new Set_();
    s->SetIdentifier(elements[0].ToString());
    s->SetElement(elements[1]);

    return Set(s, SourceLocation());
}

/**
 * Parse out the token stream.
 *
 * @param in -- The input token stream.
 * @return the element that was parsed.
 */
Element If_::Parse_( Parser const& 
                   , TokenStream& in
                   , std::vector<Element> const& elements) const
{
    in.Consume();

    std::shared_ptr<If_> s ( new If_() );
    s->SetCondition(elements[0]);
    s->SetTrue(elements[1]);
    s->SetFalse(elements[2]);

    return If(s, SourceLocation());
}

/**
 * Parse out the token stream.
 *
 * @param in -- The input token stream.
 * @return the element that was parsed.
 */
Element Builtin_::Parse_(  Parser const& 
                         , TokenStream& in
                         , std::vector<Element> const& elements) const
{
    in.Consume();

    std::shared_ptr<String_> s = std::dynamic_pointer_cast<String_>(elements[0].ElementHandle());

    Element element;
    std::shared_ptr<Builtin_> b(new Builtin_(this->table)); 

    if (0 != s)
    {
        b->SetName( s->Value() );
    }

    if (elements.size() > 1)
    {
        b->SetAdditionalParameter(elements[1]);
    }

    return Builtin(b, SourceLocation());
}

/**
 * @return true if the token stream in its present state can convert
 * the token stream to a set expression.
 *
 * @param in -- The token stream.
 * @return true if the stream of tokens can be accepted, false otherwise.
 */ 
bool Function_::CanAccept_( Parser const& parser
                     , TokenStream& stream 
                     , std::vector<strine::Element>& elements) const
{
    bool can_accept = false;

    // (
    if (stream.HasTokens())
    {
        Element current_element = stream.NextToken();
        can_accept =  (current_element.Type() == Types::TOKEN)
                   && (current_element.ToString() == "("); 
    }

    // function
    if (can_accept && stream.HasTokens())
    {
        Element current_element = stream.NextToken();
        can_accept =  (current_element.Type() == Types::TOKEN)
                   && (current_element.ToString() == "function"); 

    }

    // (
    if (can_accept && stream.HasTokens())
    {
        Element current_element = stream.NextToken();
        can_accept =  (current_element.Type() == Types::TOKEN)
                   && (current_element.ToString() == "("); 

    }

    // args
    while(can_accept && stream.HasTokens())
    {
        strine::Element current_element = stream.NextToken();
        
        if (current_element.Type() == Types::TOKEN)         
        {
            if (current_element.ToString() == ")")
            {
                break;
            }
            else
            {
                can_accept = false;
            }
        }
        else if (current_element.Type() == Types::VARIABLE)
        {
            elements.push_back(current_element); 
        }
        else
        {
            can_accept = false;
        }
    }

    if (can_accept)
    {
        stream.Push();
        strine::Element new_body;
        can_accept = parser.ParseAny(stream, new_body);

        if (can_accept && stream.HasTokens())
        {
            stream.Consume();
            Element current_element = stream.NextToken();
            can_accept =  (current_element.Type() == Types::TOKEN)
                       && (current_element.ToString() == ")"); 

            elements.push_back(new_body);
        }
        else
        {
            stream.Rollback();
            can_accept = false;
        }
    }

    return can_accept;
}

/**
 * @return true if the token stream in its present state can convert
 * the token stream to a builtin expression.
 *
 * @param in -- The token stream.
 * @return true if the stream of tokens can be accepted, false otherwise.
 */ 
bool Builtin_::CanAccept_( Parser const& parser
                         , TokenStream& stream 
                         , std::vector<Element>& elements) const
{
    bool can_accept = false;

    // (
    if (stream.HasTokens())
    {
        Element current_element = stream.NextToken();
        can_accept =  (current_element.Type() == Types::TOKEN) 
                   && (current_element.ToString() == "("); 
    }
    can_accept = can_accept && stream.HasTokens();

    // builtin
    if (can_accept)
    {
        Element current_element = stream.NextToken();
        can_accept =  (current_element.Type() == Types::TOKEN)
                   && (current_element.ToString() == "builtin"); 
    }
    can_accept = can_accept && stream.HasTokens();

    // Symbol
    if (can_accept)
    {
        Element current_element = stream.NextToken();
        can_accept =  (current_element.Type() == Types::STRING);
        elements.push_back(current_element);
    }
    can_accept = can_accept && stream.HasTokens();

    // 
    if (can_accept)
    {
        if (ParseEnd_(stream))
        {
            stream.NextToken();
        }
        else
        {
            Element current_element;
            stream.Push();
            can_accept = parser.ParseAny( stream, current_element );
            
            if (false == can_accept)
            {
                stream.Rollback();
            } 
            else
            {
                elements.push_back(current_element);
                stream.Consume();
            }

            can_accept = ParseEnd_(stream);
            if (can_accept)
            {
                stream.NextToken();
            }
        }
    }

    return can_accept;
}