global.h

Go to the documentation of this file.

/*1:*/
#line 47 "global.w"
#ifndef GLOBAL_H
#define GLOBAL_H/*4:*/
#line 154 "global.w"
#include <map>
#include "parsetree.h" 
#include "axis-types.h" /*:4*//*57:*/
#line 1196 "global.w"
#include <string>
#include <sstream>/*:57*//*59:*/
#line 1232 "global.w"
#include "arithmetic.h"/*:59*//*65:*/
#line 1347 "global.w"
#include "../Atlas.h" 
#include "matrix.h" 
#include "ratvec.h" /*:65*/
#line 50 "global.w"

namespace atlas{namespace interpreter{/*3:*/
#line 119 "global.w"
typedef std::shared_ptr<shared_value>shared_share;
class id_data
{shared_share val;type_expr tp;bool is_constant;
public:
id_data(shared_share&&val,type_expr&&t,bool is_const)
:val(std::move(val)),tp(std::move(t)),is_constant(is_const){}
#ifdef incompletecpp11
id_data():val(),tp(),is_constant(false){}

id_data(const id_data&x):val(),tp(),is_constant(false){}

id_data&operator=(const id_data&x)=delete;
id_data(id_data&&x)
:val(std::move(x.val)),tp(std::move(x.tp)),is_constant(x.is_constant){}
id_data&operator=(id_data&&x)
{val=std::move(x.val);tp=std::move(x.tp);is_constant=x.is_constant;
return*this;
}
#else
id_data(id_data&&x)=default;
id_data&operator=(id_data&&x)=default;
#endif
void swap(id_data&x){val.swap(x.val);tp.swap(x.tp);}

const shared_share&value()const{return val;}
const type_expr&type()const{return tp;}
type_expr&type(){return tp;}

bool is_const()const{return is_constant;}
};/*:3*//*5:*/
#line 162 "global.w"
class Id_table
{typedef std::map<id_type,id_data>map_type;
map_type table;
public:
Id_table(const Id_table&)=delete;
Id_table&operator=(const Id_table&)=delete;
Id_table():table(){}

void add(id_type id,shared_value v,type_expr&&t,bool is_const);

void add_type_def(id_type id,type_expr&&t);
bool remove(id_type id);
shared_share address_of(id_type id);

bool present(id_type id)const
{return table.find(id)!=table.end();}
bool is_defined_type(id_type id)const;
const_type_p type_of(id_type id,bool&is_const)const;

void specialise(id_type id,const type_expr&type);

shared_value value_of(id_type id)const;

size_t size()const{return table.size();}
void print(std::ostream&)const;
};/*:5*//*14:*/
#line 373 "global.w"
class function_base;

typedef std::shared_ptr<const function_base>shared_function;


class overload_data
{shared_function val;func_type tp;
public:
overload_data(shared_function&&val,func_type&&t)
:val(std::move(val)),tp(std::move(t)){}
#ifdef incompletecpp11
overload_data(const overload_data&x)=delete;
overload_data&operator=(const overload_data&x)=delete;
overload_data(overload_data&&x)
:val(std::move(x.val)),tp(std::move(x.tp)){}
overload_data&operator=(overload_data&&x)
{val=std::move(x.val);tp=std::move(x.tp);return*this;}
#else
overload_data(overload_data&&x)=default;
overload_data&operator=(overload_data&&x)
=default;
#endif

const shared_function&value()const{return val;}
const func_type&type()const{return tp;}
};/*:14*//*15:*/
#line 425 "global.w"
class overload_table
{
public:
#ifdef incompletecpp11
class variant_list:public std::vector<overload_data>
{typedef std::vector<overload_data>Base;
public:
variant_list():Base(){}
variant_list(const variant_list&x)

:Base(){assert(x.size()==0);}
variant_list(variant_list&&x):Base(std::move(x)){}
variant_list&operator=(const variant_list&x)=delete;
};
#else
typedef std::vector<overload_data>variant_list;
#endif
typedef std::map<id_type,variant_list>map_type;
private:
map_type table;
public:
overload_table(const Id_table&)=delete;
overload_table&operator=(const Id_table&)=delete;
overload_table():table(){}

const variant_list&variants(id_type id)const;
size_t size()const{return table.size();}

void print(std::ostream&)const;

void add(id_type id,shared_function v,type_expr&&t);

bool remove(id_type id,const type_expr&arg_t);
};/*:15*//*60:*/
#line 1247 "global.w"
struct int_value:public value_base
{int val;

explicit int_value(int v):val(v){}
~int_value(){}
void print(std::ostream&out)const{out<<val;}
int_value*clone()const{return new int_value(*this);}
static const char*name(){return "integer";}
private:
int_value(const int_value&v):val(v.val){}
};

typedef std::shared_ptr<const int_value>shared_int;
typedef std::shared_ptr<int_value>own_int;

struct rat_value:public value_base
{Rational val;

explicit rat_value(Rational v):val(v){}
~rat_value(){}
void print(std::ostream&out)const{out<<val;}
rat_value*clone()const{return new rat_value(*this);}
static const char*name(){return "integer";}
private:
rat_value(const rat_value&v):val(v.val){}
};

typedef std::shared_ptr<const rat_value>shared_rat;
typedef std::shared_ptr<rat_value>own_rat;/*:60*//*61:*/
#line 1281 "global.w"
struct string_value:public value_base
{std::string val;

explicit string_value(const std::string&s):val(s){}
explicit string_value(std::string&&s):val(std::move(s)){}
template<typename I>string_value(I begin,I end):val(begin,end){}
~string_value(){}
void print(std::ostream&out)const{out<<'"'<<val<<'"';}
string_value*clone()const{return new string_value(*this);}
static const char*name(){return "string";}
private:
string_value(const string_value&v):val(v.val){}
};

typedef std::shared_ptr<const string_value>shared_string;
typedef std::shared_ptr<string_value>own_string;


struct bool_value:public value_base
{bool val;

explicit bool_value(bool v):val(v){}
~bool_value(){}
void print(std::ostream&out)const{out<<std::boolalpha<<val;}
bool_value*clone()const{return new bool_value(*this);}
static const char*name(){return "Boolean";}
private:
bool_value(const bool_value&v):val(v.val){}
};

typedef std::shared_ptr<const bool_value>shared_bool;/*:61*//*66:*/
#line 1359 "global.w"
struct vector_value:public value_base
{int_Vector val;

explicit vector_value(const std::vector<int> &v):val(v){}
explicit vector_value(std::vector<int> &&v):val(std::move(v)){}
template<typename I>vector_value(I begin,I end):val(begin,end){}
~vector_value(){}
virtual void print(std::ostream&out)const;
vector_value*clone()const{return new vector_value(*this);}
static const char*name(){return "vector";}
private:
vector_value(const vector_value&v):val(v.val){}
};

typedef std::shared_ptr<const vector_value>shared_vector;
typedef std::shared_ptr<vector_value>own_vector;/*:66*//*67:*/
#line 1381 "global.w"
struct matrix_value:public value_base
{int_Matrix val;

explicit matrix_value(const int_Matrix&v):val(v){}
explicit matrix_value(int_Matrix&&v):val(std::move(v)){}
~matrix_value(){}
virtual void print(std::ostream&out)const;
matrix_value*clone()const{return new matrix_value(*this);}
static const char*name(){return "matrix";}
private:
matrix_value(const matrix_value&v):val(v.val){}
};

typedef std::shared_ptr<const matrix_value>shared_matrix;
typedef std::shared_ptr<matrix_value>own_matrix;

struct rational_vector_value:public value_base
{RatWeight val;

explicit rational_vector_value(const RatWeight&v)
:val(v){val.normalize();}
explicit rational_vector_value(RatWeight&&v)
:val(std::move(v)){val.normalize();}
rational_vector_value(const int_Vector&v,int d)
:val(v,d){val.normalize();}
rational_vector_value(int_Vector&&v,int d)
:val(std::move(v),d){val.normalize();}
template<typename I>rational_vector_value(I begin,I end,int d)
:val(int_Vector(begin,end),d){val.normalize();}
~rational_vector_value(){}
virtual void print(std::ostream&out)const;
rational_vector_value*clone()const
{return new rational_vector_value(*this);}
static const char*name(){return "rational vector";}
private:
rational_vector_value(const rational_vector_value&v):val(v.val){}
};

typedef std::shared_ptr<const rational_vector_value>shared_rational_vector;
typedef std::shared_ptr<rational_vector_value>own_rational_vector;/*:67*//*77:*/
#line 1691 "global.w"
typedef void(*wrapper_function)(expression_base::level);/*:77*//*12:*/
#line 346 "global.w"
extern Id_table*global_id_table;/*:12*//*24:*/
#line 637 "global.w"
extern overload_table*global_overload_table;/*:24*//*33:*/
#line 769 "global.w"
extern std::ostream*output_stream;/*:33*//*43:*/
#line 980 "global.w"
extern bool clean;/*:43*//*55:*/
#line 1182 "global.w"
extern int verbosity;/*:55*//*62:*/
#line 1318 "global.w"
extern const shared_bool global_false,global_true;/*:62*//*11:*/
#line 342 "global.w"
std::ostream&operator<<(std::ostream&out,const Id_table&p);/*:11*//*23:*/
#line 631 "global.w"
std::ostream&operator<<(std::ostream&out,const overload_table&p);/*:23*//*26:*/
#line 654 "global.w"
void initialise_evaluator();/*:26*//*29:*/
#line 684 "global.w"
type_expr analyse_types(const expr&e,expression_ptr&p);/*:29*//*32:*/
#line 752 "global.w"
void global_set_identifier(const struct raw_id_pat&id,expr_p e,int overload);
void global_set_identifiers(const raw_let_list&d);
void global_declare_identifier(id_type id,type_p type);
void global_forget_identifier(id_type id);
void global_forget_overload(id_type id,type_p type);
void type_define_identifier
(id_type id,type_p type,raw_id_pat ip,const YYLTYPE&loc);
void show_ids();
void type_of_expr(expr_p e);
void show_overloads(id_type id);/*:32*//*78:*/
#line 1697 "global.w"
void install_function
(wrapper_function f,const char*name,const char*type_string);/*:78*//*94:*/
#line 2257 "global.w"
void sizeof_vector_wrapper(expression_base::level l);
void sizeof_ratvec_wrapper(expression_base::level l);
void sizeof_string_wrapper(expression_base::level l);
void matrix_ncols_wrapper(expression_base::level l);
void virtual_module_size_wrapper(expression_base::level l);/*:94*//*112:*/
#line 2939 "global.w"
void mm_prod_wrapper(expression_base::level);/*:112*//*117:*/
#line 3175 "global.w"
void transpose_mat_wrapper(expression_base::level);
void id_mat_wrapper(expression_base::level l);/*:117*//*58:*/
#line 1210 "global.w"
template<typename T>
std::string str(T n){std::ostringstream s;s<<n;return s.str();}
inline std::string str(unsigned char c)
{return str(static_cast<unsigned int>(c));}/*:58*//*64:*/
#line 1328 "global.w"
inline shared_bool whether(bool b){return b?global_true:global_false;}/*:64*/
#line 55 "global.w"

}}
#endif/*:1*/