barf_preprocessor_parser.trison

// 2006.10.15 - Copyright Victor Dods - Licensed under Apache 2.0

%targets cpp


%target.cpp.header_filename "barf_preprocessor_parser.hpp"
%target.cpp.implementation_filename "barf_preprocessor_parser.cpp"


%target.cpp.top_of_header_file %{
#if !defined(BARF_PREPROCESSOR_PARSER_HPP_)
#define BARF_PREPROCESSOR_PARSER_HPP_

#include "barf_preprocessor.hpp"

#include "barf_filoc.hpp"

namespace Barf {
namespace Ast {

class Base;

} // end of namespace Ast

namespace Preprocessor {

class Scanner;
%}
%target.cpp.class_name Parser
%target.cpp.bottom_of_class {
    FiLoc const &GetFiLoc () const;

    bool ScannerDebugSpewIsEnabled () const;
    std::ostream *ScannerDebugSpewStream ();
    void SetScannerDebugSpewStream (std::ostream *debug_spew_stream);

    bool OpenFile (string const &input_filename);
    void OpenString (string const &input_string, string const &input_name, bool use_line_numbers = false);
    void OpenUsingStream (istream *input_stream, string const &input_name, bool use_line_numbers);

private:

    Scanner *m_scanner;
}
%target.cpp.bottom_of_header_file %{
} // end of namespace Preprocessor
} // end of namespace Barf

#endif // !defined(BARF_PREPROCESSOR_PARSER_HPP_)
%}


%target.cpp.top_of_implementation_file %{
#include "barf_preprocessor_ast.hpp"
#include "barf_preprocessor_scanner.hpp"

namespace Barf {
namespace Preprocessor {
%}
%target.cpp.constructor_actions {
    m_scanner = new Scanner();
}
%target.cpp.destructor_actions {
    delete m_scanner;
    m_scanner = NULL;
}
%target.cpp.top_of_parse_method_actions %{
    EmitExecutionMessage("starting preprocessor parser");
%}
%target.cpp.bottom_of_parse_method_actions %{
    if (parse_return_code == PRC_SUCCESS)
        EmitExecutionMessage("preprocessor parse was successful");
%}
%target.cpp.bottom_of_implementation_file %{
FiLoc const &Parser::GetFiLoc () const
{
    assert(m_scanner != NULL);
    return m_scanner->GetFiLoc();
}

bool Parser::ScannerDebugSpewIsEnabled () const
{
    return m_scanner->DebugSpewIsEnabled();
}

std::ostream *Parser::ScannerDebugSpewStream ()
{
    return m_scanner->DebugSpewStream();
}

void Parser::SetScannerDebugSpewStream (std::ostream *debug_spew_stream)
{
    m_scanner->SetDebugSpewStream(debug_spew_stream);
}

bool Parser::OpenFile (string const &input_filename)
{
    assert(m_scanner != NULL);
    ResetForNewInput();
    EmitExecutionMessage("opening file \"" + input_filename + "\" for input");
    bool scanner_open_file_succeeded = m_scanner->OpenFile(input_filename);
    if (scanner_open_file_succeeded)
        EmitExecutionMessage("opened file \"" + input_filename + "\" successfully");
    return scanner_open_file_succeeded;
}

void Parser::OpenString (string const &input_string, string const &input_name, bool use_line_numbers)
{
    assert(m_scanner != NULL);
    ResetForNewInput();
    return m_scanner->OpenString(input_string, input_name, use_line_numbers);
}

void Parser::OpenUsingStream (istream *input_stream, string const &input_name, bool use_line_numbers)
{
    assert(m_scanner != NULL);
    ResetForNewInput();
    return m_scanner->OpenUsingStream(input_stream, input_name, use_line_numbers);
}

} // end of namespace Preprocessor
} // end of namespace Barf
%}


%target.cpp.token_data_type "Ast::Base *"
%target.cpp.token_data_default "NULL"
%target.cpp.custom_token_data_type_cast "Dsc"
%target.cpp.throw_away_token_actions {
    delete token_data;
}
%target.cpp.scan_actions {
    assert(m_scanner != NULL);
    return m_scanner->Scan();
}


%target.cpp.generate_debug_spew_code
%target.cpp.debug_spew_prefix {"Preprocessor::Parser" << (GetFiLoc().IsValid() ? " ("+GetFiLoc().AsString()+")" : g_empty_string) << ":"}


