barf_targetspec_parser.trison

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

%targets cpp


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


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

#include "barf.hpp"

#include "barf_commonlang_scanner.hpp"

namespace Barf {
namespace Ast {

class Base;

} // end of namespace Ast

namespace Targetspec {

struct AddCodespecList;
struct AddDirectiveMap;
%}
%target.cpp.class_name Parser
%target.cpp.bottom_of_class {
    inline FiLoc const &GetFiLoc () const { return m_scanner.GetFiLoc(); }

    bool ScannerDebugSpewIsEnabled () const { return m_scanner.DebugSpewIsEnabled(); }
    std::ostream *ScannerDebugSpewStream () { return m_scanner.DebugSpewStream(); }
    void SetScannerDebugSpewStream (std::ostream *debug_spew_stream) { m_scanner.SetDebugSpewStream(debug_spew_stream); }

    bool OpenTargetspec (string const &input_filename, string const &target_id);

private:

    string m_target_id;
    CommonLang::Scanner m_scanner;
    AddCodespecList *m_add_codespec_list;
    AddDirectiveMap *m_add_directive_map;
}
%target.cpp.bottom_of_header_file %{
} // end of namespace Targetspec
} // end of namespace Barf

#endif // !defined(BARF_TARGETSPEC_PARSER_HPP_)
%}


%target.cpp.top_of_implementation_file %{
#include "barf_ast.hpp"
#include "barf_targetspec_ast.hpp"

namespace Barf {
namespace Targetspec {
%}
%target.cpp.top_of_parse_method_actions %{
    m_add_codespec_list = new AddCodespecList();
    m_add_directive_map = new AddDirectiveMap();
    EmitExecutionMessage("starting targetspec parser");
%}
%target.cpp.bottom_of_parse_method_actions %{
    if (parse_return_code == PRC_SUCCESS)
        EmitExecutionMessage("targetspec parse was successful");
%}
%target.cpp.bottom_of_implementation_file %{
bool Parser::OpenTargetspec (string const &input_filename, string const &target_id)
{
    assert(!target_id.empty());

    ResetForNewInput();
    m_target_id.empty();
    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");
        m_target_id = target_id;
    }
    return scanner_open_file_succeeded;
}

} // end of namespace Targetspec
} // 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 {
    Ast::Base *lookahead_token_data = NULL;
    CommonLang::Scanner::Token::Type scanner_token_type = m_scanner.Scan(lookahead_token_data);
    assert(scanner_token_type >= 0);
    if (scanner_token_type < 0x100)
        return Token(scanner_token_type);
    switch (scanner_token_type)
    {
        case CommonLang::Scanner::Token::BAD_END_OF_FILE:                  return Token(Terminal::END_, lookahead_token_data);
        case CommonLang::Scanner::Token::BAD_TOKEN:                        return Token(Terminal::BAD_TOKEN, lookahead_token_data);
        case CommonLang::Scanner::Token::DIRECTIVE_ADD_CODESPEC:           return Token(Terminal::DIRECTIVE_ADD_CODESPEC, lookahead_token_data);
        case CommonLang::Scanner::Token::DIRECTIVE_ADD_OPTIONAL_DIRECTIVE: return Token(Terminal::DIRECTIVE_ADD_OPTIONAL_DIRECTIVE, lookahead_token_data);
        case CommonLang::Scanner::Token::DIRECTIVE_ADD_REQUIRED_DIRECTIVE: return Token(Terminal::DIRECTIVE_ADD_REQUIRED_DIRECTIVE, lookahead_token_data);
        case CommonLang::Scanner::Token::DIRECTIVE_DEFAULT:                return Token(Terminal::DIRECTIVE_DEFAULT, lookahead_token_data);
        case CommonLang::Scanner::Token::DIRECTIVE_DUMB_CODE_BLOCK:        return Token(Terminal::DIRECTIVE_DUMB_CODE_BLOCK, lookahead_token_data);
        case CommonLang::Scanner::Token::DIRECTIVE_ID:                     return Token(Terminal::DIRECTIVE_ID, lookahead_token_data);
        case CommonLang::Scanner::Token::DIRECTIVE_STRICT_CODE_BLOCK:      return Token(Terminal::DIRECTIVE_STRICT_CODE_BLOCK, lookahead_token_data);
        case CommonLang::Scanner::Token::DIRECTIVE_STRING:                 return Token(Terminal::DIRECTIVE_STRING, lookahead_token_data);
        case CommonLang::Scanner::Token::DIRECTIVE_TARGET:                 return Token(Terminal::DIRECTIVE_TARGET, lookahead_token_data);
        case CommonLang::Scanner::Token::DUMB_CODE_BLOCK:                  return Token(Terminal::DUMB_CODE_BLOCK, lookahead_token_data);
        case CommonLang::Scanner::Token::END_OF_FILE:                      return Token(Terminal::END_, lookahead_token_data);
        case CommonLang::Scanner::Token::ID:                               return Token(Terminal::ID, lookahead_token_data);
        case CommonLang::Scanner::Token::NEWLINE:                          return Token(Terminal::NEWLINE, lookahead_token_data);
        case CommonLang::Scanner::Token::STRICT_CODE_BLOCK:                return Token(Terminal::STRICT_CODE_BLOCK, lookahead_token_data);
        case CommonLang::Scanner::Token::STRING_LITERAL:                   return Token(Terminal::STRING_LITERAL, lookahead_token_data);

        case CommonLang::Scanner::Token::CHAR_LITERAL:
        case CommonLang::Scanner::Token::DIRECTIVE_DEFAULT_PARSE_NONTERMINAL:
        case CommonLang::Scanner::Token::DIRECTIVE_ERROR:
        case CommonLang::Scanner::Token::DIRECTIVE_LOOKAHEAD:
        case CommonLang::Scanner::Token::DIRECTIVE_MACRO:
        case CommonLang::Scanner::Token::DIRECTIVE_NONTERMINAL:
        case CommonLang::Scanner::Token::DIRECTIVE_PREC:
        case CommonLang::Scanner::Token::DIRECTIVE_START_IN_STATE_MACHINE:
        case CommonLang::Scanner::Token::DIRECTIVE_STATE_MACHINE:
        case CommonLang::Scanner::Token::DIRECTIVE_TARGETS:
        case CommonLang::Scanner::Token::DIRECTIVE_TERMINAL:
        case CommonLang::Scanner::Token::DIRECTIVE_TYPE:
        case CommonLang::Scanner::Token::END_PREAMBLE:
        case CommonLang::Scanner::Token::REGEX:
            assert(lookahead_token_data != NULL);
            EmitError(FORMAT("unrecognized token " << scanner_token_type), lookahead_token_data->GetFiLoc());
            delete lookahead_token_data;
            lookahead_token_data = NULL;
            return Token(Terminal::BAD_TOKEN);

        default:
            assert(false && "this should never happen");
            return Token(Terminal::BAD_TOKEN);
    }
}


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


