/**
* Generate the name of the constrain function together
* with expressions for the bounds parameters, if any.
* Constrain and unconstrain functions both take bounds
* constrain function also needs row, column size args.
*
* NOTE: expecting that parser disallows integer params.
*
* @param[in] btype block var type
* @param[in] fn_name either "constrain" or "unconstrain"
*/
std::string write_constraints_fn(const block_var_type &btype,
std::string fn_name) {
std::stringstream ss;
if (btype.bare_type().is_double_type())
ss << "scalar";
else
ss << btype.name();
if (btype.has_def_bounds()) {
if (btype.bounds().has_low() && btype.bounds().has_high()) {
ss << "_lub_" << fn_name << "(";
generate_expression(btype.bounds().low_.expr_, NOT_USER_FACING, ss);
ss << ", ";
generate_expression(btype.bounds().high_.expr_, NOT_USER_FACING, ss);
} else if (btype.bounds().has_low()) {
ss << "_lb_" << fn_name << "(";
generate_expression(btype.bounds().low_.expr_, NOT_USER_FACING, ss);
} else {
ss << "_ub_" << fn_name << "(";
generate_expression(btype.bounds().high_.expr_, NOT_USER_FACING, ss);
}
} else if (btype.has_def_offset_multiplier()) {
if (btype.ls().has_offset() && btype.ls().has_multiplier()) {
ss << "_offset_multiplier_" << fn_name << "(";
generate_expression(btype.ls().offset_.expr_, NOT_USER_FACING, ss);
ss << ", ";
generate_expression(btype.ls().multiplier_.expr_, NOT_USER_FACING, ss);
} else if (btype.ls().has_offset()) {
ss << "_offset_multiplier_" << fn_name << "(";
generate_expression(btype.ls().offset_.expr_, NOT_USER_FACING, ss);
ss << ", 1";
} else {
ss << "_offset_multiplier_" << fn_name << "(0";
ss << ", ";
generate_expression(btype.ls().multiplier_.expr_, NOT_USER_FACING, ss);
}
} else {
ss << "_" << fn_name << "(";
}
if ((fn_name.compare("unconstrain") == 0)) {
if (btype.has_def_bounds() || btype.has_def_offset_multiplier())
ss << ", ";
return ss.str();
}
if (!is_nil(btype.arg1())) {
if (btype.has_def_bounds() || btype.has_def_offset_multiplier())
ss << ", ";
generate_expression(btype.arg1(), NOT_USER_FACING, ss);
}
if (btype.name() == "matrix" || btype.name() == "cholesky_factor_cov") {
ss << ", ";
generate_expression(btype.arg2(), NOT_USER_FACING, ss);
}
return ss.str();
}
int generateTURTLE_CMD(unsigned char * program, int pc, treenode * root)
{
// if the cmd expects 0 parameters...
if (root->attribute.cmd == CMD_PU
|| root->attribute.cmd == CMD_PD
|| root->attribute.cmd == CMD_HOME)
{
}
// if the cmd expects 1 parameter...
if (root->attribute.cmd == CMD_FD
|| root->attribute.cmd == CMD_BK
|| root->attribute.cmd == CMD_SETC
|| root->attribute.cmd == CMD_RT
|| root->attribute.cmd == CMD_LT) // TODO: add a bunch of ||s
{
// generate code for child
treenode * child = firstchild(root);
pc = generate_expression(program, pc, child);
// POP_R P1
program[pc++] = OPCODE_POP_R;
program[pc++] = REGISTER_P1;
}
// if the cmd expects 2 parameters...
if (root->attribute.cmd == CMD_SETXY)
{
// generate code for child
treenode * child = firstchild(root);
pc = generate_expression(program, pc, child);
// POP_R P1
program[pc++] = OPCODE_POP_R;
program[pc++] = REGISTER_P1;
child = nextchild(root,child);
pc = generate_expression(program, pc, child);
// POP_R P1
program[pc++] = OPCODE_POP_R;
program[pc++] = REGISTER_P2;
}
// TURTLE attr.turtleop
program[pc++] = OPCODE_TURTLE;
program[pc++] = turtle_cmd_to_turtle_op(root->attribute.cmd);
//printf("generated turtle_cmd with opcode %i and op %i\n",program[pc-2],program[pc-1]);
return pc;
}
static void
generate_function_call_expression(DVM_Executable *exe, Block *block,
Expression *expr, OpcodeBuf *ob)
{
FunctionCallExpression *fce = &expr->u.function_call_expression;
ArgumentList *arg_pos;
for (arg_pos = fce->argument; arg_pos; arg_pos = arg_pos->next) {
generate_expression(exe, block, arg_pos->expression, ob);
}
generate_expression(exe, block, fce->function, ob);
generate_code(ob, expr->line_number, DVM_INVOKE);
}
void generate_indexed_expr(const std::string& expr,
const std::vector<expression>& indexes,
bare_expr_type base_type,
bool user_facing, std::ostream& o) {
if (user_facing) {
generate_indexed_expr_user(expr, indexes, o);
return;
}
if (indexes.size() == 0) {
o << expr;
return;
}
if (base_type.innermost_type().is_matrix_type()
&& base_type.num_dims() == indexes.size()) {
for (size_t n = 0; n < indexes.size() - 1; ++n)
o << (isLHS ? "get_base1_lhs(" : "get_base1(");
o << expr;
for (size_t n = 0; n < indexes.size() - 2 ; ++n) {
o << ", ";
generate_expression(indexes[n], user_facing, o);
o << ", ";
generate_quoted_string(expr, o);
o << ", " << (n + 1) << ')';
}
o << ", ";
generate_expression(indexes[indexes.size() - 2U], user_facing, o);
o << ", ";
generate_expression(indexes[indexes.size() - 1U], user_facing, o);
o << ", ";
generate_quoted_string(expr, o);
o << ", " << (indexes.size() - 1U) << ')';
return;
}
for (size_t n = 0; n < indexes.size(); ++n)
o << (isLHS ? "get_base1_lhs(" : "get_base1(");
o << expr;
for (size_t n = 0; n < indexes.size() - 1; ++n) {
o << ", ";
generate_expression(indexes[n], user_facing, o);
o << ", ";
generate_quoted_string(expr, o);
o << ", " << (n + 1) << ')';
}
o << ", ";
generate_expression(indexes[indexes.size() - 1U], user_facing, o);
o << ", ";
generate_quoted_string(expr, o);
o << ", " << (indexes.size()) << ')';
}
/**
* Generate code to validate the specified variable declaration
* using the specified indentation level and stream.
* Checks any defined bounds or constraints on specialized types.
* NOTE: bounded / specialized types are mutually exclusive
*
* @param[in] decl variable declaration
* @param[in] indent indentation level
* @param[in,out] o stream for generating
*/
void generate_validate_var_decl(const block_var_decl decl,
int indent, std::ostream& o) {
std::string var_name(decl.name());
std::vector<expression> ar_lens(decl.type().array_lens());
block_var_type btype = decl.type().innermost_type();
if (btype.has_def_bounds()) {
range bounds = btype.bounds();
write_begin_array_dims_loop(decl, true, indent, o);
if (bounds.has_low()) {
generate_indent(indent + ar_lens.size(), o);
o << "check_greater_or_equal(function__, ";
o << "\"" << var_name;
write_var_idx_array_dims(ar_lens.size(), o);
o << "\", " << var_name;
write_var_idx_array_dims(ar_lens.size(), o);
o << ", ";
generate_expression(bounds.low_.expr_, NOT_USER_FACING, o);
o << ");" << EOL;
}
if (bounds.has_high()) {
generate_indent(indent + ar_lens.size(), o);
o << "check_less_or_equal(function__, ";
o << "\"" << var_name;
write_var_idx_array_dims(ar_lens.size(), o);
o << "\", " << var_name;
write_var_idx_array_dims(ar_lens.size(), o);
o << ", ";
generate_expression(bounds.high_.expr_, NOT_USER_FACING, o);
o << ");" << EOL;
}
write_end_loop(ar_lens.size(), indent, o);
} else if (btype.is_specialized()) {
write_begin_array_dims_loop(decl, true, indent, o);
generate_indent(indent + ar_lens.size(), o);
o << "stan::math::check_";
// kludge - inconsistent naming specialized cholesky_factor types
if (btype.name() == "cholesky_factor_cov")
o << "cholesky_factor";
else
o << btype.name();
o << "(function__, \"" << var_name;
write_var_idx_array_dims(ar_lens.size(), o);
o << "\", " << var_name;
write_var_idx_array_dims(ar_lens.size(), o);
o << ");" << EOL;
write_end_loop(ar_lens.size(), indent, o);
}
}
static void
generate_logical_or_expression(DVM_Executable *exe, Block *block,
Expression *expr,
OpcodeBuf *ob)
{
int true_label;
true_label = get_label(ob);
generate_expression(exe, block, expr->u.binary_expression.left, ob);
generate_code(ob, expr->line_number, DVM_DUPLICATE);
generate_code(ob, expr->line_number, DVM_JUMP_IF_TRUE, true_label);
generate_expression(exe, block, expr->u.binary_expression.right, ob);
generate_code(ob, expr->line_number, DVM_LOGICAL_OR);
set_label(ob, true_label);
}
static void
generate_logical_and_expression(DVM_Executable *exe, Block *block,
Expression *expr,
OpcodeBuf *ob)
{
int false_label;
false_label = get_label(ob);
generate_expression(exe, block, expr->u.binary_expression.left, ob);
generate_code(ob, expr->line_number, DVM_DUPLICATE);
generate_code(ob, expr->line_number, DVM_JUMP_IF_FALSE, false_label);
generate_expression(exe, block, expr->u.binary_expression.right, ob);
generate_code(ob, expr->line_number, DVM_LOGICAL_AND);
set_label(ob, false_label);
}
TEST(generateExpression, integrate_ode) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::integrate_ode so; // null ctor should work and not raise error
std::string integration_function_name = "bar";
std::string system_function_name = "foo";
stan::lang::variable y0("y0_var_name");
y0.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable t0("t0_var_name");
t0.set_type(stan::lang::double_type());
stan::lang::variable ts("ts_var_name");
ts.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable theta("theta_var_name");
theta.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable x("x_var_name");
x.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable x_int("x_int_var_name");
x.set_type(stan::lang::bare_array_type(stan::lang::int_type()));
stan::lang::integrate_ode so2(integration_function_name, system_function_name,
y0, t0, ts, theta, x, x_int);
stan::lang::expression e1(so2);
generate_expression(e1, user_facing, msgs);
EXPECT_EQ(msgs.str(),
"bar(foo_functor__(), y0_var_name, t0_var_name, ts_var_name, "
"theta_var_name, x_var_name, x_int_var_name, pstream__)");
}
static void
generate_while_statement(DVM_Executable *exe, Block *block,
Statement *statement, OpcodeBuf *ob)
{
int loop_label;
WhileStatement *while_s = &statement->u.while_s;
loop_label = get_label(ob);
set_label(ob, loop_label);
generate_expression(exe, block, while_s->condition, ob);
while_s->block->parent.statement.break_label = get_label(ob);
while_s->block->parent.statement.continue_label = get_label(ob);
generate_code(ob, statement->line_number,
DVM_JUMP_IF_FALSE,
while_s->block->parent.statement.break_label);
generate_statement_list(exe, while_s->block,
while_s->block->statement_list, ob);
set_label(ob, while_s->block->parent.statement.continue_label);
generate_code(ob, statement->line_number, DVM_JUMP, loop_label);
set_label(ob, while_s->block->parent.statement.break_label);
}
static void
generate_cast_expression(DVM_Executable *exe, Block *block,
Expression *expr, OpcodeBuf *ob)
{
generate_expression(exe, block, expr->u.cast.operand, ob);
switch (expr->u.cast.type) {
case INT_TO_DOUBLE_CAST:
generate_code(ob, expr->line_number, DVM_CAST_INT_TO_DOUBLE);
break;
case DOUBLE_TO_INT_CAST:
generate_code(ob, expr->line_number, DVM_CAST_DOUBLE_TO_INT);
break;
case BOOLEAN_TO_STRING_CAST:
generate_code(ob, expr->line_number, DVM_CAST_BOOLEAN_TO_STRING);
break;
case INT_TO_STRING_CAST:
generate_code(ob, expr->line_number, DVM_CAST_INT_TO_STRING);
break;
case DOUBLE_TO_STRING_CAST:
generate_code(ob, expr->line_number, DVM_CAST_DOUBLE_TO_STRING);
break;
default:
DBG_assert(0, ("expr->u.cast.type..%d", expr->u.cast.type));
}
}
TEST(generateExpression, index_op_sliced) {
static const bool user_facing = true;
std::stringstream msgs;
// foo is array of int
stan::lang::variable v1("foo");
v1.set_type(stan::lang::bare_array_type(stan::lang::int_type()));
stan::lang::expression e1(v1);
// use foo as multi-idx
stan::lang::multi_idx i1(e1);
stan::lang::idx idx(i1);
std::vector<stan::lang::idx> idxs;
idxs.push_back(idx);
// bar is 2-d array of int
stan::lang::bare_expr_type d2_ar_int = stan::lang::bare_array_type(stan::lang::int_type(),2);
stan::lang::variable v2("bar");
v2.set_type(d2_ar_int);
stan::lang::expression e2(v2);
// apply multi-idx to bar
stan::lang::index_op_sliced i_op_slice(e2, idxs);
stan::lang::expression e3 = i_op_slice;
generate_expression(e3, user_facing, msgs);
EXPECT_EQ(msgs.str(), "bar[foo]");
}
TEST(generateExpression, index_op) {
static const bool user_facing = true;
std::stringstream msgs;
// expr: row_vector
stan::lang::double_literal dblLit(5.1);
dblLit.string_ = "5.1";
stan::lang::expression e1 = dblLit;
std::vector<stan::lang::expression> elements;
elements.push_back(e1);
elements.push_back(e1);
stan::lang::row_vector_expr rv1(elements);
stan::lang::expression e2 = rv1;
// dimensions: vector of vector of dimensions
std::vector<std::vector<stan::lang::expression> > dimss;
std::vector<stan::lang::expression> dim;
dim.push_back(stan::lang::int_literal(1));
dimss.push_back(dim);
stan::lang::index_op i_op(e2, dimss);
stan::lang::expression e3 = i_op;
// result is index into row_vector
generate_expression(e3, user_facing, msgs);
EXPECT_NE(msgs.str().find("stan::math::to_row_vector"), std::string::npos);
EXPECT_NE(msgs.str().find("stan::math::array_builder<double"), std::string::npos);
EXPECT_NE(msgs.str().find("add(5.1).array()"), std::string::npos);
EXPECT_NE(msgs.str().find("[1]"), std::string::npos);
}
TEST(generateExpression, gen_int_lit_expr) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::int_literal intLit(5);
stan::lang::expression e1 = intLit;
generate_expression(e1, user_facing, msgs);
EXPECT_EQ(msgs.str(), "5");
}
static void
generate_binary_expression(DVM_Executable *exe, Block *block,
Expression *expr, DVM_Opcode code,
OpcodeBuf *ob)
{
DBG_assert(expr->u.binary_expression.left->type->basic_type
== expr->u.binary_expression.right->type->basic_type,
("left..%d, right..%d",
expr->u.binary_expression.left->type->basic_type,
expr->u.binary_expression.right->type->basic_type));
generate_expression(exe, block, expr->u.binary_expression.left, ob);
generate_expression(exe, block, expr->u.binary_expression.right, ob);
generate_code(ob, expr->line_number,
code
+ get_opcode_type_offset(expr->u.binary_expression.left
->type->basic_type));
}
TEST(generateExpression, gen_double_lit_expr) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::double_literal dblLit(5.10);
dblLit.string_ = "5.10";
stan::lang::expression e1 = dblLit;
generate_expression(e1, user_facing, msgs);
EXPECT_EQ(msgs.str(), "5.10");
}
static void
generate_return_statement(DVM_Executable *exe, Block *block,
Statement *statement, OpcodeBuf *ob)
{
DBG_assert(statement->u.return_s.return_value != NULL,
("return value is null."));
generate_expression(exe, block, statement->u.return_s.return_value, ob);
generate_code(ob, statement->line_number, DVM_RETURN);
}
TEST(generateExpression, unary_op) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::expression e1 = stan::lang::int_literal(5);
stan::lang::expression e2(stan::lang::unary_op('-',e1));
generate_expression(e2, user_facing, msgs);
EXPECT_EQ(msgs.str(), "-(5)");
}
static void
generate_initializer(DVM_Executable *exe, Block *block,
Statement *statement, OpcodeBuf *ob)
{
Declaration *decl = statement->u.declaration_s;
if (decl->initializer == NULL)
return;
generate_expression(exe, block, decl->initializer, ob);
generate_pop_to_identifier(decl, statement->line_number, ob);
}
static void
assign_bound_name ( node_t *var )
{
//Calculating the expression with children 1
generate_expression(var->children[1]);
//We make a pop for the final value on the stack and copy it to the space in the memory allocated for this variable
printf("\t popl %%eax \t/*Pop with the final result*/\n");
printf("\t movl %%eax,%d(%%ebp) \t /*Moving the result to the var*/\n",var->children[0]->entry->stack_offset);
}
static void
generate_assign_expression(DVM_Executable *exe, Block *block,
Expression *expr, OpcodeBuf *ob,
DVM_Boolean is_toplevel)
{
if (expr->u.assign_expression.operator != NORMAL_ASSIGN) {
generate_identifier_expression(exe, block,
expr->u.assign_expression.left,
ob);
}
generate_expression(exe, block, expr->u.assign_expression.operand, ob);
switch (expr->u.assign_expression.operator) {
case NORMAL_ASSIGN :
break;
case ADD_ASSIGN:
generate_code(ob, expr->line_number,
DVM_ADD_INT
+ get_opcode_type_offset(expr->type->basic_type));
break;
case SUB_ASSIGN:
generate_code(ob, expr->line_number,
DVM_SUB_INT
+ get_opcode_type_offset(expr->type->basic_type));
break;
case MUL_ASSIGN:
generate_code(ob, expr->line_number,
DVM_MUL_INT
+ get_opcode_type_offset(expr->type->basic_type));
break;
case DIV_ASSIGN:
generate_code(ob, expr->line_number,
DVM_DIV_INT
+ get_opcode_type_offset(expr->type->basic_type));
break;
case MOD_ASSIGN:
generate_code(ob, expr->line_number,
DVM_MOD_INT
+ get_opcode_type_offset(expr->type->basic_type));
break;
default:
DBG_assert(0, ("operator..%d\n", expr->u.assign_expression.operator));
}
if (!is_toplevel) {
generate_code(ob, expr->line_number, DVM_DUPLICATE);
}
generate_pop_to_identifier(expr->u.assign_expression.left
->u.identifier.u.declaration,
expr->line_number,
ob);
}
TEST(generateExpression, binary_op) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::expression e1 = stan::lang::int_literal(5);
stan::lang::double_literal b(-2.0);
b.string_ = "-2.0";
stan::lang::expression e2(b);
stan::lang::expression e3(stan::lang::binary_op(e1,"+",e2));
generate_expression(e3, user_facing, msgs);
EXPECT_EQ(msgs.str(), "(5 + -2.0)");
}
TEST(generateExpression, variable_expr) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::matrix_type tMat;
stan::lang::bare_array_type d2_ar(tMat,2);
stan::lang::bare_expr_type bet(d2_ar);
stan::lang::variable v("foo");
v.set_type(bet);
stan::lang::expression e1 = v;
generate_expression(e1, user_facing, msgs);
EXPECT_EQ(msgs.str(), "foo");
}
static void
generate_if_statement(DVM_Executable *exe, Block *block,
Statement *statement, OpcodeBuf *ob)
{
int if_false_label;
int end_label;
IfStatement *if_s = &statement->u.if_s;
Elsif *elsif;
generate_expression(exe, block, if_s->condition, ob);
if_false_label = get_label(ob);
generate_code(ob, statement->line_number,
DVM_JUMP_IF_FALSE, if_false_label);
generate_statement_list(exe, if_s->then_block,
if_s->then_block->statement_list, ob);
end_label = get_label(ob);
generate_code(ob, statement->line_number, DVM_JUMP, end_label);
set_label(ob, if_false_label);
for (elsif = if_s->elsif_list; elsif; elsif = elsif->next) {
generate_expression(exe, block, elsif->condition, ob);
if_false_label = get_label(ob);
generate_code(ob, statement->line_number, DVM_JUMP_IF_FALSE,
if_false_label);
generate_statement_list(exe, elsif->block,
elsif->block->statement_list, ob);
generate_code(ob, statement->line_number, DVM_JUMP, end_label);
set_label(ob, if_false_label);
}
if (if_s->else_block) {
generate_statement_list(exe, if_s->else_block,
if_s->else_block->statement_list,
ob);
}
set_label(ob, end_label);
}
static void
generate_expression_statement(DVM_Executable *exe, Block *block,
Expression *expr, OpcodeBuf *ob)
{
if (expr->kind == ASSIGN_EXPRESSION) {
generate_assign_expression(exe, block, expr, ob, DVM_TRUE);
} else if (expr->kind == INCREMENT_EXPRESSION
|| expr->kind == DECREMENT_EXPRESSION) {
generate_inc_dec_expression(exe, block, expr, expr->kind, ob,
DVM_TRUE);
} else {
generate_expression(exe, block, expr, ob);
generate_code(ob, expr->line_number, DVM_POP);
}
}
TEST(generateExpression, fun_expr) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::double_literal dblLit(5.1);
dblLit.string_ = "5.1";
stan::lang::expression e1 = dblLit;
std::vector<stan::lang::expression> args;
args.push_back(e1);
stan::lang::fun f("x", args);
f.type_ = stan::lang::void_type();
stan::lang::expression e2 = f;
generate_expression(e2, user_facing, msgs);
EXPECT_EQ(msgs.str(), "x(5.1)");
}
TEST(generateExpression, conditional_op) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::expression e1 = stan::lang::int_literal(5);
stan::lang::double_literal a(2.0);
a.string_ = "2.0";
stan::lang::expression e2(a);
stan::lang::double_literal b(-2.0);
b.string_ = "-2.0";
stan::lang::expression e3(b);
stan::lang::expression e4(stan::lang::conditional_op(e1,e2,e3));
generate_expression(e4, user_facing, msgs);
EXPECT_EQ(msgs.str(), "(5 ? 2.0 : -2.0 )");
}
static code_block *generate_let(code_block *parent, let_statement *let) {
code_system *system = parent->system;
define_clause *clause = let->clause;
do {
parent = generate_expression(parent, clause->value);
symbol_entry *entry = add_symbol(parent, clause->symbol_entry,
last_instruction(parent));
entry->type = resolve_type(system, copy_type(clause->value->type));
entry->exists = true;
clause = clause->next;
} while (clause);
return parent;
}
TEST(generateExpression, row_vector_expr) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::double_literal dblLit(5.1);
dblLit.string_ = "5.1";
stan::lang::expression e1 = dblLit;
std::vector<stan::lang::expression> elements;
elements.push_back(e1);
elements.push_back(e1);
stan::lang::row_vector_expr rv1(elements);
stan::lang::expression e2 = rv1;
generate_expression(e2, user_facing, msgs);
EXPECT_NE(msgs.str().find("stan::math::to_row_vector"), std::string::npos);
EXPECT_NE(msgs.str().find("stan::math::array_builder<double"), std::string::npos);
EXPECT_NE(msgs.str().find("add(5.1).array()"), std::string::npos);
}
TEST(generateExpression, array_expr) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::double_literal dblLit(5.1);
dblLit.string_ = "5.1";
stan::lang::expression e1 = dblLit;
std::vector<stan::lang::expression> elements;
elements.push_back(e1);
elements.push_back(e1);
elements.push_back(e1);
stan::lang::array_expr ar1;
ar1.args_ = elements;
ar1.type_ = stan::lang::bare_array_type(stan::lang::double_type());
stan::lang::expression e2 = ar1;
generate_expression(e2, user_facing, msgs);
EXPECT_NE(msgs.str().find("static_cast<std::vector<double"), std::string::npos);
EXPECT_NE(msgs.str().find("stan::math::array_builder<double"), std::string::npos);
EXPECT_NE(msgs.str().find("add(5.1).array()"), std::string::npos);
}
static void
generate_inc_dec_expression(DVM_Executable *exe, Block *block,
Expression *expr, ExpressionKind kind,
OpcodeBuf *ob, DVM_Boolean is_toplevel)
{
generate_expression(exe, block, expr->u.inc_dec.operand, ob);
if (kind == INCREMENT_EXPRESSION) {
generate_code(ob, expr->line_number, DVM_INCREMENT);
} else {
DBG_assert(kind == DECREMENT_EXPRESSION, ("kind..%d\n", kind));
generate_code(ob, expr->line_number, DVM_DECREMENT);
}
if (!is_toplevel) {
generate_code(ob, expr->line_number, DVM_DUPLICATE);
}
generate_pop_to_identifier(expr->u.inc_dec.operand
->u.identifier.u.declaration,
expr->line_number,
ob);
}
