Classes
struct	application_node

struct	assignment_expr

struct	assignment_node

struct	balance_error

struct	Block_value

struct	bool_value

struct	breaker

class	BufferedInput

struct	builtin_value

struct	call_base

struct	call_expression

class	capture_expression

struct	Cartan_class_value

struct	cast_node

struct	cfor_node

struct	closure_call

struct	closure_value

struct	comp_assignment_node

struct	component_assignment

struct	conditional_expression

struct	conditional_node

class	conversion

struct	conversion_info

struct	conversion_record

struct	counted_for_expression

struct	denotation

struct	do_expression

struct	dont_expression

struct	error_base

class	evaluation_context

struct	expr

struct	expr_error

struct	expression_base

struct	for_expression

struct	for_node

struct	forever_expression

struct	formula_node

struct	func_type

struct	function_base

struct	function_return

class	global_assignment

class	global_component_assignment

class	global_identifier

class	Hash_table

class	id_data

struct	id_pat

class	Id_table

struct	identifier

struct	inner_class_value

struct	int_case_expression

struct	int_value

struct	KGB_elt_value

struct	lambda_expression

struct	lambda_node

struct	lambda_struct

class	layer

struct	let_expr_node

struct	let_expression

struct	let_pair

class	Lexical_analyser

struct	Lie_type_value

struct	list_expression

class	local_assignment

class	local_component_assignment

class	local_identifier

struct	logic_error

struct	loop_break

struct	matrix_get_column

struct	matrix_slice

struct	matrix_subscription

struct	matrix_value

struct	module_coefficient

struct	module_parameter_value

class	multiple_assignment

struct	next_expression

struct	op_cast_node

class	overload_data

class	overload_table

struct	overloaded_builtin_call

struct	overloaded_call

struct	program_error

struct	projector_call

struct	projector_value

struct	rat_value

struct	rational_vector_value

struct	ratvec_slice

struct	ratvec_subscription

struct	raw_id_pat

struct	real_form_value

struct	returner

struct	root_datum_value

struct	row_slice

struct	row_subscription

struct	row_value

struct	runtime_error

struct	seq_expression

struct	sequence_node

struct	shell

struct	slice_base

struct	slice_node

struct	source_location

struct	split_int_value

class	String_pool

struct	string_slice

struct	string_subscription

struct	string_value

struct	subscr_base

struct	subscription_node

struct	tuple_expression

struct	tuple_value

struct	type_error

struct	type_expr

struct	user_interrupt

struct	value_base

struct	vector_slice

struct	vector_subscription

struct	vector_value

struct	virtual_module_value

class	voiding

struct	while_expression

struct	while_node

Typedefs
typedef std::shared_ptr< const Lie_type_value >	shared_Lie_type

typedef std::shared_ptr< Lie_type_value >	own_Lie_type

typedef std::unique_ptr< root_datum_value >	root_datum_ptr

typedef std::shared_ptr< const root_datum_value >	shared_root_datum

typedef std::shared_ptr< const inner_class_value >	shared_inner_class

typedef std::shared_ptr< const real_form_value >	shared_real_form

typedef std::shared_ptr< real_form_value >	own_real_form

typedef std::shared_ptr< const Cartan_class_value >	shared_Cartan_class

typedef std::unique_ptr< KGB_elt_value >	KGB_elt_ptr

typedef std::shared_ptr< const KGB_elt_value >	shared_KGB_elt

typedef std::shared_ptr< KGB_elt_value >	own_KGB_elt

typedef std::unique_ptr< Block_value >	Block_ptr

typedef std::shared_ptr< const Block_value >	shared_Block

typedef std::shared_ptr< Block_value >	own_Block

typedef std::unique_ptr< module_parameter_value >	module_parameter_ptr

typedef std::shared_ptr< const module_parameter_value >	shared_module_parameter

typedef std::shared_ptr< module_parameter_value >	own_module_parameter

typedef std::unique_ptr< split_int_value >	split_int_ptr

typedef std::shared_ptr< const split_int_value >	shared_split_int

typedef std::shared_ptr< split_int_value >	own_split_int

typedef std::unique_ptr< virtual_module_value >	virtual_module_ptr

typedef std::shared_ptr< const virtual_module_value >	shared_virtual_module

typedef std::shared_ptr< virtual_module_value >	own_virtual_module

typedef type_expr *	type_p

typedef const type_expr *	const_type_p

typedef std::unique_ptr< type_expr >	type_ptr

typedef containers::simple_list< type_expr >	type_list

typedef atlas::containers::sl_node< type_expr > *	raw_type_list

typedef containers::sl_list< type_expr >	dressed_type_list

typedef containers::weak_sl_list_const_iterator< type_expr >	wtl_const_iterator

typedef containers::weak_sl_list_iterator< type_expr >	wtl_iterator

typedef func_type *	func_type_p

typedef std::unique_ptr< func_type >	func_type_ptr

typedef value_base *	value

typedef std::shared_ptr< const value_base >	shared_value

typedef std::shared_ptr< value_base >	own_value

typedef std::shared_ptr< const row_value >	shared_row

typedef std::shared_ptr< row_value >	own_row

typedef std::unique_ptr< tuple_value >	tuple_ptr

typedef std::shared_ptr< const tuple_value >	shared_tuple

typedef std::shared_ptr< tuple_value >	own_tuple

typedef std::shared_ptr< class evaluation_context >	shared_context

typedef expression_base *	expression

typedef std::unique_ptr< expression_base >	expression_ptr

typedef std::shared_ptr< expression_base >	shared_expression

typedef std::shared_ptr< const builtin_value< false > >	shared_builtin

typedef std::shared_ptr< const builtin_value< true > >	shared_variadic_builtin

typedef overloaded_builtin_call< false >	builtin_call

typedef overloaded_builtin_call< true >	variadic_builtin_call