%terminal TEXT %type.cpp "Text *"
%terminal START_CODE END_CODE
%terminal CODE_LINE CODE_NEWLINE
%terminal ID %type.cpp "Ast::Id *"
%terminal DUMP_SYMBOL_TABLE
%terminal IF ELSE ELSE_IF END_IF
%terminal UNDEFINE
%terminal DECLARE_ARRAY DECLARE_MAP
%terminal DEFINE END_DEFINE
%terminal LOOP END_LOOP
%terminal FOR_EACH END_FOR_EACH
%terminal INCLUDE SANDBOX_INCLUDE
%terminal WARNING ERROR FATAL_ERROR
%terminal SIZEOF
%terminal IS_DEFINED
%terminal INTEGER_LITERAL %type.cpp "Integer *"
%terminal STRING_LITERAL %type.cpp "Text *"
%terminal KEYWORD_INT KEYWORD_STRING
%terminal STRING_LENGTH
%terminal TO_CHARACTER_LITERAL
%terminal TO_STRING_LITERAL
%terminal '(' ')' '[' ']' ',' '?'
%terminal '.' '+' '-' '*' '/' '%'
%terminal '!' '&' '|' '=' '<' '>'
%terminal BAD_TOKEN

%prec.left %default
%prec.left LOGICAL_OR
%prec.left LOGICAL_AND
%prec.left EQUALITY
%prec.left COMPARISON
%prec.left CONCATENATION
%prec.left ADDITION
%prec.left MULTIPLICATION
%prec.right UNARY

%default_parse_nonterminal body

%%

%nonterminal body %type.cpp "Body *"
:
    %empty
    %target.cpp {
        return new Body();
    }
|
    TEXT:text
    %target.cpp {
        Body *body = new Body();
        body->Append(text);
        return body;
    }
|
    body:body executable:executable
    %target.cpp {
        if (executable != NULL)
            body->Append(executable);
        return body;
    }
|
    body:body executable:executable TEXT:text
    %target.cpp {
        if (executable != NULL)
            body->Append(executable);
        body->Append(text);
        return body;
    }
;

%nonterminal executable %type.cpp "ExecutableAst *"
:
    code:code
    %target.cpp {
        return code;
    }
|
    conditional_series:conditional
    %target.cpp {
        return conditional;
    }
|
    define:define body:body end_define
    %target.cpp {
        define->SetBody(body);
        return define;
    }
|
    loop:loop body:body end_loop
    %target.cpp {
        loop->SetBody(body);
        return loop;
    }
|
    for_each:for_each body:body end_for_each
    %target.cpp {
        for_each->SetBody(body);
        return for_each;
    }
;

%nonterminal code %type.cpp "ExecutableAst *"
:
    START_CODE code_body:code_body END_CODE %target.cpp { return code_body; }
|
    CODE_LINE code_body:code_body CODE_NEWLINE %target.cpp { return code_body; }
;

%nonterminal code_body %type.cpp "ExecutableAst *"
:
    %empty
    %target.cpp { return NULL; }
|
    expression:expression
    %target.cpp { return expression; }
|
    DUMP_SYMBOL_TABLE '(' ')'
    %target.cpp { return new DumpSymbolTable(); }
|
    UNDEFINE '(' ID:id ')'
    %target.cpp { return new Undefine(id); }
|
    DECLARE_ARRAY '(' ID:id ')'
    %target.cpp { return new DeclareArray(id); }
|
    DECLARE_MAP '(' ID:id ')'
    %target.cpp { return new DeclareMap(id); }
|
    INCLUDE '(' expression:include_filename_expression ')'
    %target.cpp { return new Include(include_filename_expression, false); }
|
    SANDBOX_INCLUDE '(' expression:include_filename_expression ')'
    %target.cpp { return new Include(include_filename_expression, true); }
|
    WARNING '(' expression:message_expression ')'
    %target.cpp { return new Message(message_expression, Message::WARNING); }
|
    ERROR '(' expression:message_expression ')'
    %target.cpp { return new Message(message_expression, Message::ERROR); }
|
    FATAL_ERROR '(' expression:message_expression ')'
    %target.cpp { return new Message(message_expression, Message::FATAL_ERROR); }
;

%nonterminal conditional_series %type.cpp "Conditional *"
:
    if_statement:conditional body:if_body conditional_series_end:else_body
    %target.cpp {
        conditional->SetIfBody(if_body);
        conditional->SetElseBody(else_body);
        return conditional;
    }
