calculator_parser.trison

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

%targets cpp


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


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

#include "calculator.hpp"

namespace Calculator {

class Scanner;
%}
%target.cpp.class_name Parser
%target.cpp.bottom_of_class {
    bool ShouldPrintResult () const { return m_should_print_result; }

    void SetInputString (string const &input_string);

private:

    Scanner *m_scanner;
    double m_last_result;
    double m_modulus;
    bool m_should_print_result;
}

%target.cpp.bottom_of_header_file %{
} // end of namespace Calculator

#endif // !defined(CALCULATOR_PARSER_HPP_)
%}


%target.cpp.top_of_implementation_file %{
#include "calculator_scanner.hpp"

#define MODULO(x) (m_modulus == 0 ? x : fmod(x, m_modulus))

namespace Calculator {
%}
%target.cpp.constructor_actions {
    m_scanner = NULL;
    m_last_result = 0.0;
    m_modulus = 0.0;
    m_should_print_result = true;
}
%target.cpp.destructor_actions {
    delete m_scanner;
    m_scanner = NULL;
}
%target.cpp.top_of_parse_method_actions %{
    m_should_print_result = true;
%}
%target.cpp.bottom_of_implementation_file %{
void Parser::SetInputString (string const &input_string)
{
    if (m_scanner != NULL)
        delete m_scanner;
    m_scanner = new Scanner(input_string);
    ResetForNewInput();
}

} // end of namespace Calculator
%}


%target.cpp.token_data_type "double"
%target.cpp.token_data_default "0.0"
%target.cpp.scan_actions {
    assert(m_scanner != NULL);
    return m_scanner->Scan();
}


%target.cpp.generate_debug_spew_code


%terminal BAD_TOKEN
%terminal NEWLINE
%terminal NUMBER
%terminal RESULT
%terminal HELP MOD
%terminal LOG
%terminal '+' '-' '*' '/' '^' '(' ')' '\\'

%prec.left %default
%prec.left ADDITION
%prec.left MULTIPLICATION
%prec.right UNARY
%prec.right EXPONENTIATION

%default_parse_nonterminal root

%%

%nonterminal root
:
    %empty
    %target.cpp {
        m_should_print_result = false;
        return 0.0;
    }
|
    expression:result
    %target.cpp {
        result = MODULO(result);
        if (m_should_print_result)
            m_last_result = result;
        return result;
    }
|
    command
    %target.cpp {
        m_should_print_result = false;
        return 0.0;
    }
;

%nonterminal expression
:
    expression:lhs '+' expression:rhs %prec ADDITION %target.cpp { return MODULO(lhs + rhs); }
|
    expression:lhs '-' expression:rhs %prec ADDITION %target.cpp { return MODULO(lhs - rhs); }
|
    expression:lhs '*' expression:rhs %prec MULTIPLICATION %target.cpp { return MODULO(lhs * rhs); }
|
    expression:lhs '/' expression:rhs %prec MULTIPLICATION
    %target.cpp {
        if (rhs == 0.0)
        {
            cerr << "error: divide by zero" << endl;
            m_should_print_result = false;
            return 1.0; // arbitrary non-zero return value
        }
        else
            return lhs / rhs;
    }
|
    '+' expression:ex %prec UNARY %target.cpp { return MODULO(ex); }
|
    '-' expression:ex %prec UNARY %target.cpp { return MODULO(-ex); }
|
    LOG '(' expression:ex ')' %prec UNARY %target.cpp { return log(ex); }
|
    expression:base '^' expression:power %prec EXPONENTIATION
    %target.cpp {
        if (base == 0.0 && power == 0.0)
        {
            cerr << "error: taking 0 to the 0 power" << endl;
            m_should_print_result = false;
            return 1.0; // arbitrary non-zero return value
        }
        else
            return MODULO(pow(base, power));
    }
|
    '(' expression:ex ')' %target.cpp { return ex; }
|
    NUMBER:number %target.cpp { return MODULO(number); }
|
    RESULT %target.cpp { return m_last_result; }
;

%nonterminal command
:
    '\\' HELP
    %target.cpp {
        cout << "Operators\n"
                "  + - * / ^ ( )\n"
                "Symbols\n"
                "  r          - The value of the previous result.\n"
                "  pi         - The ratio of a circle's circumference to its diameter.\n"
                "  e          - The base of the natural logarithm.\n"
                "Functions\n"
                "  log        - The natural logarithm (base e).\n"
                "Commands\n"
                "  \\help      - This help screen.\n"
                "  \\mod [arg] - Sets the modulus (i.e. modulo arithmetic).  Giving no\n"
                "               argument will print the current modulus.  A modulus\n"
                "               of 0 indicates no result truncation." << endl;
        return 0.0;
    }
|
    '\\' MOD NUMBER:number
    %target.cpp {
        if (number >= 0.0)
        {
            m_modulus = number;
            cout << "current modulus set to: " << m_modulus << endl;
        }
        else
            cerr << "error: invalid modulus (must be non-negative)" << endl;
        return 0.0;
    }
|
    '\\' MOD
    %target.cpp {
        cout << "current modulus: " << m_modulus << endl;
        return 0.0;
    }
;

%nonterminal at_least_zero_newlines
:
    at_least_zero_newlines NEWLINE %target.cpp { return 0.0; }
|
    %empty %target.cpp { return 0.0; }
;