typedef std::shared_ptr< lambda_struct >	shared_lambda

typedef std::unique_ptr< closure_value >	closure_ptr

typedef std::shared_ptr< const closure_value >	shared_closure

typedef std::shared_ptr< shared_value >	shared_share

typedef std::shared_ptr< const function_base >	shared_function

typedef std::shared_ptr< const int_value >	shared_int

typedef std::shared_ptr< int_value >	own_int

typedef std::shared_ptr< const rat_value >	shared_rat

typedef std::shared_ptr< rat_value >	own_rat

typedef std::shared_ptr< const string_value >	shared_string

typedef std::shared_ptr< string_value >	own_string

typedef std::shared_ptr< const bool_value >	shared_bool

typedef std::shared_ptr< const vector_value >	shared_vector

typedef std::shared_ptr< vector_value >	own_vector

typedef std::shared_ptr< const matrix_value >	shared_matrix

typedef std::shared_ptr< matrix_value >	own_matrix

typedef std::shared_ptr< const rational_vector_value >	shared_rational_vector

typedef std::shared_ptr< rational_vector_value >	own_rational_vector

typedef void(*	wrapper_function) (expression_base::level)

typedef Hash_table::id_type	id_type

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

typedef struct application_node *	app

typedef containers::simple_list< struct id_pat >	patlist

typedef containers::sl_node< struct id_pat > *	raw_patlist

typedef struct let_expr_node *	let

typedef struct lambda_node *	lambda

typedef struct conditional_node *	cond

typedef struct while_node *	w_loop

typedef struct for_node *	f_loop

typedef struct cfor_node *	c_loop

typedef struct subscription_node *	sub

typedef struct slice_node *	slc

typedef struct cast_node *	cast

typedef struct op_cast_node *	op_cast

typedef struct assignment_node *	assignment

typedef struct comp_assignment_node *	comp_assignment

typedef struct sequence_node *	sequence

typedef struct expr *	expr_p

typedef std::unique_ptr< expr >	expr_ptr

typedef containers::mirrored_simple_list< formula_node >	form_stack

typedef containers::sl_node< formula_node > *	raw_form_stack

typedef containers::simple_list< let_pair >	let_list

typedef containers::sl_node< let_pair > *	raw_let_list

Enumerations
enum	type_tag { undetermined_type, primitive_type, row_type, tuple_type, function_type }

enum	primitive_tag { integral_type, rational_type, string_type, boolean_type, vector_type, matrix_type, rational_vector_type, complex_lie_type_type, root_datum_type, inner_class_type, real_form_type, Cartan_class_type, KGB_element_type, block_type, module_parameter_type, split_integer_type, virtual_module_type, nr_of_primitive_types }

enum	expr_kind { integer_denotation, string_denotation, boolean_denotation, applied_identifier, last_value_computed, break_expr, return_expr, die_expr, tuple_display, list_display, function_call, negation_expr, let_expr, lambda_expr, conditional_expr, int_case_expr, while_expr, for_expr, cfor_expr, subscription, slice, cast_expr, op_cast_expr, ass_stat, comp_ass_stat, seq_expr, next_expr, do_expr, no_expr }

Functions
void	initialise_builtin_types ()

void	virtual_module_size_wrapper (expression_base::level l)

type_ptr	acquire (const type_expr *t)

type_list	empty_tuple ()

type_list &	prefix (type_expr &&t, type_list &dst)

dressed_type_list &	prefix (type_expr &&t, dressed_type_list &dst)

std::ostream &	operator<< (std::ostream &out, const raw_type_list &l)

std::ostream &	operator<< (std::ostream &out, const func_type &f)

std::ostream &	operator<< (std::ostream &out, const type_expr &t)

bool	operator== (const type_expr &x, const type_expr &y)

type_ptr	mk_prim_type (primitive_tag p)

type_ptr	mk_row_type (type_ptr &&c)

type_ptr	mk_tuple_type (type_list &&l)

type_ptr	mk_function_type (type_expr &&a, type_expr &&r)

type_p	make_prim_type (unsigned int p)

type_p	make_row_type (type_p c)

type_p	make_tuple_type (raw_type_list l)

type_p	make_function_type (type_p a, type_p r)

raw_type_list	make_type_singleton (type_p t)

raw_type_list	make_type_list (raw_type_list l, type_p t)

dressed_type_list	scan_type_list (const char *&s)

type_expr	scan_type (const char *&s)

type_expr	mk_type_expr (const char *s)

type_ptr	mk_type (const char *s)

type_expr	unknown_tuple (size_t n)

std::ostream &	operator<< (std::ostream &out, const value_base &v)

void	push_tuple_components ()

void	wrap_tuple (size_t n)

void	push_expanded (expression_base::level l, const shared_value &v)

void	coercion (const type_expr &from, const type_expr &to, const char *s, conversion_info::conv_f f)

bool	coerce (const type_expr &from_type, const type_expr &to_type, expression_ptr &e)

expression_ptr	conform_types (const type_expr &found, type_expr &required, expression_ptr &&d, const expr &e)

const conversion_record *	row_coercion (const type_expr &final_type, type_expr &component_type)

unsigned int	is_close (const type_expr &x, const type_expr &y)

bool	broader_eq (const type_expr &a, const type_expr &b)

bool	operator!= (const type_expr &x, const type_expr &y)

std::ostream &	operator<< (std::ostream &out, const expression_base &e)

template<typename T >
T &	as_lvalue (T &&rvalue)

void	push_value (const shared_value &v)

void	push_value (shared_value &&v)

shared_value	pop_value ()

template<typename D >
std::shared_ptr< const D >	get () throw (logic_error)

template<typename D >
std::shared_ptr< D >	non_const_get () throw (logic_error)

template<typename D >
D *	force (value v) throw (logic_error)

template<typename D >
const D *	force (const value_base *v) throw (logic_error)