;

%nonterminal conditional_series_end %type.cpp "Body *"
:
    end_if %target.cpp { return NULL; }
|
    else_statement body:body end_if %target.cpp { return body; }
|
    else_if_statement:conditional body:if_body conditional_series_end:else_body
    %target.cpp {
        conditional->SetIfBody(if_body);
        conditional->SetElseBody(else_body);
        Body *body = new Body();
        body->Append(conditional);
        return body;
    }
;

%nonterminal if_statement %type.cpp "Conditional *"
:
    START_CODE IF '(' expression:expression ')' END_CODE
    %target.cpp { return new Conditional(expression); }
|
    CODE_LINE IF '(' expression:expression ')' CODE_NEWLINE
    %target.cpp { return new Conditional(expression); }
;

%nonterminal else_statement
:
    START_CODE ELSE END_CODE %target.cpp { return NULL; }
|
    CODE_LINE ELSE CODE_NEWLINE %target.cpp { return NULL; }
;

%nonterminal else_if_statement %type.cpp "Conditional *"
:
    START_CODE ELSE_IF '(' expression:expression ')' END_CODE
    %target.cpp { return new Conditional(expression); }
|
    CODE_LINE ELSE_IF '(' expression:expression ')' CODE_NEWLINE
    %target.cpp { return new Conditional(expression); }
;

%nonterminal end_if
:
    START_CODE END_IF END_CODE %target.cpp { return NULL; }
|
    CODE_LINE END_IF CODE_NEWLINE %target.cpp { return NULL; }
;

%nonterminal define %type.cpp "Define *"
:
    define_scalar:define        %target.cpp { return define; }
|
    define_array_element:define %target.cpp { return define; }
|
    define_map_element:define   %target.cpp { return define; }
;

%nonterminal define_scalar %type.cpp "Define *"
:
    START_CODE DEFINE '(' ID:id ')' END_CODE
    %target.cpp { return new Define(id); }
|
    CODE_LINE DEFINE '(' ID:id ')' CODE_NEWLINE
    %target.cpp { return new Define(id); }
;

%nonterminal define_array_element %type.cpp "Define *"
:
    START_CODE DEFINE '(' ID:id '[' ']' ')' END_CODE
    %target.cpp { return new DefineArrayElement(id); }
|
    CODE_LINE DEFINE '(' ID:id '[' ']' ')' CODE_NEWLINE
    %target.cpp { return new DefineArrayElement(id); }
;

%nonterminal define_map_element %type.cpp "Define *"
:
    START_CODE DEFINE '(' ID:id '[' STRING_LITERAL:key ']' ')' END_CODE
    %target.cpp { return new DefineMapElement(id, key); }
|
    CODE_LINE DEFINE '(' ID:id '[' STRING_LITERAL:key ']' ')' CODE_NEWLINE
    %target.cpp { return new DefineMapElement(id, key); }
;

%nonterminal end_define
:
    START_CODE END_DEFINE END_CODE %target.cpp { return NULL; }
|
    CODE_LINE END_DEFINE CODE_NEWLINE %target.cpp { return NULL; }
;

%nonterminal loop %type.cpp "Loop *"
:
    START_CODE LOOP '(' ID:iterator_id ',' expression:iteration_count_expression ')' END_CODE
    %target.cpp { return new Loop(iterator_id, iteration_count_expression); }
|
    CODE_LINE LOOP '(' ID:iterator_id ',' expression:iteration_count_expression ')' CODE_NEWLINE
    %target.cpp { return new Loop(iterator_id, iteration_count_expression); }
;

%nonterminal end_loop
:
    START_CODE END_LOOP END_CODE %target.cpp { return NULL; }
|
    CODE_LINE END_LOOP CODE_NEWLINE %target.cpp { return NULL; }
;

%nonterminal for_each %type.cpp "ForEach *"
:
    START_CODE FOR_EACH '(' ID:key_id ',' ID:map_id ')' END_CODE
    %target.cpp { return new ForEach(key_id, map_id); }
|
    CODE_LINE FOR_EACH '(' ID:key_id ',' ID:map_id ')' CODE_NEWLINE
    %target.cpp { return new ForEach(key_id, map_id); }
;

%nonterminal end_for_each
:
    START_CODE END_FOR_EACH END_CODE %target.cpp { return NULL; }
|
    CODE_LINE END_FOR_EACH CODE_NEWLINE %target.cpp { return NULL; }
