void integer_expression(Array* a, int d, bool& success, int& _out, bool* tape__ANONYMOUS_s104/* len = 143 */, int& tape_index__ANONYMOUS_s105) {
_out = 0;
assertion ((d) > (0));;
if ((d) == (1)) {
success = 1;
_out = 0;
return;
}
bool integer_success=0;
int zp_s72=0;
integer_expression(a, d - 1, integer_success, zp_s72, tape__ANONYMOUS_s104, tape_index__ANONYMOUS_s105);
Array* l_s74=NULL;
bool array_success=0;
array_expression(a, d - 1, array_success, l_s74, tape__ANONYMOUS_s104, tape_index__ANONYMOUS_s105);
bool c1_s76=0;
flip(c1_s76, tape__ANONYMOUS_s104, tape_index__ANONYMOUS_s105);
bool c2_s78=0;
flip(c2_s78, tape__ANONYMOUS_s104, tape_index__ANONYMOUS_s105);
bool c3_s80=0;
flip(c3_s80, tape__ANONYMOUS_s104, tape_index__ANONYMOUS_s105);
if (c1_s76 && c2_s78) {
success = 1;
_out = 0;
return;
}
if (c1_s76 && !(c2_s78)) {
success = integer_success;
_out = zp_s72 + 1;
return;
}
if (!(c1_s76) && c2_s78) {
success = integer_success;
_out = zp_s72 - 1;
return;
}
if (c3_s80) {
if (array_success) {
bool car_success=0;
int r_s82=0;
car(l_s74, car_success, r_s82);
success = car_success;
_out = r_s82;
return;
}
success = 0;
_out = 0;
return;
}
success = array_success;
_out = l_s74->s;
return;
}
void dynamic_shader_format::load_shader(boost::filesystem::path const& filename) {
std::string extension = filename.extension().string();
bool parse_outputs = false;
if ((extension.compare(".fs") == 0) || (extension.compare(".frag") == 0)) {
obj::shader_base::create_shader< fshd::type::gl_fragment_shader >();
parse_outputs = true;
} else if ((extension.compare(".vs") == 0) || (extension.compare(".vert") == 0)) {
obj::shader_base::create_shader< fshd::type::gl_vertex_shader >();
} else if ((extension.compare(".gs") == 0) || (extension.compare(".geom") == 0)) {
obj::shader_base::create_shader< fshd::type::gl_geometry_shader >();
} else {
__gtulu_error() << "Unknown shader extension " << extension
<< ", please use one of .fs/.frag, .gs/.geom or .vs/.vert.";
}
std::string source = gu::file::get_contents(filename);
obj::shader_base::set_source(source.c_str());
outputs_.clear();
if (parse_outputs) {
boost::regex expression("out\\s+(\\S+)\\s+(\\S+);");
boost::regex array_expression("\\s*(\\S+)\\s*\\[(\\S*)\\]\\s*");
boost::sregex_iterator it(source.begin(), source.end(), expression);
boost::sregex_iterator end;
std::uint32_t id = 0;
while (it != end) {
std::string type_name = it->str(1);
std::string name = it->str(2);
std::uint32_t size = 1;
boost::sregex_iterator name_it(name.begin(), name.end(), array_expression);
boost::sregex_iterator type_it(type_name.begin(), type_name.end(), array_expression);
// We've found a static sized output vector, that's really nice...
if (name_it != end) {
name = name_it->str(1);
size = boost::lexical_cast< std::uint32_t >(name_it->str(2));
// We've just found a dynamic sized output vector, what a wonderful idea...
} else if (type_it != end) {
type_name = type_it->str(1);
size = -1;
}
outputs_.push_back(output_info(id++, name, fout::format::get(type_name), size, -1, -1));
++it;
}
}
} // load_shader
static sl_node_base_t*
primary_expression(sl_parse_state_t* ps)
{
sl_token_t* tok;
sl_node_base_t* node;
switch(peek_token(ps)->type) {
case SL_TOK_INTEGER:
tok = next_token(ps);
return sl_make_immediate_node(ps, sl_integer_parse(ps->vm, tok->as.str.buff, tok->as.str.len));
case SL_TOK_FLOAT:
return sl_make_immediate_node(ps, sl_make_float(ps->vm, next_token(ps)->as.dbl));
case SL_TOK_STRING:
tok = next_token(ps);
return sl_make_immediate_node(ps, sl_make_string(ps->vm, tok->as.str.buff, tok->as.str.len));
case SL_TOK_REGEXP:
return regexp_expression(ps);
case SL_TOK_CONSTANT:
tok = next_token(ps);
return sl_make_const_node(ps, NULL, sl_intern2(ps->vm, sl_make_string(ps->vm, tok->as.str.buff, tok->as.str.len)));
case SL_TOK_IDENTIFIER:
tok = next_token(ps);
return sl_make_var_node(ps, SL_NODE_VAR,
sl_make_string(ps->vm, tok->as.str.buff, tok->as.str.len));
case SL_TOK_TRUE:
next_token(ps);
return sl_make_immediate_node(ps, ps->vm->lib._true);
case SL_TOK_FALSE:
next_token(ps);
return sl_make_immediate_node(ps, ps->vm->lib._false);
case SL_TOK_NIL:
next_token(ps);
return sl_make_immediate_node(ps, ps->vm->lib.nil);
case SL_TOK_SELF:
next_token(ps);
return sl_make_self_node(ps);
case SL_TOK_IVAR:
tok = next_token(ps);
node = sl_make_var_node(ps, SL_NODE_IVAR,
sl_make_string(ps->vm, tok->as.str.buff, tok->as.str.len));
return node;
case SL_TOK_CVAR:
tok = next_token(ps);
node = sl_make_var_node(ps, SL_NODE_CVAR,
sl_make_string(ps->vm, tok->as.str.buff, tok->as.str.len));
return node;
case SL_TOK_IF:
case SL_TOK_UNLESS:
return if_expression(ps);
case SL_TOK_WHILE:
case SL_TOK_UNTIL:
return while_expression(ps);
case SL_TOK_FOR:
return for_expression(ps);
case SL_TOK_CLASS:
return class_expression(ps);
case SL_TOK_DEF:
return def_expression(ps);
case SL_TOK_LAMBDA:
return lambda_expression(ps);
case SL_TOK_TRY:
return try_expression(ps);
case SL_TOK_OPEN_BRACKET:
return array_expression(ps);
case SL_TOK_OPEN_PAREN:
return bracketed_expression(ps);
case SL_TOK_OPEN_BRACE:
return dict_expression(ps);
case SL_TOK_NEXT:
tok = next_token(ps);
if(!(ps->scope->flags & SL_PF_CAN_NEXT_LAST)) {
error(ps, sl_make_cstring(ps->vm, "next invalid outside loop"), tok);
}
return sl_make_singleton_node(ps, SL_NODE_NEXT);
case SL_TOK_LAST:
tok = next_token(ps);
if(!(ps->scope->flags & SL_PF_CAN_NEXT_LAST)) {
error(ps, sl_make_cstring(ps->vm, "last invalid outside loop"), tok);
}
return sl_make_singleton_node(ps, SL_NODE_LAST);
case SL_TOK_RANGE_EX:
next_token(ps);
return sl_make_singleton_node(ps, SL_NODE_YADA_YADA);
default:
unexpected(ps, peek_token(ps));
return NULL;
}
}
void array_expression(Array* a, int d, bool& success, Array*& _out, bool* tape__ANONYMOUS_s102/* len = 143 */, int& tape_index__ANONYMOUS_s103) {
_out = NULL;
assertion ((d) > (0));;
bool c1_s36=0;
flip(c1_s36, tape__ANONYMOUS_s102, tape_index__ANONYMOUS_s103);
if ((d) == (1)) {
success = 1;
if (c1_s36) {
Array* _out_s38=NULL;
empty_list(_out_s38);
_out = _out_s38;
return;
} else {
_out = a;
return;
}
}
bool c2_s40=0;
flip(c2_s40, tape__ANONYMOUS_s102, tape_index__ANONYMOUS_s103);
Array* lp_s42=NULL;
bool array_success=0;
array_expression(a, d - 1, array_success, lp_s42, tape__ANONYMOUS_s102, tape_index__ANONYMOUS_s103);
bool integer_success=0;
int z_s44=0;
integer_expression(a, d - 1, integer_success, z_s44, tape__ANONYMOUS_s102, tape_index__ANONYMOUS_s103);
bool cdr_success=0;
if ((d) > (2)) {
bool c3_s46=0;
flip(c3_s46, tape__ANONYMOUS_s102, tape_index__ANONYMOUS_s103);
Guard* g_s48=NULL;
bool guard_success=0;
guard_expression(a, d - 1, guard_success, g_s48, tape__ANONYMOUS_s102, tape_index__ANONYMOUS_s103);
if ((c1_s36 && c2_s40) && c3_s46) {
success = 1;
Array* _out_s50=NULL;
empty_list(_out_s50);
_out = _out_s50;
return;
}
if ((c1_s36 && c2_s40) && !(c3_s46)) {
success = 1;
_out = a;
return;
}
if ((c1_s36 && !(c2_s40)) && c3_s46) {
if (array_success) {
Array* r_s52=NULL;
cdr(lp_s42, cdr_success, r_s52);
success = cdr_success;
_out = r_s52;
return;
}
success = 0;
_out = lp_s42;
return;
}
if ((c1_s36 && !(c2_s40)) && !(c3_s46)) {
success = integer_success;
Array* _out_s54=NULL;
singleton(z_s44, _out_s54);
_out = _out_s54;
return;
}
if ((!(c1_s36) && c2_s40) && c3_s46) {
success = guard_success && array_success;
Array* _out_s56=NULL;
filter(g_s48, lp_s42, _out_s56);
_out = _out_s56;
return;
}
} else {
if (c2_s40 && c1_s36) {
success = 1;
Array* _out_s58=NULL;
empty_list(_out_s58);
_out = _out_s58;
return;
}
if (c2_s40 && !(c1_s36)) {
success = 1;
_out = a;
return;
}
if (!(c2_s40) && c1_s36) {
if (array_success) {
Array* r_s60=NULL;
cdr(lp_s42, cdr_success, r_s60);
success = cdr_success;
_out = r_s60;
return;
}
success = 0;
_out = lp_s42;
return;
}
if (!(c2_s40) && !(c1_s36)) {
success = integer_success;
Array* _out_s62=NULL;
singleton(z_s44, _out_s62);
_out = _out_s62;
return;
}
}
assertion (0);;
}
void recursive_expression(Array* a, int bnd, Array*& _out, bool* tape__ANONYMOUS_s106/* len = 143 */, int& tape_index__ANONYMOUS_s85) {
_out = NULL;
if ((bnd) < (0)) {
_out = NULL;
return;
}
tape_index__ANONYMOUS_s85 = 0;
bool s1=0;
bool s2=0;
bool s3=0;
bool s4=0;
bool s5=0;
bool s6=0;
Guard* g_s8=NULL;
guard_expression(a, 3, s1, g_s8, tape__ANONYMOUS_s106, tape_index__ANONYMOUS_s85);
int target_s10=0;
integer_expression(a, 3, s2, target_s10, tape__ANONYMOUS_s106, tape_index__ANONYMOUS_s85);
assertion ((tape_index__ANONYMOUS_s85) == (16));;
Array* b_s12=NULL;
array_expression(a, 4, s3, b_s12, tape__ANONYMOUS_s106, tape_index__ANONYMOUS_s85);
Array* x_s14=NULL;
array_expression(a, 4, s4, x_s14, tape__ANONYMOUS_s106, tape_index__ANONYMOUS_s85);
Array* x=NULL;
x = x_s14;
bool rx_s16=0;
flip(rx_s16, tape__ANONYMOUS_s106, tape_index__ANONYMOUS_s85);
Array* y_s18=NULL;
array_expression(a, 4, s5, y_s18, tape__ANONYMOUS_s106, tape_index__ANONYMOUS_s85);
Array* y=NULL;
y = y_s18;
bool ry_s20=0;
flip(ry_s20, tape__ANONYMOUS_s106, tape_index__ANONYMOUS_s85);
Array* z_s22=NULL;
array_expression(a, 4, s6, z_s22, tape__ANONYMOUS_s106, tape_index__ANONYMOUS_s85);
Array* z=NULL;
z = z_s22;
bool rz_s24=0;
flip(rz_s24, tape__ANONYMOUS_s106, tape_index__ANONYMOUS_s85);
assertion ((s1 && s2) && s3);;
bool _out_s26=0;
run_guard(g_s8, target_s10, _out_s26);
if (_out_s26) {
_out = b_s12;
return;
}
assertion ((s4 && s5) && s6);;
if (rz_s24) {
assertion ((x_s14->s) < (a->s));;
Array* x_s28=NULL;
recursive_expression(x_s14, bnd - 1, x_s28, tape__ANONYMOUS_s106, tape_index__ANONYMOUS_s85);
x = x_s28;
}
if (ry_s20) {
assertion ((y_s18->s) < (a->s));;
Array* y_s30=NULL;
recursive_expression(y_s18, bnd - 1, y_s30, tape__ANONYMOUS_s106, tape_index__ANONYMOUS_s85);
y = y_s30;
}
if (rz_s24) {
assertion ((z_s22->s) < (a->s));;
Array* z_s32=NULL;
recursive_expression(z_s22, bnd - 1, z_s32, tape__ANONYMOUS_s106, tape_index__ANONYMOUS_s85);
z = z_s32;
}
Array* _out_s34=NULL;
concatenate3(x, y, z, _out_s34);
_out = _out_s34;
return;
}