template<typename D >
std::shared_ptr< D >	get_own () throw (logic_error)

value	uniquify (shared_value &v)

template<unsigned int>
void	wrap_tuple ()

template<unsigned int>
void	do_wrap (std::vector< shared_value >::iterator it)

template<>
void	do_wrap< 0u > (std::vector< shared_value >::iterator it)

void	reset_evaluator ()

expression_ptr	convert_expr (const expr &e, type_expr &type)

expression_ptr	resolve_overload (const expr &e, type_expr &type, const overload_table::variant_list &variants)

type_list	pattern_list_types (const patlist &p)

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)

std::ostream &	operator<< (std::ostream &out, const lambda_struct &l)

std::string	range_mess (int i, size_t n, const expression_base e, const char where)

void	slice_range_error (int lwb, int upb, int n, unsigned flags, const expression_base *e)

void	print_body (std::ostream &out, const expression_ptr &body, unsigned flags)

unsigned int	input_path_size ()

const std::string &	input_path_component (unsigned int i)

std::ostream &	operator<< (std::ostream &out, const Id_table &p)

std::ostream &	operator<< (std::ostream &out, const overload_table &p)

void	initialise_evaluator ()

type_expr	analyse_types (const expr &e, expression_ptr &p)

void	global_set_identifier (const raw_id_pat &raw_pat, expr_p raw, int overload)

void	global_set_identifiers (const raw_let_list &d)

void	global_declare_identifier (id_type id, type_p t)

void	global_forget_identifier (id_type id)

void	global_forget_overload (id_type id, type_p t)

void	type_define_identifier (id_type id, type_p t, raw_id_pat ip, const YYLTYPE &loc)

void	type_of_expr (expr_p raw)

void	show_overloads (id_type id)

void	show_ids ()

void	install_function (wrapper_function f, const char name, const char type_string)

void	sizeof_string_wrapper (expression_base::level l)

void	sizeof_vector_wrapper (expression_base::level l)

void	sizeof_ratvec_wrapper (expression_base::level l)

void	matrix_ncols_wrapper (expression_base::level l)

void	mm_prod_wrapper (expression_base::level l)

void	transpose_mat_wrapper (expression_base::level l)

void	id_mat_wrapper (expression_base::level l)

void	global_set_identifier (const struct raw_id_pat &id, expr_p e, int overload)

template<typename T >
std::string	str (T n)

std::string	str (unsigned char c)

shared_bool	whether (bool b)

void	destroy_expr (expr_p p)

expr_p	make_int_denotation (int val, const YYLTYPE &loc)

expr_p	make_bool_denotation (bool val, const YYLTYPE &loc)

expr_p	make_string_denotation (std::string *val_p, const YYLTYPE &loc)

expr_p	make_applied_identifier (id_type id, const YYLTYPE &loc)

expr_p	make_dollar (const YYLTYPE &loc)

expr_p	make_break (unsigned n, const YYLTYPE &loc)

expr_p	make_return (expr_p exp, const YYLTYPE &loc)

expr_p	make_die (const YYLTYPE &loc)

raw_expr_list	make_exprlist_node (expr_p e, raw_expr_list raw)

raw_expr_list	reverse_expr_list (raw_expr_list raw)

expr_p	wrap_tuple_display (raw_expr_list l, const YYLTYPE &loc)

expr_p	wrap_list_display (raw_expr_list l, const YYLTYPE &loc)

void	destroy_exprlist (raw_expr_list l)

expr_p	make_application_node (expr_p f, raw_expr_list r_args, const YYLTYPE &loc, const YYLTYPE &left, const YYLTYPE &right)

expr_p	make_application_node (expr_p f, expr_p arg, const YYLTYPE &loc)

expr_p	make_binary_call (id_type name, expr_p x, expr_p y, const YYLTYPE &loc, const YYLTYPE &op_loc)

expr_p	make_unary_call (id_type name, expr_p a, const YYLTYPE &loc, const YYLTYPE &op_loc)

expr_p	make_negation (expr_p e, const YYLTYPE &loc)

raw_form_stack	start_formula (expr_p e, id_type op, int prio, const YYLTYPE &op_loc)

raw_form_stack	start_unary_formula (id_type op, int prio, const YYLTYPE &op_loc)

raw_form_stack	extend_formula (raw_form_stack pre, expr_p ep, id_type op, int prio, const YYLTYPE &op_loc)

expr_p	end_formula (raw_form_stack pre, expr_p ep, const YYLTYPE &loc)

void	destroy_formula (raw_form_stack s)

raw_patlist	make_pattern_node (raw_patlist prev, raw_id_pat &pattern)

void	destroy_pattern (raw_patlist p)

void	destroy_id_pat (const raw_id_pat &p)

raw_patlist	reverse_patlist (raw_patlist raw)

raw_let_list	make_let_node (raw_id_pat &pattern, expr_p val)

raw_let_list	append_let_node (raw_let_list prev, raw_let_list cur)

std::pair< id_pat, expr >	zip_decls (raw_let_list d)

expr_p	make_let_expr_node (raw_let_list d, expr_p b, const YYLTYPE &loc)

void	destroy_letlist (raw_let_list l)

void	destroy_type (type_p t)

void	destroy_type_list (raw_type_list t)

expr_p	make_lambda_node (raw_patlist p, raw_type_list tl, expr_p b, const YYLTYPE &loc)

expr_p	make_conditional_node (expr_p c, expr_p t, expr_p e, const YYLTYPE &loc)

expr_p	make_int_case_node (expr_p s, raw_expr_list i, const YYLTYPE &loc)

expr_p	make_while_node (expr_p b, unsigned flags, const YYLTYPE &loc)

expr_p	make_for_node (raw_id_pat &id, expr_p ip, expr_p b, unsigned flags, const YYLTYPE &loc)