%terminal BAD_TOKEN
%terminal DIRECTIVE_ADD_CODESPEC %type.cpp "Ast::ThrowAway *"
%terminal DIRECTIVE_ADD_OPTIONAL_DIRECTIVE %type.cpp "Ast::ThrowAway *"
%terminal DIRECTIVE_ADD_REQUIRED_DIRECTIVE %type.cpp "Ast::ThrowAway *"
%terminal DIRECTIVE_DEFAULT %type.cpp "Ast::ThrowAway *"
%terminal DIRECTIVE_DUMB_CODE_BLOCK
%terminal DIRECTIVE_ID
%terminal DIRECTIVE_STRICT_CODE_BLOCK
%terminal DIRECTIVE_STRING
%terminal DIRECTIVE_TARGET %type.cpp "Ast::ThrowAway *"
%terminal DUMB_CODE_BLOCK %type.cpp "Ast::DumbCodeBlock *"
%terminal ID %type.cpp "Ast::Id *"
%terminal NEWLINE
%terminal STRICT_CODE_BLOCK %type.cpp "Ast::StrictCodeBlock *"
%terminal STRING_LITERAL %type.cpp "Ast::String *"

%prec.left %default

%default_parse_nonterminal root

%%

// ///////////////////////////////////////////////////////////////////////////
// root rule
// ///////////////////////////////////////////////////////////////////////////

%nonterminal root %type.cpp "Specification *"
:
    directives %end
    %target.cpp {
        assert(m_add_codespec_list != NULL);
        assert(m_add_directive_map != NULL);
        return new Specification(
            new Ast::Id(m_target_id, FiLoc::ms_invalid),
            m_add_codespec_list,
            m_add_directive_map);
    }
;

// ///////////////////////////////////////////////////////////////////////////
// directives (add_codespec and add_*_directive)
// ///////////////////////////////////////////////////////////////////////////

%nonterminal directives
:
    directives directive %target.cpp { return NULL; }
|
    %empty %target.cpp { return NULL; }
;

%nonterminal directive
:
    add_codespec at_least_one_newline %target.cpp { return NULL; }
|
    add_directive at_least_one_newline %target.cpp { return NULL; }
|
    at_least_one_newline %target.cpp { return NULL; }
;

