C++ 自顶向下递归下降解析：依赖尾部调用优化

我正在构建一个递归下降解析器，我有两条规则来构建一个列表：

ValueList  -> TOKEN_IDENTIFER TOKEN_QUOTE ValueListP

ValueListP -> ValueList
           |  %EPSILON%

现在我知道，您可以通过循环轻松地将这两个规则优化为单个规则，但我也知道编译器可以并且将在它看到的地方执行尾部调用优化。这是我目前的代码：

void Parser::grammarValueList( std::deque<std::unique_ptr<ValueNode>>& arg1 )                                                                                                                                                                 
{                                                                                                                                                                                                                                             
    std::string var1 = m_currentToken.getValue().string;                                                                                                                                                                                  
    if( acceptToken( Token::Type::TOKEN_IDENTIFIER ) )                                                                                                                                                                                    
    {                                                                                                                                                                                                                                     
            std::string var2 = m_currentToken.getValue().string;                                                                                                                                                                          
            if( acceptToken( Token::Type::TOKEN_QUOTE ) )                                                                                                                                                                                 
            {                                                                                                                                                                                                                             
                    arg1.push_back( std::unique_ptr<ValueNode>( new ValueNode( var1, var2 ) ) );                                                                                                                                          
                    if( peekValueListP() )                                                                                                                                                                                                
                    {                                                                                                                                                                                                                     
                            return grammarValueListP( arg1 );                                                                                                                                                                             
                    }                                                                                                                                                                                                                     
            }                                                                                                                                                                                                                             
    }                                                                                                                                                                                                                                     

    throw ParseException( "Error: did not expect \"" + m_currentToken.toString() + "\"" );                                                                                                                                                
}

void Parser::grammarValueListP( std::deque<std::unique_ptr<ValueNode>>& arg1 )                                                                                                                                                                
{                                                                                                                                                                                                                                             
    if( peekValueList() )                                                                                                                                                                                                                 
    {                                                                                                                                                                                                                                     
            return grammarValueList( arg1 );                                                                                                                                                                                              
    }                                                                                                                                                                                                                                     
    else                                                                                                                                                                                                                                  
    {                                                                                                                                                                                                                                     
            return;                                                                                                                                                                                                                       
    }                                                                                                                                                                                                                                     

    throw ParseException( "Error: did not expect \"" + m_currentToken.toString() + "\"" );                                                                                                                                                
}

void解析器：：grammarValueList（std：：deque和arg1）
{                                                                                                                                                                                                                                             
std:：string var1=m_currentToken.getValue（）.string；
if（接受令牌（令牌：：类型：：令牌\标识符））
{                                                                                                                                                                                                                                     
std:：string var2=m_currentToken.getValue（）.string；
if（acceptToken（Token:：Type:：Token_QUOTE））
{                                                                                                                                                                                                                             
arg1.push_back（std:：unique_ptr（新的ValueNode（var1，var2））；
if（peekValueListP（））
{                                                                                                                                                                                                                     
返回grammarValueListP（arg1）；
}                                                                                                                                                                                                                     
}                                                                                                                                                                                                                             
}                                                                                                                                                                                                                                     
抛出ParseException（“错误：未预期\”“+m\U currentToken.toString（）+”\”）；
}
void解析器：：grammarValueListP（std：：deque和arg1）
{                                                                                                                                                                                                                                             
if（peekValueList（））
{                                                                                                                                                                                                                                     
返回语法值列表（arg1）；
}                                                                                                                                                                                                                                     
其他的
{                                                                                                                                                                                                                                     
返回；