expr_p	make_cfor_node (id_type id, expr_p c, expr_p l, expr_p b, unsigned flags, const YYLTYPE &loc)

expr_p	make_subscription_node (expr_p a, expr_p i, bool reversed, const YYLTYPE &loc)

expr_p	make_slice_node (expr_p a, expr_p lower, expr_p upper, unsigned flags, const YYLTYPE &loc)

expr_p	make_cast (type_p t, expr_p e, const YYLTYPE &loc)

expr_p	make_op_cast (id_type name, type_p t, const YYLTYPE &loc)

expr_p	make_assignment (id_type id, expr_p r, const YYLTYPE &loc)

expr_p	make_multi_assignment (raw_id_pat &lhs, expr_p r, const YYLTYPE &loc)

expr_p	make_comp_ass (expr_p l, expr_p r, const YYLTYPE &loc)

expr_p	make_comp_upd_ass (expr_p l, id_type op, expr_p r, const YYLTYPE &loc, const YYLTYPE &op_loc)

expr_p	make_recfun (id_type f, expr_p d, const YYLTYPE &loc, const YYLTYPE &f_loc)

expr_p	make_sequence (expr_p f, expr_p l, unsigned which, const YYLTYPE &loc)

id_type	lookup_identifier (const char *name)

void	include_file (int skip_seen)

std::ostream &	operator<< (std::ostream &out, const source_location &sl)

std::ostream &	operator<< (std::ostream &out, const expr &e)

bool	is_empty (const expr &e)

std::ostream &	operator<< (std::ostream &out, const id_pat &p)

Variables
const char *	prim_names []

const type_expr	unknown_type

const type_expr	void_type (empty_tuple())

const type_expr	int_type (integral_type)

const type_expr	bool_type (boolean_type)

const type_expr	row_of_type (mk_type_expr("[*]"))

const type_expr	gen_func_type (mk_type_expr("(->)"))

const type_expr	rat_type (rational_type)

const type_expr	str_type (string_type)

const type_expr	vec_type (vector_type)

const type_expr	ratvec_type (rational_vector_type)

const type_expr	mat_type (matrix_type)

const type_expr	row_of_int_type (mk_type_expr("[int]"))

const type_expr	row_of_rat_type (mk_type_expr("[rat]"))

const type_expr	row_of_vec_type (mk_type_expr("[vec]"))

const type_expr	row_row_of_int_type (mk_type_expr("[[int]]"))

const type_expr	pair_type (mk_type_expr("(,)"))

const type_expr	int_int_type (mk_type_expr("(int,int)"))

const type_expr	Lie_type_type (complex_lie_type_type)

const type_expr	rd_type (root_datum_type)

const type_expr	ic_type (inner_class_type)

const type_expr	rf_type (real_form_type)

const type_expr	split_type (split_integer_type)

const type_expr	param_type (module_parameter_type)

const type_expr	param_pol_type (virtual_module_type)

std::vector< shared_value >	execution_stack

std::vector< conversion_record >	coerce_table

volatile std::sig_atomic_t	interrupt_flag =0

type_expr	last_type

shared_value	last_value

BufferedInput *	main_input_buffer =nullptr

Id_table *	global_id_table =nullptr

overload_table *	global_overload_table =nullptr

std::ostream *	output_stream = &std::cout

bool	clean =true

int	verbosity =0

const shared_bool	global_false =std::make_shared<bool_value>(false)

const shared_bool	global_true =std::make_shared<bool_value>(true)

Hash_table *	main_hash_table =nullptr

Lexical_analyser *	lex =nullptr

Typedef Documentation

typedef struct application_node* atlas::interpreter::app

typedef struct assignment_node* atlas::interpreter::assignment

typedef std::unique_ptr<Block_value> atlas::interpreter::Block_ptr

typedef overloaded_builtin_call<false> atlas::interpreter::builtin_call

typedef struct cfor_node* atlas::interpreter::c_loop

typedef struct cast_node* atlas::interpreter::cast

typedef std::unique_ptr<closure_value> atlas::interpreter::closure_ptr

typedef struct comp_assignment_node* atlas::interpreter::comp_assignment

typedef struct conditional_node* atlas::interpreter::cond

typedef const type_expr* atlas::interpreter::const_type_p

typedef containers::sl_list<type_expr> atlas::interpreter::dressed_type_list

typedef containers::simple_list<expr> atlas::interpreter::expr_list

typedef struct expr* atlas::interpreter::expr_p

typedef std::unique_ptr<expr> atlas::interpreter::expr_ptr

typedef expression_base* atlas::interpreter::expression

typedef std::unique_ptr<expression_base> atlas::interpreter::expression_ptr

typedef struct for_node* atlas::interpreter::f_loop

typedef containers::mirrored_simple_list<formula_node> atlas::interpreter::form_stack

typedef func_type* atlas::interpreter::func_type_p

typedef std::unique_ptr<func_type> atlas::interpreter::func_type_ptr

typedef Hash_table::id_type atlas::interpreter::id_type

typedef std::unique_ptr<KGB_elt_value> atlas::interpreter::KGB_elt_ptr

typedef struct lambda_node* atlas::interpreter::lambda

typedef struct let_expr_node* atlas::interpreter::let

typedef containers::simple_list<let_pair> atlas::interpreter::let_list

typedef std::unique_ptr<module_parameter_value> atlas::interpreter::module_parameter_ptr

typedef struct op_cast_node* atlas::interpreter::op_cast

typedef std::shared_ptr<Block_value> atlas::interpreter::own_Block

typedef std::shared_ptr<int_value> atlas::interpreter::own_int

typedef std::shared_ptr<KGB_elt_value> atlas::interpreter::own_KGB_elt

typedef std::shared_ptr<Lie_type_value> atlas::interpreter::own_Lie_type

typedef std::shared_ptr<matrix_value> atlas::interpreter::own_matrix