%nonterminal add_codespec
:
    DIRECTIVE_ADD_CODESPEC:throwaway STRING_LITERAL:filename ID:filename_directive_id
    %target.cpp {
        assert(m_add_codespec_list != NULL);
        assert(m_add_directive_map != NULL);
        AddDirective *add_directive = m_add_directive_map->Element(filename_directive_id->GetText());
        if (add_directive == NULL)
            EmitError("undeclared directive id \"" + filename_directive_id->GetText() + "\" in add_codespec directive", throwaway->GetFiLoc());
        if (add_directive == NULL || !add_directive->IsRequired() || add_directive->m_param_type != Ast::AST_STRING)
            EmitError("directive id \"" + filename_directive_id->GetText() + "\" in add_codespec directive must refer to a required directive accepting param type %string", throwaway->GetFiLoc());
        if (filename->GetText().find_first_of(DIRECTORY_SLASH_STRING) != string::npos)
            EmitError("filename portion \"" + filename->GetText() + "\" of %add_codespec directive may not contain slash (directory-delimiting) characters", throwaway->GetFiLoc());
        m_add_codespec_list->Append(new AddCodespec(filename, filename_directive_id));
        delete throwaway;
        return NULL;
    }
;

%nonterminal add_directive %type.cpp "AddDirective *"
:
    DIRECTIVE_ADD_OPTIONAL_DIRECTIVE:throwaway ID:directive_to_add_id param_spec:param_type
    %target.cpp {
        assert(m_add_directive_map != NULL);
        m_add_directive_map->Add(
            directive_to_add_id->GetText(),
            new AddOptionalDirective(directive_to_add_id, param_type->m_param_type, NULL));
        delete throwaway;
        delete param_type;
        return NULL;
    }
|
    DIRECTIVE_ADD_OPTIONAL_DIRECTIVE:throwaway1 ID:directive_to_add_id param_spec:param_type DIRECTIVE_DEFAULT:throwaway2 default_value:default_value
    %target.cpp {
        assert(m_add_directive_map != NULL);
        AddDirective *directive =
            new AddOptionalDirective(
                directive_to_add_id,
                param_type->m_param_type, default_value);
        m_add_directive_map->Add(
            directive_to_add_id->GetText(),
            directive);
        if (param_type->m_param_type != default_value->GetAstType())
            EmitError(
                "type mismatch for default value for directive " + directive->DirectiveString() +
                "; was expecting type " + Ast::TextBase::DirectiveTypeString(param_type->m_param_type) +
                " but got type " + Ast::TextBase::DirectiveTypeString(default_value->GetAstType()),
                throwaway1->GetFiLoc());
        delete throwaway1;
        delete param_type;
        delete throwaway2;
        return NULL;
    }
|
    DIRECTIVE_ADD_REQUIRED_DIRECTIVE:throwaway ID:directive_to_add_id param_spec:param_type
    %target.cpp {
        assert(m_add_directive_map != NULL);
        m_add_directive_map->Add(
            directive_to_add_id->GetText(),
            new AddRequiredDirective(directive_to_add_id, param_type->m_param_type));
        delete throwaway;
        delete param_type;
        return NULL;
    }
;

%nonterminal param_spec %type.cpp "ParamType *"
:
    %empty
    %target.cpp {
        return new ParamType(Ast::AST_NONE);
    }
|
    DIRECTIVE_ID:throwaway
    %target.cpp {
        delete throwaway;
        return new ParamType(Ast::AST_ID);
    }
|
    DIRECTIVE_STRING:throwaway
    %target.cpp {
        delete throwaway;
        return new ParamType(Ast::AST_STRING);
    }
|
    DIRECTIVE_DUMB_CODE_BLOCK:throwaway
    %target.cpp {
        delete throwaway;
        return new ParamType(Ast::AST_DUMB_CODE_BLOCK);
    }
|
    DIRECTIVE_STRICT_CODE_BLOCK:throwaway
    %target.cpp {
        delete throwaway;
        return new ParamType(Ast::AST_STRICT_CODE_BLOCK);
    }
;

%nonterminal default_value %type.cpp "Ast::TextBase *"
:
    ID:value                %target.cpp { return value; }
|   STRING_LITERAL:value    %target.cpp { return value; }
|   DUMB_CODE_BLOCK:value   %target.cpp { return value; }
|   STRICT_CODE_BLOCK:value %target.cpp { return value; }
;

// ///////////////////////////////////////////////////////////////////////////
// misc rules
// ///////////////////////////////////////////////////////////////////////////

%nonterminal at_least_one_newline
:
    at_least_one_newline NEWLINE %target.cpp { return NULL; }
|
    NEWLINE %target.cpp { return NULL; }
;