;

%nonterminal expression %type.cpp "Expression *"
:
    STRING_LITERAL:str
    %target.cpp { return str; }
|
    INTEGER_LITERAL:integer
    %target.cpp { return integer; }
|
    SIZEOF '(' ID:id ')'
    %target.cpp { return new Sizeof(id); }
|
    KEYWORD_INT '(' expression:expression ')'
    %target.cpp { return new Operation(Operation::INT_CAST, expression); }
|
    KEYWORD_STRING '(' expression:expression ')'
    %target.cpp { return new Operation(Operation::STRING_CAST, expression); }
|
    STRING_LENGTH '(' expression:expression ')'
    %target.cpp { return new Operation(Operation::STRING_LENGTH, expression); }
|
    TO_CHARACTER_LITERAL '(' expression:character_index_expression ')'
    %target.cpp { return new Operation(Operation::TO_CHARACTER_LITERAL, character_index_expression); }
|
    TO_STRING_LITERAL '(' expression:string_expression ')'
    %target.cpp { return new Operation(Operation::TO_STRING_LITERAL, string_expression); }
|
    IS_DEFINED '(' ID:id ')'
    %target.cpp { return new IsDefined(id, NULL); }
|
    IS_DEFINED '(' ID:id '[' expression:element_index_expression ']' ')'
    %target.cpp { return new IsDefined(id, element_index_expression); }
|
    ID:id
    %target.cpp { return new Dereference(id, NULL, DEREFERENCE_ALWAYS); }
|
    ID:id '[' expression:element_index_expression ']'
    %target.cpp { return new Dereference(id, element_index_expression, DEREFERENCE_ALWAYS); }
|
    ID:id '?'
    %target.cpp { return new Dereference(id, NULL, DEREFERENCE_IFF_DEFINED); }
|
    ID:id '[' expression:element_index_expression ']' '?'
    %target.cpp { return new Dereference(id, element_index_expression, DEREFERENCE_IFF_DEFINED); }
|
    expression:left '.' expression:right %prec CONCATENATION
    %target.cpp { return new Operation(left, Operation::CONCATENATE, right); }
|
    expression:left '|' '|' expression:right %prec LOGICAL_OR
    %target.cpp { return new Operation(left, Operation::LOGICAL_OR, right); }
|
    expression:left '&' '&' expression:right %prec LOGICAL_AND
    %target.cpp { return new Operation(left, Operation::LOGICAL_AND, right); }
|
    expression:left '=' '=' expression:right %prec EQUALITY
    %target.cpp { return new Operation(left, Operation::EQUAL, right); }
|
    expression:left '!' '=' expression:right %prec EQUALITY
    %target.cpp { return new Operation(left, Operation::NOT_EQUAL, right); }
|
    expression:left '<' expression:right %prec COMPARISON
    %target.cpp { return new Operation(left, Operation::LESS_THAN, right); }
|
    expression:left '<' '=' expression:right %prec COMPARISON
    %target.cpp { return new Operation(left, Operation::LESS_THAN_OR_EQUAL, right); }
|
    expression:left '>' expression:right %prec COMPARISON
    %target.cpp { return new Operation(left, Operation::GREATER_THAN, right); }
|
    expression:left '>' '=' expression:right %prec COMPARISON
    %target.cpp { return new Operation(left, Operation::GREATER_THAN_OR_EQUAL, right); }
|
    expression:left '+' expression:right %prec ADDITION
    %target.cpp { return new Operation(left, Operation::PLUS, right); }
|
    expression:left '-' expression:right %prec ADDITION
    %target.cpp { return new Operation(left, Operation::MINUS, right); }
|
    expression:left '*' expression:right %prec MULTIPLICATION
    %target.cpp { return new Operation(left, Operation::MULTIPLY, right); }
|
    expression:left '/' expression:right %prec MULTIPLICATION
    %target.cpp { return new Operation(left, Operation::DIVIDE, right); }
|
    expression:left '%' expression:right %prec MULTIPLICATION
    %target.cpp { return new Operation(left, Operation::REMAINDER, right); }
|
    '-' expression:expression            %prec UNARY
    %target.cpp { return new Operation(Operation::NEGATIVE, expression); }
|
    '!' expression:expression            %prec UNARY
    %target.cpp { return new Operation(Operation::LOGICAL_NOT, expression); }
|
    '(' expression:expression ')'
    %target.cpp { return expression; }
;