typedef std::shared_ptr<module_parameter_value> atlas::interpreter::own_module_parameter

typedef std::shared_ptr<rat_value> atlas::interpreter::own_rat

typedef std::shared_ptr<rational_vector_value> atlas::interpreter::own_rational_vector

typedef std::shared_ptr<real_form_value> atlas::interpreter::own_real_form

typedef std::shared_ptr<row_value> atlas::interpreter::own_row

typedef std::shared_ptr<split_int_value> atlas::interpreter::own_split_int

typedef std::shared_ptr<string_value> atlas::interpreter::own_string

typedef std::shared_ptr<tuple_value> atlas::interpreter::own_tuple

typedef std::shared_ptr<value_base> atlas::interpreter::own_value

typedef std::shared_ptr<vector_value> atlas::interpreter::own_vector

typedef std::shared_ptr<virtual_module_value> atlas::interpreter::own_virtual_module

typedef containers::simple_list<struct id_pat> atlas::interpreter::patlist

typedef containers::sl_node<expr>* atlas::interpreter::raw_expr_list

typedef containers::sl_node<formula_node>* atlas::interpreter::raw_form_stack

typedef containers::sl_node<let_pair>* atlas::interpreter::raw_let_list

typedef containers::sl_node<struct id_pat>* atlas::interpreter::raw_patlist

typedef atlas::containers::sl_node<type_expr>* atlas::interpreter::raw_type_list

typedef std::unique_ptr<root_datum_value> atlas::interpreter::root_datum_ptr

typedef struct sequence_node* atlas::interpreter::sequence

typedef std::shared_ptr<const Block_value> atlas::interpreter::shared_Block

typedef std::shared_ptr<const bool_value> atlas::interpreter::shared_bool

typedef std::shared_ptr<const builtin_value<false> > atlas::interpreter::shared_builtin

typedef std::shared_ptr<const Cartan_class_value> atlas::interpreter::shared_Cartan_class

typedef std::shared_ptr<const closure_value> atlas::interpreter::shared_closure

typedef std::shared_ptr<class evaluation_context> atlas::interpreter::shared_context

typedef std::shared_ptr<expression_base> atlas::interpreter::shared_expression

typedef std::shared_ptr<const function_base> atlas::interpreter::shared_function

typedef std::shared_ptr<const inner_class_value> atlas::interpreter::shared_inner_class

typedef std::shared_ptr<const int_value> atlas::interpreter::shared_int

typedef std::shared_ptr<const KGB_elt_value> atlas::interpreter::shared_KGB_elt

typedef std::shared_ptr<lambda_struct> atlas::interpreter::shared_lambda

typedef std::shared_ptr<const Lie_type_value> atlas::interpreter::shared_Lie_type

typedef std::shared_ptr<const matrix_value> atlas::interpreter::shared_matrix

typedef std::shared_ptr<const module_parameter_value> atlas::interpreter::shared_module_parameter

typedef std::shared_ptr<const rat_value> atlas::interpreter::shared_rat

typedef std::shared_ptr<const rational_vector_value> atlas::interpreter::shared_rational_vector

typedef std::shared_ptr<const real_form_value> atlas::interpreter::shared_real_form

typedef std::shared_ptr<const root_datum_value> atlas::interpreter::shared_root_datum

typedef std::shared_ptr<const row_value> atlas::interpreter::shared_row

typedef std::shared_ptr<shared_value> atlas::interpreter::shared_share

typedef std::shared_ptr<const split_int_value> atlas::interpreter::shared_split_int

typedef std::shared_ptr<const string_value> atlas::interpreter::shared_string

typedef std::shared_ptr<const tuple_value> atlas::interpreter::shared_tuple

typedef std::shared_ptr<const value_base> atlas::interpreter::shared_value

typedef std::shared_ptr<const builtin_value<true> > atlas::interpreter::shared_variadic_builtin

typedef std::shared_ptr<const vector_value> atlas::interpreter::shared_vector

typedef std::shared_ptr<const virtual_module_value> atlas::interpreter::shared_virtual_module

typedef struct slice_node* atlas::interpreter::slc

typedef std::unique_ptr<split_int_value> atlas::interpreter::split_int_ptr

typedef struct subscription_node* atlas::interpreter::sub

typedef std::unique_ptr<tuple_value> atlas::interpreter::tuple_ptr

typedef containers::simple_list<type_expr> atlas::interpreter::type_list

typedef type_expr* atlas::interpreter::type_p

typedef std::unique_ptr<type_expr> atlas::interpreter::type_ptr

typedef value_base* atlas::interpreter::value

typedef overloaded_builtin_call<true> atlas::interpreter::variadic_builtin_call

typedef std::unique_ptr<virtual_module_value> atlas::interpreter::virtual_module_ptr

typedef struct while_node* atlas::interpreter::w_loop

typedef containers::weak_sl_list_const_iterator<expr> atlas::interpreter::wel_const_iterator

typedef containers::weak_sl_list_iterator<expr> atlas::interpreter::wel_iterator

typedef void(* atlas::interpreter::wrapper_function) (expression_base::level)

typedef containers::weak_sl_list_const_iterator<type_expr> atlas::interpreter::wtl_const_iterator

typedef containers::weak_sl_list_iterator<type_expr> atlas::interpreter::wtl_iterator

Enumeration Type Documentation

enum atlas::interpreter::expr_kind

Enumerator
integer_denotation
string_denotation
boolean_denotation
applied_identifier
last_value_computed
break_expr
return_expr
die_expr
tuple_display
list_display
function_call
negation_expr
let_expr
lambda_expr
conditional_expr
int_case_expr
while_expr
for_expr
cfor_expr
subscription
slice
cast_expr
op_cast_expr
ass_stat
comp_ass_stat
seq_expr
next_expr
do_expr
no_expr

enum atlas::interpreter::primitive_tag

Enumerator
integral_type
rational_type
string_type
boolean_type
vector_type
matrix_type
rational_vector_type
complex_lie_type_type
root_datum_type
inner_class_type
real_form_type
Cartan_class_type
KGB_element_type
block_type
module_parameter_type
split_integer_type
virtual_module_type
nr_of_primitive_types

enum atlas::interpreter::type_tag

Enumerator
undetermined_type
primitive_type
row_type
tuple_type
function_type

Function Documentation

type_ptr atlas::interpreter::acquire ( const type_expr * t )

type_expr atlas::interpreter::analyse_types	(	const expr &	e,
		expression_ptr &	p
	)

raw_let_list atlas::interpreter::append_let_node	(	raw_let_list	prev,
		raw_let_list	cur
	)

template<typename T >

T& atlas::interpreter::as_lvalue ( T && rvalue )

bool atlas::interpreter::broader_eq	(	const type_expr &	a,
		const type_expr &	b
	)

bool atlas::interpreter::coerce	(	const type_expr &	from_type,
		const type_expr &	to_type,
		expression_ptr &	e
	)

void atlas::interpreter::coercion	(	const type_expr &	from,
		const type_expr &	to,
		const char *	s,
		conversion_info::conv_f	f
	)

expression_ptr atlas::interpreter::conform_types	(	const type_expr &	found,
		type_expr &	required,
		expression_ptr &&	d,
		const expr &	e
	)

expression_ptr atlas::interpreter::convert_expr	(	const expr &	e,
		type_expr &	type
	)

size_t atlas::interpreter::count_identifiers ( const id_pat & pat )

void atlas::interpreter::destroy_expr ( expr_p p )

void atlas::interpreter::destroy_exprlist ( raw_expr_list l )

void atlas::interpreter::destroy_formula ( raw_form_stack s )

void atlas::interpreter::destroy_id_pat ( const raw_id_pat & p )

void atlas::interpreter::destroy_letlist ( raw_let_list l )

void atlas::interpreter::destroy_pattern ( raw_patlist p )

void atlas::interpreter::destroy_type ( type_p t )

void atlas::interpreter::destroy_type_list ( raw_type_list t )

template<unsigned int>

void atlas::interpreter::do_wrap ( std::vector< shared_value >::iterator it )

inline

template<>

void atlas::interpreter::do_wrap< 0u > ( std::vector< shared_value >::iterator it )

inline

type_list atlas::interpreter::empty_tuple ( )

expr_p atlas::interpreter::end_formula	(	raw_form_stack	pre,
		expr_p	ep,
		const YYLTYPE &	loc
	)

raw_form_stack atlas::interpreter::extend_formula	(	raw_form_stack	pre,
		expr_p	ep,
		id_type	op,
		int	prio,
		const YYLTYPE &	op_loc
	)

template<typename D >

D* atlas::interpreter::force	(	value	v	)
throw	(	logic_error
	)

template<typename D >

const D* atlas::interpreter::force	(	const value_base *	v	)
throw	(	logic_error
	)

template<typename D >

std::shared_ptr<const D> atlas::interpreter::get	(		)
throw	(	logic_error
	)

inline

template<typename D >

std::shared_ptr<D> atlas::interpreter::get_own	(		)
throw	(	logic_error
	)

void atlas::interpreter::global_declare_identifier	(	id_type	id,
		type_p	t
	)

void atlas::interpreter::global_forget_identifier ( id_type id )

void atlas::interpreter::global_forget_overload	(	id_type	id,
		type_p	t
	)

void atlas::interpreter::global_set_identifier	(	const struct raw_id_pat &	id,
		expr_p	e,
		int	overload
	)

void atlas::interpreter::global_set_identifier	(	const raw_id_pat &	raw_pat,
		expr_p	raw,
		int	overload
	)

void atlas::interpreter::global_set_identifiers ( const raw_let_list & d )

void atlas::interpreter::id_mat_wrapper ( expression_base::level l )

void atlas::interpreter::include_file ( int skip_seen )

void atlas::interpreter::initialise_builtin_types ( )

void atlas::interpreter::initialise_evaluator ( )

const std::string & atlas::interpreter::input_path_component ( unsigned int i )

unsigned int atlas::interpreter::input_path_size ( )

void atlas::interpreter::install_function	(	wrapper_function	f,
		const char *	name,
		const char *	type_string
	)

unsigned int atlas::interpreter::is_close	(	const type_expr &	x,
		const type_expr &	y
	)

bool atlas::interpreter::is_empty ( const expr & e )

void atlas::interpreter::list_identifiers	(	const id_pat &	pat,
		std::vector< id_type > &	d
	)

id_type atlas::interpreter::lookup_identifier ( const char * name )

expr_p atlas::interpreter::make_application_node	(	expr_p	f,
		raw_expr_list	r_args,
		const YYLTYPE &	loc,
		const YYLTYPE &	left,
		const YYLTYPE &	right
	)

