axis.h

Go to the documentation of this file.

/*1:*/
#line 40 "axis.w"
#ifndef EVALUATOR_H
#define EVALUATOR_H

#include "axis-types.h"/*61:*/
#line 1589 "axis.w"
#include "global.h" /*:61*/
#line 45 "axis.w"

namespace atlas{namespace interpreter{/*7:*/
#line 211 "axis.w"
class layer
{
typedef containers::simple_list<layer* >list;
public:
typedef std::vector<std::pair<id_type,type_expr> >vec;
static list lexical_context;
private:
vec variable;
BitMap constness;
const unsigned loop_depth;
const type_p return_type;

public:
layer(const layer&)=delete;
layer&operator=(const layer&)=delete;
layer(size_t n);
layer(size_t n,type_p return_type);

~layer(){lexical_context.pop_front();}

void add(id_type id,type_expr&&t,bool is_const);
static const_type_p lookup
(id_type id,size_t&depth,size_t&offset,bool&is_const);
static void specialise(size_t depth,size_t offset,const type_expr&t);

bool empty()const{return variable.empty();}
std::pair<id_type,type_expr> &operator[](size_t i)
{return variable[i];}
vec::iterator begin(){return variable.begin();}
vec::iterator end(){return variable.end();}
vec::const_iterator cbegin()const{return variable.begin();}
vec::const_iterator cend()const{return variable.end();}
bool is_const(vec::const_iterator it)const
{return constness.isMember(it-cbegin());}
static bool may_break(unsigned depth)
{return not lexical_context.empty()
and lexical_context.front()->loop_depth>depth;}
static bool may_return()
{return not lexical_context.empty()
and lexical_context.front()->return_type!=nullptr;}
static type_expr&current_return_type()
{return*lexical_context.front()->return_type;}
};/*:7*//*14:*/
#line 400 "axis.w"
struct denotation:public expression_base
{shared_value denoted_value;

explicit denotation(const shared_value&v):denoted_value(v){}
explicit denotation(shared_value&&v):denoted_value(std::move(v)){}
virtual void evaluate(level l)const{push_expanded(l,denoted_value);}
virtual void print(std::ostream&out)const
{denoted_value->print(out);}
};/*:14*//*18:*/
#line 465 "axis.w"
class capture_expression:public denotation
{std::string print_name;
public:
capture_expression(const shared_value&v,const std::string&name)
:denotation(v),print_name(name){}
virtual void print(std::ostream&out)const{out<<print_name;}
};/*:18*//*20:*/
#line 505 "axis.w"
struct shell:public expression_base
{
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const{out<<" die ";}
};/*:20*//*23:*/
#line 530 "axis.w"
struct breaker:public expression_base
{unsigned depth;
breaker(unsigned depth):depth(depth){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{out<<" break ";
if(depth>0)
out<<depth<<' ';
}
};/*:23*//*26:*/
#line 564 "axis.w"
struct returner:public expression_base
{expression_ptr exp;
returner(expression_ptr&&exp):exp(std::move(exp)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{out<<" return "<< *exp;}
};/*:26*//*29:*/
#line 610 "axis.w"
struct tuple_expression:public expression_base
{std::vector<expression_ptr>component;

#ifdef incompletecpp11
explicit tuple_expression(size_t n):component()

{component.reserve(n);
while(n-- >0)
component.push_back(expression_ptr());
}
#else
explicit tuple_expression(size_t n):component(n){}
#endif

virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:29*//*33:*/
#line 748 "axis.w"
struct list_expression:public tuple_expression
{explicit list_expression(size_t n):tuple_expression(n){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:33*//*42:*/
#line 1029 "axis.w"
#ifdef incompletecpp11
#define nothing_new_here {} 
#else
#define nothing_new_here =default
#endif

struct identifier:public expression_base
{id_type code;

explicit identifier(id_type id):code(id){}
virtual~identifier()nothing_new_here;
const char*name()const;
virtual void print(std::ostream&out)const;
};/*:42*//*44:*/
#line 1067 "axis.w"
class global_identifier:public identifier
{const shared_share address;
public:
explicit global_identifier(id_type id);
virtual~global_identifier()nothing_new_here;
virtual void evaluate(level l)const;
};/*:44*//*48:*/
#line 1141 "axis.w"
class local_identifier:public identifier
{size_t depth,offset;
public:
explicit local_identifier(id_type id,size_t i,size_t j)
:identifier(id),depth(i),offset(j){}
virtual void evaluate(level l)const;
};/*:48*//*57:*/
#line 1502 "axis.w"
struct call_base:public expression_base
{expression_ptr argument;
source_location loc;

call_base(expression_ptr&&arg,const source_location&loc)
:expression_base(),argument(arg.release()),loc(loc){}
virtual~call_base()nothing_new_here;
virtual std::string function_name()const=0;
};/*:57*//*58:*/
#line 1525 "axis.w"



struct function_base:public value_base
{
function_base():value_base(){}
virtual~function_base()nothing_new_here;
virtual void apply(expression_base::level l)const=0;

virtual expression_base::level argument_policy()const=0;

virtual void report_origin(std::ostream&o)const=0;

virtual expression_ptr build_call
(const shared_function&owner,const std::string&name,
expression_ptr&&arg,const source_location&loc)const=0;
};/*:58*//*59:*/
#line 1553 "axis.w"
struct call_expression:public call_base
{expression_ptr function;

call_expression
(expression_ptr&&f,expression_ptr&&a,const source_location&loc)
:call_base(std::move(a),loc),function(f.release()){}
virtual~call_expression()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
virtual std::string function_name()const

{std::ostringstream o;o<< *function;return o.str();}

};/*:59*//*62:*/
#line 1612 "axis.w"
template<bool variadic>
struct builtin_value:public function_base
{wrapper_function val;
std::string print_name;

builtin_value(wrapper_function v,const std::string&n)
:function_base(),val(v),print_name(n){}
virtual~builtin_value()nothing_new_here;
virtual void print(std::ostream&out)const
{out<<'{'<<print_name<<'}';}
virtual void apply(expression_base::level l)const
{(*val)(l);}
virtual expression_base::level argument_policy()const
{return variadic
?expression_base::single_value:expression_base::multi_value;}
virtual void report_origin(std::ostream&o)const
{o<<"built-in";}
virtual expression_ptr build_call
(const shared_function&owner,const std::string&name,
expression_ptr&&arg,const source_location&loc)const;

virtual builtin_value*clone()const{return new builtin_value(*this);}
static const char*name(){return "built-in function";}
private:
builtin_value(const builtin_value&v)=default;
};
typedef std::shared_ptr<const builtin_value<false> >shared_builtin;
typedef std::shared_ptr<const builtin_value<true> >shared_variadic_builtin;/*:62*//*63:*/
#line 1652 "axis.w"
struct overloaded_call:public call_base
{std::string name;

overloaded_call
(const std::string&name,
expression_ptr&&arg,
const source_location&loc)
:call_base(std::move(arg),loc),name(name){}
virtual~overloaded_call()nothing_new_here;
virtual std::string function_name()const{return name;}
virtual void print(std::ostream&out)const;
};/*:63*//*65:*/
#line 1693 "axis.w"
template<bool variadic>
struct overloaded_builtin_call:public overloaded_call
{typedef std::shared_ptr<const builtin_value<variadic> >ptr_to_builtin;

ptr_to_builtin f;

wrapper_function f_ptr;

overloaded_builtin_call
(const ptr_to_builtin&fun,
const std::string&name,
expression_ptr&&arg,
const source_location&loc)
:overloaded_call(name,std::move(arg),loc),f(fun),f_ptr(fun->val){}
overloaded_builtin_call
(const ptr_to_builtin&fun,
expression_ptr&&arg,
const source_location&loc)
:overloaded_call(fun->print_name,std::move(arg),loc)
,f(fun),f_ptr(fun->val){}
virtual~overloaded_builtin_call()nothing_new_here;
virtual void evaluate(level l)const;
};

typedef overloaded_builtin_call<false>builtin_call;
typedef overloaded_builtin_call<true>variadic_builtin_call;/*:65*//*81:*/
#line 2214 "axis.w"
struct let_expression:public expression_base
{const id_pat variable;
expression_ptr initialiser,body;

let_expression(const id_pat&v,expression_ptr&&ini,expression_ptr&&b);
virtual~let_expression()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:81*//*94:*/
#line 2492 "axis.w"
struct lambda_struct
{id_pat param;expression_ptr body;source_location loc;
lambda_struct
(id_pat&&param,expression_ptr&&body,const source_location&loc)
:param(std::move(param)),body(std::move(body)),loc(loc){}
};
typedef std::shared_ptr<lambda_struct>shared_lambda;

struct lambda_expression:public expression_base
{shared_lambda p;

lambda_expression
(const id_pat&p,expression_ptr&&b,const source_location&loc);
virtual~lambda_expression()nothing_new_here;

virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:94*//*98:*/
#line 2636 "axis.w"
struct closure_value:public function_base
{shared_context context;
shared_lambda p;
const expression_base&body;

closure_value(const shared_context&c,const shared_lambda&l)
:function_base(),context(c),p(l),body(*p->body){}
virtual~closure_value()nothing_new_here;
virtual void print(std::ostream&out)const;
virtual void apply(expression_base::level l)const;
virtual expression_base::level argument_policy()const
{return expression_base::single_value;}
virtual void report_origin(std::ostream&o)const
{o<<"defined "<<p->loc;}
virtual expression_ptr build_call
(const shared_function&owner,const std::string&name,
expression_ptr&&arg,const source_location&loc)const;

virtual closure_value*clone()const
{return new closure_value(context,p);}
static const char*name(){return "closure";}
};
typedef std::unique_ptr<closure_value>closure_ptr;
typedef std::shared_ptr<const closure_value>shared_closure;/*:98*//*103:*/
#line 2789 "axis.w"
struct closure_call:public overloaded_call
{shared_closure f;

closure_call
(shared_closure f,const std::string&n,expression_ptr&&a
,const source_location&loc)
:overloaded_call(n,std::move(a),loc),f(f){}
virtual~closure_call()nothing_new_here;
virtual void evaluate(level l)const;
};/*:103*//*108:*/
#line 2935 "axis.w"
struct seq_expression:public expression_base
{expression_ptr first,last;

seq_expression(expression_ptr&&f,expression_ptr&&l)
:first(f.release()),last(l.release()){}
virtual~seq_expression()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};

struct next_expression:public expression_base
{expression_ptr first,last;

next_expression(expression_ptr&&f,expression_ptr&&l)
:first(f.release()),last(l.release()){}
virtual~next_expression()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:108*//*113:*/
#line 3022 "axis.w"
struct subscr_base:public expression_base
{enum sub_type
{row_entry,vector_entry,ratvec_entry,string_char
,matrix_entry,matrix_column,mod_poly_term,not_so};
expression_ptr array,index;

subscr_base(expression_ptr&&a,expression_ptr&&i)
:array(a.release())
,index(i.release())
{}
virtual~subscr_base()nothing_new_here;

void print(std::ostream&out,bool reversed)const;
static sub_type index_kind
(const type_expr&aggr,
const type_expr&index,
type_expr&subscr);
static sub_type slice_kind(const type_expr&aggr);
static bool assignable(sub_type);
};

struct slice_base:public expression_base
{expression_ptr array,lower,upper;

slice_base(expression_ptr&&a,expression_ptr&&l,expression_ptr&&u)
:array(a.release())
,lower(l.release())
,upper(u.release())
{}
virtual~slice_base()nothing_new_here;

void print(std::ostream&out,unsigned flags)const;
};/*:113*//*114:*/
#line 3061 "axis.w"
template<bool reversed>
struct row_subscription:public subscr_base
{row_subscription(expression_ptr&&a,expression_ptr&&i)
:subscr_base(std::move(a),std::move(i)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{subscr_base::print(out,reversed);}
};


template<bool reversed>
struct vector_subscription:public subscr_base
{vector_subscription(expression_ptr&&a,expression_ptr&&i)
:subscr_base(std::move(a),std::move(i)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{subscr_base::print(out,reversed);}
};

template<bool reversed>
struct ratvec_subscription:public subscr_base
{ratvec_subscription(expression_ptr&&a,expression_ptr&&i)
:subscr_base(std::move(a),std::move(i)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{subscr_base::print(out,reversed);}
};

template<bool reversed>
struct string_subscription:public subscr_base
{string_subscription(expression_ptr&&a,expression_ptr&&i)
:subscr_base(std::move(a),std::move(i)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{subscr_base::print(out,reversed);}
};

template<bool reversed>
struct matrix_subscription:public subscr_base
{matrix_subscription(expression_ptr&&a,expression_ptr&&ij)
:subscr_base(std::move(a),std::move(ij)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};

template<bool reversed>
struct matrix_get_column:public subscr_base
{matrix_get_column(expression_ptr&&a,expression_ptr&&j)
:subscr_base(std::move(a),std::move(j)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{subscr_base::print(out,reversed);}
};

struct module_coefficient:public subscr_base
{module_coefficient(expression_ptr&&pol,expression_ptr&&param)
:subscr_base(std::move(pol),std::move(param)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{out<< *array<<'['<<']';}
};/*:114*//*115:*/
#line 3130 "axis.w"
template<unsigned flags>
struct row_slice:public slice_base
{row_slice(expression_ptr&&a,expression_ptr&&l,expression_ptr&&u)
:slice_base(std::move(a),std::move(l),std::move(u)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{slice_base::print(out,flags);}
};


template<unsigned flags>
struct vector_slice:public slice_base
{vector_slice(expression_ptr&&a,expression_ptr&&l,expression_ptr&&u)
:slice_base(std::move(a),std::move(l),std::move(u)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{slice_base::print(out,flags);}
};

template<unsigned flags>
struct ratvec_slice:public slice_base
{ratvec_slice(expression_ptr&&a,expression_ptr&&l,expression_ptr&&u)
:slice_base(std::move(a),std::move(l),std::move(u)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{slice_base::print(out,flags);}
};

template<unsigned flags>
struct string_slice:public slice_base
{string_slice(expression_ptr&&a,expression_ptr&&l,expression_ptr&&u)
:slice_base(std::move(a),std::move(l),std::move(u)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{slice_base::print(out,flags);}
};

template<unsigned flags>
struct matrix_slice:public slice_base
{matrix_slice(expression_ptr&&a,expression_ptr&&l,expression_ptr&&u)
:slice_base(std::move(a),std::move(l),std::move(u)){}
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const
{slice_base::print(out,flags);}
};/*:115*//*130:*/
#line 3709 "axis.w"
struct projector_value:public function_base
{type_expr type;
unsigned position;
id_type id;
source_location loc;

projector_value
(const type_expr&t,unsigned i,id_type id,const source_location&loc)
:type(t.copy()),position(i),id(id),loc(loc){}
virtual~projector_value()nothing_new_here;
virtual void print(std::ostream&out)const;
virtual void apply(expression_base::level l)const;
virtual expression_base::level argument_policy()const;
virtual void report_origin(std::ostream&o)const;
virtual expression_ptr build_call
(const shared_function&owner,const std::string&name,
expression_ptr&&arg,const source_location&loc)const;

virtual projector_value*clone()const
{return new projector_value(*this);}
static const char*name(){return "built-in function";}
private:
projector_value(const projector_value&v)
:type(v.type.copy()),position(v.position),loc(v.loc){}
};/*:130*//*133:*/
#line 3760 "axis.w"
struct projector_call:public overloaded_call
{unsigned position;id_type id;

projector_call
(const projector_value&f,const std::string&n,expression_ptr&&a
,const source_location&loc)
:overloaded_call(n,std::move(a),loc),position(f.position),id(f.id){}
virtual~projector_call()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:133*//*139:*/
#line 3901 "axis.w"
struct conditional_expression:public expression_base
{expression_ptr condition,then_branch,else_branch;

conditional_expression
(expression_ptr&&c,expression_ptr&&t,expression_ptr&&e)
:condition(c.release()),then_branch(t.release()),else_branch(e.release())
{}
virtual~conditional_expression()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:139*//*143:*/
#line 3970 "axis.w"
struct int_case_expression:public expression_base
{expression_ptr condition;std::vector<expression_ptr>branches;

int_case_expression
(expression_ptr&&c,std::vector<expression_ptr> &&b)
:condition(c.release()),branches(std::move(b))
{}
virtual~int_case_expression()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:143*//*148:*/
#line 4055 "axis.w"
template<unsigned flags>
struct while_expression:public expression_base
{expression_ptr body;
while_expression(expression_ptr&&b):body(std::move(b)){}
virtual~while_expression()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:148*//*154:*/
#line 4161 "axis.w"
template<bool negated>
struct do_expression:public expression_base
{expression_ptr condition,body;

do_expression(expression_ptr&&c,expression_ptr&&b)
:condition(c.release()),body(b.release()){}
virtual~do_expression()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:154*//*155:*/
#line 4179 "axis.w"
struct forever_expression:public expression_base
{expression_ptr body;

forever_expression(expression_ptr&&b):body(b.release()){}
virtual~forever_expression()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};
struct dont_expression:public expression_base
{dont_expression(){}
virtual~dont_expression()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:155*//*161:*/
#line 4398 "axis.w"
template<unsigned flags,subscr_base::sub_type kind>
struct for_expression:public expression_base
{id_pat pattern;expression_ptr in_part;
expression_ptr body;

for_expression(const id_pat&p,expression_ptr&&i,expression_ptr&&b);
virtual~for_expression()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:161*//*174:*/
#line 4850 "axis.w"
template<unsigned flags>
struct counted_for_expression:public expression_base
{id_type id;
expression_ptr count,bound,body;


counted_for_expression
(id_type i,expression_ptr&&cnt,expression_ptr&&bnd,
expression_ptr&&b)
:id(i),count(cnt.release()),bound(bnd.release()),body(b.release())
{}
virtual~counted_for_expression()nothing_new_here;
virtual void evaluate(level l)const;
virtual void print(std::ostream&out)const;
};/*:174*//*188:*/
#line 5310 "axis.w"
struct assignment_expr:public expression_base
{id_type lhs;
expression_ptr rhs;

assignment_expr(id_type l,expression_ptr&&r)
:lhs(l),rhs(r.release()){}
virtual~assignment_expr()nothing_new_here;
virtual void print(std::ostream&out)const;
};/*:188*//*190:*/
#line 5330 "axis.w"
class global_assignment:public assignment_expr
{shared_share address;
public:
global_assignment(id_type l,expression_ptr&&r);
virtual~global_assignment()nothing_new_here;
virtual void evaluate(level l)const;
};/*:190*//*193:*/
#line 5364 "axis.w"
class local_assignment:public assignment_expr
{size_t depth,offset;
public:
local_assignment(id_type l,size_t i,size_t j,expression_ptr&&r);
virtual~local_assignment()nothing_new_here;
virtual void evaluate(level l)const;
};/*:193*//*196:*/
#line 5405 "axis.w"
class multiple_assignment:public expression_base
{
public:
struct local_dest{size_t depth,offset;};
typedef containers::simple_list<local_dest>loc_list;
typedef containers::simple_list<shared_share>glob_list;
private:
id_pat lhs;
expression_ptr rhs;
loc_list locals;
glob_list globals;
BitMap is_global;
public:
multiple_assignment
(const id_pat&lhs,expression_ptr&&r
,loc_list&&ll,glob_list&&gl,BitMap&&bm);
virtual~multiple_assignment()nothing_new_here;
virtual void print(std::ostream&out)const;
virtual void evaluate(level l)const;
};/*:196*//*212:*/
#line 5792 "axis.w"
template<bool reversed>
struct component_assignment:public assignment_expr
{expression_ptr index;

component_assignment
(id_type a,expression_ptr&&i,expression_ptr&&r)
:assignment_expr(a,std::move(r)),index(i.release()){}
virtual~component_assignment()nothing_new_here;

virtual void print(std::ostream&out)const;

void assign(level l,shared_value&aggregate,subscr_base::sub_type kind)const;
};/*:212*//*214:*/
#line 5818 "axis.w"
template<bool reversed>
class global_component_assignment:public component_assignment<reversed>
{typedef component_assignment<reversed>base;

subscr_base::sub_type kind;
shared_share address;
public:
global_component_assignment
(id_type a,expression_ptr&&i,expression_ptr&&r,
subscr_base::sub_type k);
virtual void evaluate(expression_base::level l)const;
};/*:214*//*222:*/
#line 5981 "axis.w"
template<bool reversed>
class local_component_assignment:public component_assignment<reversed>
{typedef component_assignment<reversed>base;

subscr_base::sub_type kind;
size_t depth,offset;
public:
local_component_assignment
(id_type arr,expression_ptr&&i,size_t d,size_t o,
expression_ptr&&r,subscr_base::sub_type k);
virtual void evaluate(expression_base::level l)const;
};/*:222*//*16:*/
#line 445 "axis.w"
extern type_expr last_type;
extern shared_value last_value;/*:16*//*3:*/
#line 75 "axis.w"
void reset_evaluator();/*:3*//*6:*/
#line 179 "axis.w"
expression_ptr convert_expr(const expr&e,type_expr&type);/*:6*//*51:*/
#line 1230 "axis.w"
expression_ptr resolve_overload
(const expr&e,
type_expr&type,
const overload_table::variant_list&variants);/*:51*//*84:*/
#line 2253 "axis.w"
type_expr pattern_type(const id_pat&pat);
size_t count_identifiers(const id_pat&pat);
void list_identifiers(const id_pat&pat,std::vector<id_type> &d);
void thread_bindings
(const id_pat&pat,const type_expr&type,layer&dst,bool is_const);
void thread_components
(const id_pat&pat,const shared_value&val,
std::back_insert_iterator<std::vector<shared_value> >dst);/*:84*/
#line 49 "axis.w"

}}
#endif/*:1*/