parse_types.h

Go to the documentation of this file.

/*1:*/
#line 39 "parsetree.w"
#ifndef PARSE_TYPES_H
#define PARSE_TYPES_H/*6:*/
#line 145 "parsetree.w"
#include "buffer.h" /*:6*//*38:*/
#line 602 "parsetree.w"
#include "sl_list.h" /*:38*//*101:*/
#line 1612 "parsetree.w"
#include "axis-types.h" /*:101*//*133:*/
#line 1915 "parsetree.w"
#include "bitset.h"/*:133*/
#line 41 "parsetree.w"

struct YYLTYPE;

namespace atlas
{
namespace interpreter
{/*4:*//*5:*/
#line 137 "parsetree.w"
struct expr;/*:5*//*7:*/
#line 152 "parsetree.w"
typedef Hash_table::id_type id_type;/*:7*//*8:*/
#line 159 "parsetree.w"
struct source_location
{unsigned int start_line;
unsigned short extent,first_col,last_col;
id_type file;
source_location(const YYLTYPE&loc);
source_location():start_line(~0u){}

source_location
(const source_location&left,const source_location&right);

bool undefined()const{return start_line==~0u;}
};/*:8*//*39:*/
#line 617 "parsetree.w"
typedef containers::simple_list<expr>expr_list;
typedef containers::sl_node<expr> *raw_expr_list;


typedef containers::weak_sl_list_const_iterator<expr>wel_const_iterator;
typedef containers::weak_sl_list_iterator<expr>wel_iterator;/*:39*//*53:*/
#line 818 "parsetree.w"
typedef struct application_node*app;/*:53*//*82:*/
#line 1296 "parsetree.w"
typedef containers::simple_list<struct id_pat>patlist;
typedef containers::sl_node<struct id_pat> *raw_patlist;

struct raw_id_pat
{id_type name;
unsigned char kind;

raw_patlist sublist;
};
struct id_pat
{id_type name;
unsigned char kind;

patlist sublist;

id_pat():name(),kind(0x0),sublist(){}
explicit id_pat(const raw_id_pat&x)
:name(x.name),kind(x.kind)
,sublist((kind&0x2)==0?nullptr:x.sublist)
{}
id_pat(id_type n):name(n),kind(0x1),sublist(){}

id_pat(patlist&&l):name(),kind(0x2),sublist(std::move(l)){}

id_pat(id_type n,unsigned char k,patlist&&l)
:name(n),kind(k),sublist(std::move(l)){}

id_pat(const id_pat&x)=delete;
id_pat&operator=(const id_pat&x)=delete;
#ifdef incompletecpp11
id_pat(id_pat&&x)
:name(x.name),kind(x.kind),sublist(std::move(x.sublist)){}
id_pat&operator=(id_pat&&x)
{name=x.name;kind=x.kind;sublist=std::move(x.sublist);
return*this;
}
#else
id_pat(id_pat&&x)=default;
id_pat&operator=(id_pat&&x)=default;
#endif
raw_id_pat release()
{return{name,kind,sublist.release()};}
};/*:82*//*89:*/
#line 1428 "parsetree.w"
typedef struct let_expr_node*let;/*:89*//*104:*/
#line 1632 "parsetree.w"
typedef struct lambda_node*lambda;/*:104*//*115:*/
#line 1742 "parsetree.w"
typedef struct conditional_node*cond;/*:115*//*132:*/
#line 1907 "parsetree.w"
typedef struct while_node*w_loop;
typedef struct for_node*f_loop;
typedef struct cfor_node*c_loop;/*:132*//*143:*/
#line 2092 "parsetree.w"
typedef struct subscription_node*sub;
typedef struct slice_node*slc;/*:143*//*153:*/
#line 2225 "parsetree.w"
typedef struct cast_node*cast;/*:153*//*163:*/
#line 2293 "parsetree.w"
typedef struct op_cast_node*op_cast;/*:163*//*173:*/
#line 2362 "parsetree.w"
typedef struct assignment_node*assignment;/*:173*//*183:*/
#line 2456 "parsetree.w"
typedef struct comp_assignment_node*comp_assignment;/*:183*//*196:*/
#line 2637 "parsetree.w"
typedef struct sequence_node*sequence;/*:196*/
#line 117 "parsetree.w"


enum expr_kind
{/*23:*/
#line 378 "parsetree.w"
integer_denotation,string_denotation,boolean_denotation,/*:23*//*30:*/
#line 501 "parsetree.w"
applied_identifier,
last_value_computed,break_expr,return_expr,
die_expr,/*:30*//*41:*/
#line 638 "parsetree.w"
tuple_display,list_display,/*:41*//*55:*/
#line 841 "parsetree.w"
function_call,/*:55*//*66:*/
#line 1004 "parsetree.w"
negation_expr,/*:66*//*91:*/
#line 1464 "parsetree.w"
let_expr,/*:91*//*106:*/
#line 1652 "parsetree.w"
lambda_expr,/*:106*//*117:*/
#line 1769 "parsetree.w"
conditional_expr,/*:117*//*125:*/
#line 1840 "parsetree.w"
int_case_expr,/*:125*//*135:*/
#line 1967 "parsetree.w"
while_expr,for_expr,cfor_expr,/*:135*//*145:*/
#line 2121 "parsetree.w"
subscription,slice,/*:145*//*155:*/
#line 2242 "parsetree.w"
cast_expr,/*:155*//*165:*/
#line 2311 "parsetree.w"
op_cast_expr,/*:165*//*175:*/
#line 2390 "parsetree.w"
ass_stat,/*:175*//*185:*/
#line 2485 "parsetree.w"
comp_ass_stat,/*:185*//*198:*/
#line 2663 "parsetree.w"
seq_expr,next_expr,do_expr,/*:198*/
#line 120 "parsetree.w"
no_expr};
typedef struct expr*expr_p;
struct expr{
expr_kind kind;
union{/*22:*/
#line 367 "parsetree.w"
int int_denotation_variant;
bool bool_denotation_variant;
#ifdef incompletecpp11
const char*str_denotation_variant;
#else
std::string str_denotation_variant;
#endif/*:22*//*31:*/
#line 509 "parsetree.w"
id_type identifier_variant;
unsigned break_variant;
expr_p return_variant;/*:31*//*40:*/
#line 629 "parsetree.w"
raw_expr_list sublist;/*:40*//*56:*/
#line 847 "parsetree.w"
app call_variant;/*:56*//*67:*/
#line 1008 "parsetree.w"
expr*negation_variant;/*:67*//*92:*/
#line 1470 "parsetree.w"
let let_variant;/*:92*//*107:*/
#line 1656 "parsetree.w"
lambda lambda_variant;/*:107*//*118:*/
#line 1775 "parsetree.w"
cond if_variant;/*:118*//*136:*/
#line 1973 "parsetree.w"
w_loop while_variant;
f_loop for_variant;
c_loop cfor_variant;/*:136*//*146:*/
#line 2126 "parsetree.w"
sub subscription_variant;
slc slice_variant;/*:146*//*156:*/
#line 2246 "parsetree.w"
cast cast_variant;/*:156*//*166:*/
#line 2315 "parsetree.w"
op_cast op_cast_variant;/*:166*//*176:*/
#line 2394 "parsetree.w"
assignment assign_variant;/*:176*//*186:*/
#line 2489 "parsetree.w"
comp_assignment comp_assign_variant;/*:186*//*199:*/
#line 2667 "parsetree.w"
sequence sequence_variant;/*:199*/
#line 124 "parsetree.w"
};
source_location loc;/*13:*/
#line 243 "parsetree.w"
expr():kind(no_expr),loc(){}
expr(const expr&x)=delete;
expr&operator=(const expr&x)=delete;
~expr();/*:13*//*17:*/
#line 284 "parsetree.w"
void set_from(expr&other);
expr(expr&&other);
void operator=(expr&&other);
void swap(expr&other);/*:17*//*24:*/
#line 391 "parsetree.w"
struct int_tag{};
struct bool_tag{};
expr(int n,const YYLTYPE&loc,int_tag)
:kind(integer_denotation),int_denotation_variant(n),loc(loc){}
expr(bool b,const YYLTYPE&loc,bool_tag)
:kind(boolean_denotation),bool_denotation_variant(b),loc(loc){}
expr(std::string&&s,const YYLTYPE&loc)
:kind(string_denotation)
#ifdef incompletecpp11
,str_denotation_variant(std::strcpy(new char[s.size()+1],s.c_str()))
#else
,str_denotation_variant(std::move(s))
#endif
,loc(loc){}/*:24*//*32:*/
#line 517 "parsetree.w"
struct identifier_tag{};
struct dollar_tag{};
struct break_tag{unsigned depth;};
struct return_tag{};
struct die_tag{};

expr(id_type id,const YYLTYPE&loc,identifier_tag)
:kind(applied_identifier),identifier_variant(id),loc(loc){}
expr(const YYLTYPE&loc,dollar_tag)
:kind(last_value_computed),loc(loc){}
expr(const YYLTYPE&loc,break_tag t)
:kind(break_expr),break_variant(t.depth),loc(loc){}
expr(expr_p exp,const YYLTYPE&loc,return_tag t)
:kind(return_expr),return_variant(exp),loc(loc){}
expr(const YYLTYPE&loc,die_tag)
:kind(die_expr),loc(loc){}/*:32*//*42:*/
#line 649 "parsetree.w"
struct tuple_display_tag{};struct list_display_tag{};
expr(expr_list&&nodes,tuple_display_tag,const YYLTYPE&loc)
:kind(tuple_display)
,sublist(nodes.release())
,loc(loc)
{}
expr(expr_list&&nodes,list_display_tag,const YYLTYPE&loc)
:kind(list_display)
,sublist(nodes.release())
,loc(loc)
{}
expr(expr_list&&nodes,tuple_display_tag,const source_location&loc)
:kind(tuple_display)
,sublist(nodes.release())
,loc(loc)
{}
expr(expr_list&&nodes,tuple_display_tag);/*:42*//*57:*/
#line 856 "parsetree.w"
expr(app&&fx,const YYLTYPE&loc)
:kind(function_call)
,call_variant(std::move(fx))
,loc(loc)
{}
expr(app&&fx,const source_location&loc)
:kind(function_call)
,call_variant(std::move(fx))
,loc(loc)
{}/*:57*//*68:*/
#line 1012 "parsetree.w"
struct negate_tag{};
expr(expr*p,const YYLTYPE&loc,negate_tag)
:kind(negation_expr)
,negation_variant(p)
,loc(loc)
{}/*:68*//*93:*/
#line 1474 "parsetree.w"
expr(let&&declaration,const YYLTYPE&loc)
:kind(let_expr)
,let_variant(std::move(declaration))
,loc(loc)
{}/*:93*//*108:*/
#line 1660 "parsetree.w"
expr(lambda&&fun,const YYLTYPE&loc)
:kind(lambda_expr)
,lambda_variant(std::move(fun))
,loc(loc)
{}/*:108*//*119:*/
#line 1781 "parsetree.w"
expr(expr_kind which,cond&&conditional,const YYLTYPE&loc)
:kind(which)
,if_variant(std::move(conditional))
,loc(loc)
{}/*:119*//*137:*/
#line 1979 "parsetree.w"
expr(w_loop&&loop,const YYLTYPE&loc)
:kind(while_expr)
,while_variant(std::move(loop))
,loc(loc)
{}
expr(f_loop&&loop,const YYLTYPE&loc)
:kind(for_expr)
,for_variant(std::move(loop))
,loc(loc)
{}
expr(c_loop&&loop,const YYLTYPE&loc)
:kind(cfor_expr)
,cfor_variant(std::move(loop))
,loc(loc)
{}/*:137*//*147:*/
#line 2132 "parsetree.w"
expr(sub&&s,const YYLTYPE&loc)
:kind(subscription)
,subscription_variant(std::move(s))
,loc(loc)
{}
expr(sub&&s,const source_location&loc)
:kind(subscription)
,subscription_variant(std::move(s))
,loc(loc)
{}
expr(slc&&s,const YYLTYPE&loc)
:kind(slice)
,slice_variant(std::move(s))
,loc(loc)
{}/*:147*//*157:*/
#line 2250 "parsetree.w"
expr(cast&&c,const YYLTYPE&loc)
:kind(cast_expr)
,cast_variant(std::move(c))
,loc(loc)
{}/*:157*//*167:*/
#line 2319 "parsetree.w"
expr(op_cast&&c,const YYLTYPE&loc)
:kind(op_cast_expr)
,op_cast_variant(std::move(c))
,loc(loc)
{}/*:167*//*177:*/
#line 2398 "parsetree.w"
expr(assignment&&a,const YYLTYPE&loc)
:kind(ass_stat)
,assign_variant(std::move(a))
,loc(loc)
{}/*:177*//*187:*/
#line 2493 "parsetree.w"
expr(comp_assignment&&ca,const YYLTYPE&loc)
:kind(comp_ass_stat)
,comp_assign_variant(std::move(ca))
,loc(loc)
{}/*:187*//*200:*/
#line 2671 "parsetree.w"
expr(sequence&&s,unsigned which,const YYLTYPE&loc)
:kind(which==0?seq_expr:which==1?next_expr:do_expr)
,sequence_variant(std::move(s))
,loc(loc)
{}/*:200*/
#line 127 "parsetree.w"

};
typedef std::unique_ptr<expr>expr_ptr;/*54:*/
#line 830 "parsetree.w"
struct application_node
{expr fun;expr arg;

application_node(expr&&fun,expr&&arg)
:fun(std::move(fun)),arg(std::move(arg)){}
};/*:54*//*75:*/
#line 1161 "parsetree.w"
struct formula_node{expr left_subtree;expr op_exp;int prio;
formula_node(expr&&l,expr&&o,int prio)
:left_subtree(std::move(l)),op_exp(std::move(o)),prio(prio){}
#ifdef incompletecpp11
formula_node(const formula_node&x)=delete;
formula_node operator=(const formula_node&x)=delete;
#endif
};

typedef containers::mirrored_simple_list<formula_node>form_stack;
typedef containers::sl_node<formula_node> *raw_form_stack;/*:75*//*90:*/
#line 1442 "parsetree.w"
struct let_pair{id_pat pattern;expr val;
#ifdef incompletecpp11
let_pair(const let_pair&)=delete;
let_pair&operator=(const let_pair&)=delete;
let_pair(let_pair&&x)
:pattern(std::move(x.pattern)),val(std::move(x.val)){}
let_pair(id_pat&&p,expr&&v)
:pattern(std::move(p)),val(std::move(v)){}
#endif
};
typedef containers::simple_list<let_pair>let_list;
typedef containers::sl_node<let_pair> *raw_let_list;

struct let_expr_node
{id_pat pattern;expr val;expr body;

let_expr_node(id_pat&&pattern,expr&&val,expr&&body)
:pattern(std::move(pattern)),val(std::move(val)),body(std::move(body)){}
};/*:90*//*105:*/
#line 1640 "parsetree.w"
struct lambda_node
{id_pat pattern;type_expr parameter_type;expr body;

lambda_node(id_pat&&pattern,type_expr&&type,expr&&body)
:pattern(std::move(pattern))
,parameter_type(std::move(type))
,body(std::move(body))
{}
};/*:105*//*116:*/
#line 1755 "parsetree.w"
struct conditional_node
{expr condition;containers::sl_node<expr>branches;

conditional_node(expr&&condition,expr&&then_branch,expr&&else_branch)
:condition(std::move(condition))
,branches(std::move(then_branch))
{branches.next.reset(new
containers::sl_node<expr>(std::move(else_branch)));
}/*126:*/
#line 1845 "parsetree.w"
conditional_node(expr&&condition,containers::sl_node<expr> &&branches)
:condition(std::move(condition))
,branches(std::move(branches))
{}/*:126*/
#line 1764 "parsetree.w"

};/*:116*//*134:*/
#line 1932 "parsetree.w"
struct while_node
{expr body;
BitSet<2>flags;

while_node(expr&&body,unsigned flags)
:body(std::move(body))
,flags(flags){}

};
struct for_node
{id_pat id;expr in_part;expr body;
BitSet<2>flags;

for_node(id_pat&&id,expr&&in_part,expr&&body,unsigned flags)
:id(std::move(id))
,in_part(std::move(in_part))
,body(std::move(body))
,flags(flags){}
};
struct cfor_node
{id_type id;expr count;expr bound;expr body;
BitSet<3>flags;

cfor_node
(id_type id,expr&&count,expr&&bound,expr&&body,unsigned flags)
:id(id)
,count(std::move(count))
,bound(std::move(bound))
,body(std::move(body))
,flags(flags){}
};/*:134*//*144:*/
#line 2100 "parsetree.w"
struct subscription_node
{expr array;expr index;bool reversed;

subscription_node(expr&&array,expr&&index,bool reversed)
:array(std::move(array))
,index(std::move(index))
,reversed(reversed){}
};
struct slice_node
{expr array;expr lower,upper;BitSet<3>flags;

slice_node(expr&&array,expr&&lower,expr&&upper,unsigned flags)
:array(std::move(array))
,lower(std::move(lower))
,upper(std::move(upper))
,flags(flags)
{}
};/*:144*//*154:*/
#line 2230 "parsetree.w"
struct cast_node
{type_expr type;expr exp;

cast_node(type_expr&&type,expr&&exp)
:type(std::move(type))
,exp(std::move(exp)){}

};/*:154*//*164:*/
#line 2299 "parsetree.w"
struct op_cast_node
{id_type oper;type_expr type;

op_cast_node(id_type oper,type_expr&&type)
:oper(oper)
,type(std::move(type)){}

};/*:164*//*174:*/
#line 2369 "parsetree.w"
struct assignment_node
{id_pat lhs;expr rhs;

assignment_node(id_type lhs,expr&&rhs)
:lhs(lhs)
,rhs(std::move(rhs)){}
assignment_node(id_pat&&lhs,expr&&rhs)
:lhs(std::move(lhs))
,rhs(std::move(rhs)){}
#ifdef incompletecpp11
assignment_node(const assignment_node&x)=delete;
assignment_node(assignment_node&&x)
:lhs(x.lhs)
,rhs(std::move(x.rhs))
{}
#endif
};/*:174*//*184:*/
#line 2462 "parsetree.w"
struct comp_assignment_node
{id_type aggr;expr index;expr rhs;bool reversed;

comp_assignment_node(id_type aggr,expr&&index,expr&&rhs,bool reversed)
:aggr(aggr)
,index(std::move(index))
,rhs(std::move(rhs))
,reversed(reversed)
{}
#ifdef incompletecpp11
comp_assignment_node(const comp_assignment_node&x)=delete;
comp_assignment_node(comp_assignment_node&&x)
:aggr(x.aggr)
,index(std::move(x.index))
,rhs(std::move(x.rhs))
,reversed(x.reversed)
{}
#endif
};/*:184*//*197:*/
#line 2646 "parsetree.w"
struct sequence_node
{expr first;expr last;

sequence_node(expr&&first,expr&&last)
:first(std::move(first))
,last(std::move(last)){}

};/*:197*//*:4*/
#line 48 "parsetree.w"

}
}
#endif/*:1*/