expr_p atlas::interpreter::make_application_node	(	expr_p	f,
		expr_p	arg,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_applied_identifier	(	id_type	id,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_assignment	(	id_type	id,
		expr_p	r,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_binary_call	(	id_type	name,
		expr_p	x,
		expr_p	y,
		const YYLTYPE &	loc,
		const YYLTYPE &	op_loc
	)

expr_p atlas::interpreter::make_bool_denotation	(	bool	val,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_break	(	unsigned	n,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_cast	(	type_p	t,
		expr_p	e,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_cfor_node	(	id_type	id,
		expr_p	c,
		expr_p	l,
		expr_p	b,
		unsigned	flags,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_comp_ass	(	expr_p	l,
		expr_p	r,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_comp_upd_ass	(	expr_p	l,
		id_type	op,
		expr_p	r,
		const YYLTYPE &	loc,
		const YYLTYPE &	op_loc
	)

expr_p atlas::interpreter::make_conditional_node	(	expr_p	c,
		expr_p	t,
		expr_p	e,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_die ( const YYLTYPE & loc )

expr_p atlas::interpreter::make_dollar ( const YYLTYPE & loc )

raw_expr_list atlas::interpreter::make_exprlist_node	(	expr_p	e,
		raw_expr_list	raw
	)

expr_p atlas::interpreter::make_for_node	(	raw_id_pat &	id,
		expr_p	ip,
		expr_p	b,
		unsigned	flags,
		const YYLTYPE &	loc
	)

type_p atlas::interpreter::make_function_type	(	type_p	a,
		type_p	r
	)

expr_p atlas::interpreter::make_int_case_node	(	expr_p	s,
		raw_expr_list	i,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_int_denotation	(	int	val,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_lambda_node	(	raw_patlist	p,
		raw_type_list	tl,
		expr_p	b,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_let_expr_node	(	raw_let_list	d,
		expr_p	b,
		const YYLTYPE &	loc
	)

raw_let_list atlas::interpreter::make_let_node	(	raw_id_pat &	pattern,
		expr_p	val
	)

expr_p atlas::interpreter::make_multi_assignment	(	raw_id_pat &	lhs,
		expr_p	r,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_negation	(	expr_p	e,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_op_cast	(	id_type	name,
		type_p	t,
		const YYLTYPE &	loc
	)

raw_patlist atlas::interpreter::make_pattern_node	(	raw_patlist	prev,
		raw_id_pat &	pattern
	)

type_p atlas::interpreter::make_prim_type ( unsigned int p )

expr_p atlas::interpreter::make_recfun	(	id_type	f,
		expr_p	d,
		const YYLTYPE &	loc,
		const YYLTYPE &	f_loc
	)

expr_p atlas::interpreter::make_return	(	expr_p	exp,
		const YYLTYPE &	loc
	)

type_p atlas::interpreter::make_row_type ( type_p c )

expr_p atlas::interpreter::make_sequence	(	expr_p	f,
		expr_p	l,
		unsigned	which,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_slice_node	(	expr_p	a,
		expr_p	lower,
		expr_p	upper,
		unsigned	flags,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_string_denotation	(	std::string *	val_p,
		const YYLTYPE &	loc
	)

expr_p atlas::interpreter::make_subscription_node	(	expr_p	a,
		expr_p	i,
		bool	reversed,
		const YYLTYPE &	loc
	)

type_p atlas::interpreter::make_tuple_type ( raw_type_list l )

raw_type_list atlas::interpreter::make_type_list	(	raw_type_list	l,
		type_p	t
	)

raw_type_list atlas::interpreter::make_type_singleton ( type_p t )

expr_p atlas::interpreter::make_unary_call	(	id_type	name,
		expr_p	a,
		const YYLTYPE &	loc,
		const YYLTYPE &	op_loc
	)

expr_p atlas::interpreter::make_while_node	(	expr_p	b,
		unsigned	flags,
		const YYLTYPE &	loc
	)

void atlas::interpreter::matrix_ncols_wrapper ( expression_base::level l )

type_ptr atlas::interpreter::mk_function_type	(	type_expr &&	a,
		type_expr &&	r
	)

type_ptr atlas::interpreter::mk_prim_type ( primitive_tag p )

type_ptr atlas::interpreter::mk_row_type ( type_ptr && c )

type_ptr atlas::interpreter::mk_tuple_type ( type_list && l )

type_ptr atlas::interpreter::mk_type ( const char * s )

type_expr atlas::interpreter::mk_type_expr ( const char * s )

void atlas::interpreter::mm_prod_wrapper ( expression_base::level l )

template<typename D >

std::shared_ptr<D> atlas::interpreter::non_const_get	(		)
throw	(	logic_error
	)

inline

bool atlas::interpreter::operator!=	(	const type_expr &	x,
		const type_expr &	y
	)

inline

std::ostream& atlas::interpreter::operator<<	(	std::ostream &	out,
		const raw_type_list &	l
	)

std::ostream & atlas::interpreter::operator<<	(	std::ostream &	out,
		const func_type &	f
	)

std::ostream & atlas::interpreter::operator<<	(	std::ostream &	out,
		const type_expr &	t
	)

std::ostream& atlas::interpreter::operator<<	(	std::ostream &	out,
		const expression_base &	e
	)

inline

std::ostream & atlas::interpreter::operator<<	(	std::ostream &	out,
		const value_base &	v
	)

std::ostream & atlas::interpreter::operator<<	(	std::ostream &	out,
		const source_location &	sl
	)

std::ostream & atlas::interpreter::operator<<	(	std::ostream &	out,
		const expr &	e
	)

std::ostream & atlas::interpreter::operator<<	(	std::ostream &	out,
		const id_pat &	p
	)

std::ostream & atlas::interpreter::operator<<	(	std::ostream &	out,
		const Id_table &	p
	)

std::ostream & atlas::interpreter::operator<<	(	std::ostream &	out,
		const overload_table &	p
	)

std::ostream& atlas::interpreter::operator<<	(	std::ostream &	out,
		const lambda_struct &	l
	)

bool atlas::interpreter::operator==	(	const type_expr &	x,
		const type_expr &	y
	)

type_list atlas::interpreter::pattern_list_types ( const patlist & p )

type_expr atlas::interpreter::pattern_type ( const id_pat & pat )

shared_value atlas::interpreter::pop_value ( )

inline

type_list & atlas::interpreter::prefix	(	type_expr &&	t,
		type_list &	dst
	)

dressed_type_list & atlas::interpreter::prefix	(	type_expr &&	t,
		dressed_type_list &	dst
	)

void atlas::interpreter::print_body	(	std::ostream &	out,
		const expression_ptr &	body,
		unsigned	flags
	)

void atlas::interpreter::push_expanded	(	expression_base::level	l,
		const shared_value &	v
	)

void atlas::interpreter::push_tuple_components ( )

void atlas::interpreter::push_value ( const shared_value & v )

inline

void atlas::interpreter::push_value ( shared_value && v )

inline

std::string atlas::interpreter::range_mess	(	int	i,
		size_t	n,
		const expression_base *	e,
		const char *	where
	)

inline

void atlas::interpreter::reset_evaluator ( )

expression_ptr atlas::interpreter::resolve_overload	(	const expr &	e,
		type_expr &	type,
		const overload_table::variant_list &	variants
	)

raw_expr_list atlas::interpreter::reverse_expr_list ( raw_expr_list raw )

raw_patlist atlas::interpreter::reverse_patlist ( raw_patlist raw )

const conversion_record * atlas::interpreter::row_coercion	(	const type_expr &	final_type,
		type_expr &	component_type
	)

type_expr atlas::interpreter::scan_type ( const char *& s )

dressed_type_list atlas::interpreter::scan_type_list ( const char *& s )

void atlas::interpreter::show_ids ( )

void atlas::interpreter::show_overloads ( id_type id )

void atlas::interpreter::sizeof_ratvec_wrapper ( expression_base::level l )

void atlas::interpreter::sizeof_string_wrapper ( expression_base::level l )

void atlas::interpreter::sizeof_vector_wrapper ( expression_base::level l )

void atlas::interpreter::slice_range_error	(	int	lwb,
		int	upb,
		int	n,
		unsigned	flags,
		const expression_base *	e
	)

raw_form_stack atlas::interpreter::start_formula	(	expr_p	e,
		id_type	op,
		int	prio,
		const YYLTYPE &	op_loc
	)

raw_form_stack atlas::interpreter::start_unary_formula	(	id_type	op,
		int	prio,
		const YYLTYPE &	op_loc
	)

template<typename T >

std::string atlas::interpreter::str ( T n )

std::string atlas::interpreter::str ( unsigned char c )

inline

void atlas::interpreter::thread_bindings	(	const id_pat &	pat,
		const type_expr &	type,
		layer &	dst,
		bool	is_const
	)

void atlas::interpreter::thread_components	(	const id_pat &	pat,
		const shared_value &	val,
		std::back_insert_iterator< std::vector< shared_value > >	dst
	)

void atlas::interpreter::transpose_mat_wrapper ( expression_base::level l )

void atlas::interpreter::type_define_identifier	(	id_type	id,
		type_p	t,
		raw_id_pat	ip,
		const YYLTYPE &	loc
	)

void atlas::interpreter::type_of_expr ( expr_p raw )

value atlas::interpreter::uniquify ( shared_value & v )

inline

type_expr atlas::interpreter::unknown_tuple ( size_t n )

void atlas::interpreter::virtual_module_size_wrapper ( expression_base::level l )

shared_bool atlas::interpreter::whether ( bool b )

inline

expr_p atlas::interpreter::wrap_list_display	(	raw_expr_list	l,
		const YYLTYPE &	loc
	)

void atlas::interpreter::wrap_tuple ( size_t n )

template<unsigned int>

void atlas::interpreter::wrap_tuple ( )

inline

expr_p atlas::interpreter::wrap_tuple_display	(	raw_expr_list	l,
		const YYLTYPE &	loc
	)

std::pair< id_pat, expr > atlas::interpreter::zip_decls ( raw_let_list d )

Variable Documentation

const type_expr atlas::interpreter::bool_type

bool atlas::interpreter::clean =true

std::vector<conversion_record> atlas::interpreter::coerce_table

std::vector< shared_value > atlas::interpreter::execution_stack

const type_expr atlas::interpreter::gen_func_type

const shared_bool atlas::interpreter::global_false =std::make_shared<bool_value>(false)

Id_table * atlas::interpreter::global_id_table =nullptr

overload_table * atlas::interpreter::global_overload_table =nullptr

const shared_bool atlas::interpreter::global_true =std::make_shared<bool_value>(true)

const type_expr atlas::interpreter::ic_type

const type_expr atlas::interpreter::int_int_type

const type_expr atlas::interpreter::int_type

volatile std::sig_atomic_t atlas::interpreter::interrupt_flag =0

type_expr atlas::interpreter::last_type

shared_value atlas::interpreter::last_value

Lexical_analyser * atlas::interpreter::lex =nullptr

const type_expr atlas::interpreter::Lie_type_type

Hash_table * atlas::interpreter::main_hash_table =nullptr

BufferedInput * atlas::interpreter::main_input_buffer =nullptr

const type_expr atlas::interpreter::mat_type

std::ostream * atlas::interpreter::output_stream = &std::cout

const type_expr atlas::interpreter::pair_type

const type_expr atlas::interpreter::param_pol_type

const type_expr atlas::interpreter::param_type

const char * atlas::interpreter::prim_names

Initial value:

=
{"int","rat","string","bool",
"vec","mat","ratvec",
"LieType","RootDatum","InnerClass","RealForm",
"CartanClass","KGBElt","Block","Param","Split","ParamPol",
"void",nullptr}

const type_expr atlas::interpreter::rat_type

const type_expr atlas::interpreter::ratvec_type

const type_expr atlas::interpreter::rd_type

const type_expr atlas::interpreter::rf_type

const type_expr atlas::interpreter::row_of_int_type

const type_expr atlas::interpreter::row_of_rat_type

const type_expr atlas::interpreter::row_of_type

const type_expr atlas::interpreter::row_of_vec_type

const type_expr atlas::interpreter::row_row_of_int_type

const type_expr atlas::interpreter::split_type

const type_expr atlas::interpreter::str_type

const type_expr atlas::interpreter::unknown_type

const type_expr atlas::interpreter::vec_type

int atlas::interpreter::verbosity =0

const type_expr atlas::interpreter::void_type

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation