Commit 36e4e9d4 authored by Dominik Bongartz's avatar Dominik Bongartz
Browse files

Release version v0.4

Add grammar documentation
Minor fixes for MSVC and gcc 11
parent 2fc61650
......@@ -30,6 +30,8 @@ if(MSVC)
target_compile_options(ale
PUBLIC /bigobj
)
message(STATUS "Detected MSVC: using compile definitions _USE_MATH_DEFINES")
add_compile_definitions(_USE_MATH_DEFINES)
endif()
##########
......
......@@ -14,21 +14,9 @@
#define LIBALE_MAX_DIM 3
#define LIBALE_MAX_SET_DIM 1
#if (LIBALE_MAX_DIM < 1 || LIBALE_MAX_DIM > 10)
#if (LIBALE_MAX_DIM < 1)
#error LIBALE_MAX_DIM must be between 1 and 10
#endif
#define LIBALE_REPEAT_0 LIBALE_TO_REPEAT(0)
#define LIBALE_REPEAT_1 LIBALE_REPEAT_0 LIBALE_TO_REPEAT(1)
#define LIBALE_REPEAT_2 LIBALE_REPEAT_1 LIBALE_TO_REPEAT(2)
#define LIBALE_REPEAT_3 LIBALE_REPEAT_2 LIBALE_TO_REPEAT(3)
#define LIBALE_REPEAT_4 LIBALE_REPEAT_3 LIBALE_TO_REPEAT(4)
#define LIBALE_REPEAT_5 LIBALE_REPEAT_4 LIBALE_TO_REPEAT(5)
#define LIBALE_REPEAT_6 LIBALE_REPEAT_5 LIBALE_TO_REPEAT(6)
#define LIBALE_REPEAT_7 LIBALE_REPEAT_6 LIBALE_TO_REPEAT(7)
#define LIBALE_REPEAT_8 LIBALE_REPEAT_7 LIBALE_TO_REPEAT(8)
#define LIBALE_REPEAT_9 LIBALE_REPEAT_8 LIBALE_TO_REPEAT(9)
#define LIBALE_REPEAT_10 LIBALE_REPEAT_9 LIBALE_TO_REPEAT(10)
#define LIBALE_REPEAT_LITERAL(N) LIBALE_REPEAT_ ## N
#define LIBALE_REPEAT(N) LIBALE_REPEAT_LITERAL(N)
#if (LIBALE_MAX_SET_DIM < 1)
#error LIBALE_MAX_SET_DIM must be between 1 and 10
#endif
......@@ -60,25 +60,39 @@ class parser {
template <typename TType> bool match_expression(std::unique_ptr<value_node<TType>>&);
template <typename TType> bool match_expression(std::unique_ptr<value_node<TType>>&, std::string&);
bool match_literal(std::string&);
// expression<T> = value<T> [LITERAL] SEMICOL
// generic dispatch
template <typename TType> bool match_value(std::unique_ptr<value_node<TType>>&);
// value<T> = primary<T>
// generic primary tensor
template <typename TType> bool match_primary(std::unique_ptr<value_node<TType>>&);
// primary<T> = constant<T>
// | parameter<T>
// generic primary set
template <typename TType> bool match_primary(std::unique_ptr<value_node<set<TType, 0>>>&);
// primary<set<T>> = constant<set<T>>
// | parameter<set<T>>
// | entry<set<T>>
// generic primary alternatives
template <typename TType> bool match_constant(std::unique_ptr<value_node<TType>>&);
// constant<T> = basic<T>
template <typename TType> bool match_parameter(std::unique_ptr<value_node<TType>>&);
// parameter<T> = IDENT
template <typename TType> bool match_grouping(std::unique_ptr<value_node<TType>>&);
// grouping<T> = LPAREN value<T> RPAREN
template <typename TType> bool match_partial_entry(std::unique_ptr<value_node<TType>>&);
template <typename TAtom> bool match_partial_entry(std::unique_ptr<value_node<tensor_type<TAtom, LIBALE_MAX_DIM - 1>>>&);
template <typename TAtom> bool match_partial_entry(std::unique_ptr<value_node<set<TAtom, LIBALE_MAX_SET_DIM - 1>>>&);
template <typename TType> bool match_entry(std::unique_ptr<value_node<TType>>&);
template <typename TAtom> bool match_entry(std::unique_ptr<value_node<tensor_type<TAtom, LIBALE_MAX_DIM - 1>>>&);
template <typename TAtom> bool match_entry(std::unique_ptr<value_node<set<TAtom, LIBALE_MAX_SET_DIM - 1>>>&);
// LET n AND m BE DIMENSIONS WITH n < m
// entry<T<n>> = value<T<m>> LBRACK value<index<0>> ( COMMA value<index<0>> )*(m-n-1) RBRACK
// generic basics
template <typename TAtom, unsigned IDim> bool match_tensor(typename tensor_type<TAtom, IDim>::basic_type&);
......@@ -99,48 +113,190 @@ class parser {
inline bool match_basic(typename boolean<0>::basic_type&, basic_tag<boolean<0>>);
// template call to tag dispatch overloads
template <typename TType> bool match_basic(typename TType::basic_type&);
// basic<T<n>> = LBRACK [ basic<T<n-1>> ( COMMA basic<T<n-1>> )* ] RBRACK
// basic<real<0>> = [MINUS] ( NUMBER | INTEGER )
// basic<index<0>> = INTEGER
// basic<boolean<0>> = "true" | "false"
// basic<set<T>> = LBRACE [ basic<T> ( COMMA basic<T> )* ] RBRACE
// basic<set<index<0>>> = LBRACE [ basic<index<0>> ( COMMA basic<index<0>> )* ] RBRACE
// | LBRACE basic<index<0>> DOTS basic<index<0>> RBRACE
// set operations
template <unsigned IDim> bool match_any_sum(std::unique_ptr<value_node<real<0>>>&);
// any_sum = sum<real<0>> | sum <index<0>>
// | ...
// | sum<real<LIBALE_MAX_DIM>> | sum<index<LIBALE_MAX_DIM>>
template <typename TType> bool match_sum(std::unique_ptr<value_node<real<0>>>&);
// sum<T> = "sum" LPAREN IDENT "in" COLON value<real<0>> RPAREN
template <unsigned IDim> bool match_any_set_min(std::unique_ptr<value_node<real<0>>>&);
// any_set_min = set_min<real<0>> | set_min <index<0>>
// | ...
// | set_min<real<LIBALE_MAX_DIM>> | set_min<index<LIBALE_MAX_DIM>>
template <typename TType> bool match_set_min(std::unique_ptr<value_node<real<0>>>&);
// set_min<T> = "min" LPAREN IDENT "in" COLON value<real<0>> RPAREN
template <unsigned IDim> bool match_any_set_max(std::unique_ptr<value_node<real<0>>>&);
// any_set_max = set_max<real<0>> | set_max<index<0>>
// | ...
// | set_max<real<LIBALE_MAX_DIM>> | set_max<index<LIBALE_MAX_DIM>>
template <typename TType> bool match_set_max(std::unique_ptr<value_node<real<0>>>&);
// set_max<T> = "max" LPAREN IDENT "in" COLON value<real<0>> RPAREN
//comparisons
template <typename TType> bool match_comparison(std::unique_ptr<value_node<boolean<0>>>&);
// comparison<T> = value<T> ( EQUAL | LESS | LEQUAL | GREATER | GEQUAL ) value<T>
// sets
template <typename TType> bool match_indicator_set(std::unique_ptr<value_node<set<TType, 0>>>&);
// indicator_set<T> = LBRACE IDENT "in" value<set<T>> COLON value<boolean<0>> RBRACE
// quantifiers
template <unsigned IDim> bool match_any_quantifier(std::unique_ptr<value_node<boolean<0>>>&);
// any_quantifier = forall<real<0>> | forall<index<0>>
// | ...
// | forall<real<LIBALE_MAX_DIM>> | forall<index<LIBALE_MAX_DIM>>
template <typename TType> bool match_forall(std::unique_ptr<value_node<boolean<0>>>&);
// forall<T> = "forall" IDENT "in" value<set<T>> COLON value<boolean<0>>
// definitions
template <typename TAtom> bool match_declarator();
template <unsigned IDim> bool match_any_definition();
// any_definition = real_definition<0>
// | integer_definition<0>
// | binary_definition<0>
// | definition<index<0>>
// | definition<boolean<0>>
// | set_definition<real<0>>
// | set_definition<index<0>>
// | set_definition<boolean<0>>
// | expr_definition<real<0>>
// | expr_definition<index<0>>
// | expr_definition<boolean<0>>
// | real_definition<1>
// | integer_definition<1>
// | binary_definition<1>
// | definition<index<1>>
// | definition<boolean<1>>
// | set_definition<real<1>>
// | set_definition<index<1>>
// | set_definition<boolean<1>>
// | ...
// | real_definition<LIBALE_MAX_DIM>
// | integer_definition<LIBALE_MAX_DIM>
// | binary_definition<LIBALE_MAX_DIM>
// | definition<index<LIBALE_MAX_DIM>>
// | definition<boolean<LIBALE_MAX_DIM>>
// | set_definition<real<LIBALE_MAX_DIM>>
// | set_definition<index<LIBALE_MAX_DIM>>
// | set_definition<boolean<LIBALE_MAX_DIM>>
template <typename TType> bool match_definition();
// definition<index<n>> = "index" LBRACK INTEGER ( COMMA INTEGER )*n RBRACK IDENT
// DEFINE ( basic<index<0>> | basic<index<n>> ) SEMICOL
// definition<index<0>> = "index" IDENT DEFINE basic<index<0>> SEMICOL
// definition<boolean<n>> = "boolean" LBRACK INTEGER ( COMMA INTEGER )*n RBRACK IDENT
// DEFINE ( basic<boolean<0>> | basic<boolean<n>> ) SEMICOL
// definition<boolean<0>> = "boolean" IDENT DEFINE basic<boolean<0>> SEMICOL
template <unsigned IDim> bool match_real_definition();
// real_definition<n> = "real" LBRACK INTEGER ( COMMA INTEGER )*n RBRACK IDENT
// ( SEMICOL
// | DEFINE ( basic<real<0>> | basic<real<n>> ) SEMICOL
// | "in" LBRACK basic<real<0>> COMMA basic<real<0>> RBRACK SEMICOL
// | "in" LBRACK basic<real<0>> COMMA basic<real<n>> RBRACK SEMICOL
// | "in" LBRACK basic<real<n>> COMMA basic<real<0>> RBRACK SEMICOL
// | "in" LBRACK basic<real<n>> COMMA basic<real<n>> RBRACK SEMICOL
// )
// real_definition<0> = "real" IDENT
// ( SEMICOL
// | DEFINE basic<real<0>> SEMICOL
// | "in" LBRACK basic<real<0>> COMMA basic<real<0>> RBRACK SEMICOL
// )
template <unsigned IDim> bool match_integer_definition();
// integer_definition<n> = "integer" LBRACK INTEGER ( COMMA INTEGER )*n RBRACK IDENT
// ( SEMICOL
// | "in" LBRACK basic<real<0>> COMMA basic<real<0>> RBRACK SEMICOL
// | "in" LBRACK basic<real<0>> COMMA basic<real<n>> RBRACK SEMICOL
// | "in" LBRACK basic<real<n>> COMMA basic<real<0>> RBRACK SEMICOL
// | "in" LBRACK basic<real<n>> COMMA basic<real<n>> RBRACK SEMICOL
// )
// integer_definition<n> = "integer" IDENT
// ( SEMICOL
// | "in" LBRACK basic<real<0>> COMMA basic<real<0>> RBRACK SEMICOL
// )
template <unsigned IDim> bool match_binary_definition();
// binary_definition<n> = "binary" LBRACK INTEGER ( COMMA INTEGER )*n RBRACK IDENT SEMICOL
// binary_definition<0> = "binary" IDENT SEMICOL
template <typename TType> bool match_set_definition();
// set_definition<T<n>> = "set" LBRACE T LBRACK COLON ( COMMA COLON )*n RBRACK RBRACE IDENT
// ( SEMICOL
// | DEFINE basic<set<T<n>>> SEMICOL
// )
// set_definition<T<0>> = "set" IDENT
// ( SEMICOL
// | DEFINE basic<set<T<0>>> SEMICOL
// )
template <typename TType> bool match_expr_definition();
// expr_definition<real<0>> = "real" IDENT DEFINE value<real<0>> SEMICOL
// expr_definition<index<0>> = "index" IDENT DEFINE value<index<0>> SEMICOL
// expr_definition<boolean<0>> = "boolean" IDENT DEFINE value<boolean<0>> SEMICOL
// assignments
template <unsigned IDim> bool match_any_assignment();
// any_assignment = assignment<real<0>>
// | assignment<index<0>>
// | assignment<boolean<0>>
// | bound_assignment<0>
// | init_assignment<0>
// | ...
// | assignment<real<LIBALE_MAX_DIM>>
// | assignment<index<LIBALE_MAX_DIM>>
// | assignment<boolean<LIBALE_MAX_DIM>>
// | bound_assignment<LIBALE_MAX_DIM>
// | init_assignment<LIBALE_MAX_DIM>
template <typename TType> bool match_assignment();
// assignment<T<n>> = IDENT LBRACK ( INTEGER | COLON ) ( COMMA ( INTEGER | COLON ) )*n RBRACK
// ASSIGN basic<T<0>> SEMICOL
// assignment<T<0>> = IDENT ASSIGN basic<T<0>> SEMICOL
template <unsigned IDim> bool match_bound_assignment();
// bound_assignment<n> = IDENT DOT ( "ub" | "lb" )
// LBRACK ( INTEGER | COLON ) ( COMMA ( INTEGER | COLON ) )*n RBRACK
// ASSIGN basic<real<0>> SEMICOL
// bound_assignment<0> = IDENT DOT ( "ub" | "lb" ) ASSIGN basic<real<0>> SEMICOL
template <unsigned IDim> bool match_init_assignment();
// init_assignment<n> = IDENT DOT "init"
// LBRACK ( INTEGER | COLON ) ( COMMA ( INTEGER | COLON ) )*n RBRACK
// ASSIGN basic<real<0>> SEMICOL
// init_assignment<0> = IDENT DOT "init" ASSIGN basic<real<0>> SEMICOL
bool match_value(std::unique_ptr<value_node<real<0>>>&);
// value<real<0>> = addition<real<0>>
bool match_addition(std::unique_ptr<value_node<real<0>>>&);
// addition<real<0>> = [MINUS] multiplication<real<0>> ( ( PLUS | MINUS ) multiplication<real<0>> )*
bool match_multiplication(std::unique_ptr<value_node<real<0>>>&);
// multiplication<real<0>> = exponentiation ( ( STAR | SLASH ) exponentiation )*
bool match_exponentiation(std::unique_ptr<value_node<real<0>>>&);
// exponentiation = unary<real<0>> ( HAT unary<real<0>> )*
bool match_unary(std::unique_ptr<value_node<real<0>>>&);
// unary<real<0>> = primary<real<0>>
bool match_primary(std::unique_ptr<value_node<real<0>>>&);
// primary<real<0>> = constant<real<0>>
// | parameter<real<0>>
// | unary_function
// | binary_function
// | ternary_function
// | quaternary_function
// | quinary_function
// | senary_function
// | septenary_function
// | octonary_function
// | novenary_function
// | unodenary_function
// | nary_function
// | any_sum
// | any_set_min
// | any_set_max
// | grouping<real<0>>
// | entry<real<0>>
bool match_unary_function(std::unique_ptr<value_node<real<0>>>&);
// unary_dunction = FUNCTION_NAME grouping<real<0>>
bool match_binary_function(std::unique_ptr<value_node<real<0>>>&);
bool match_ternary_function(std::unique_ptr<value_node<real<0>>>&);
bool match_quaternary_function(std::unique_ptr<value_node<real<0>>>&);
......@@ -150,30 +306,70 @@ class parser {
bool match_octonary_function(std::unique_ptr<value_node<real<0>>>&);
bool match_novenary_function(std::unique_ptr<value_node<real<0>>>&);
bool match_unodenary_function(std::unique_ptr<value_node<real<0>>>&);
// LET k BE THE NUMBER OF ARGUMENTS
// kary_function = FUNCTION_NAME LPAREN value<real<0>> ( COMMA value<real<0>> )*k RPAREN
bool match_nary_function(std::unique_ptr<value_node<real<0>>>&);
// nary_function = min
// | max
// | sum_div
// | xlog_sum
bool match_min(std::unique_ptr<value_node<real<0>>>&);
// min = "min" LPAREN value<real<0>> ( COMMA value<real<0>> )* RPAREN
bool match_max(std::unique_ptr<value_node<real<0>>>&);
// max = "max" LPAREN value<real<0>> ( COMMA value<real<0>> )* RPAREN
bool match_sum_div(std::unique_ptr<value_node<real<0>>>&);
// sum_div = "sum_div" LPAREN value<real<0>> ( COMMA value<real<0>> )* RPAREN
bool match_xlog_sum(std::unique_ptr<value_node<real<0>>>&);
// xlog_sum = "xlog_sum" LPAREN value<real<0>> ( COMMA value<real<0>> )* RPAREN
bool match_value(std::unique_ptr<value_node<index<0>>>&);
// value<index<0>> = addition<index<0>>
bool match_addition(std::unique_ptr<value_node<index<0>>>&);
// addition<index<0>> = [MINUS] multiplication<index<0>> ( ( PLUS | MINUS ) multiplication<index<0>> )*
bool match_multiplication(std::unique_ptr<value_node<index<0>>>&);
// multiplication<index<0>> = unary<index<0>> ( STAR unary<index<0>> )*
bool match_unary(std::unique_ptr<value_node<index<0>>>&);
// unary<index<0>> = primary<index<0>>
bool match_primary(std::unique_ptr<value_node<index<0>>>&);
// primary<index<0>> = constant<index<0>>
// | parameter<index<0>>
// | grouping<index<0>>
// | entry<index<0>>
bool match_value(std::unique_ptr<value_node<boolean<0>>>&);
// value<boolean<0>> = disjunction
bool match_disjunction(std::unique_ptr<value_node<boolean<0>>>&);
// disjunction = conjunction ( PIPE conjunction )*
bool match_conjunction(std::unique_ptr<value_node<boolean<0>>>&);
// conjunction = unary<boolean<0>> ( AND unary<boolean<0>> )*
bool match_unary(std::unique_ptr<value_node<boolean<0>>>&);
// unary<boolean<0>> = negation
// | primary<boolean<0>>
bool match_negation(std::unique_ptr<value_node<boolean<0>>>&);
// negation = BANG unary<boolean<0>>
bool match_primary(std::unique_ptr<value_node<boolean<0>>>&);
// primary<boolean<0>> = constant<boolean<0>>
// | parameter<boolean<0>>
// | comparison<real<0>>
// | comparison<index<0>>
// | element
// | any_quantifier
// | grouping<boolean<0>>
bool match_element(std::unique_ptr<value_node<boolean<0>>>&);
// element = value<real<0>> "in" value<set<real<0>>>
bool match_primary(std::unique_ptr<value_node<set<real<0>, 0>>>&);
// primary<set<real<0>>> = constant<set<real<0>>>
// | parameter<set<real<0>>>
// | entry<set<real<0>>>
// | indicator_set<set<real<0>>>
bool match_primary(std::unique_ptr<value_node<set<index<0>, 0>>>&);
// primary<set<index<0>>> = constant<set<index<0>>>
// | parameter<set<index<0>>>
// | entry<set<index<0>>>
// | indicator_set<set<index<0>>>
// token handling
lexer lex;
......
......@@ -13,6 +13,7 @@
#include "value.hpp"
#include <limits>
#include <string>
#include <variant>
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment