void multi_concept_model_generator::
populate(const unsigned int position, result_type& v) {
v.prop_1(create_int(position + 0));
v.prop_0(create_std_string(position + 1));
v.prop_2(create_int(position + 2));
v.prop_10(create_int(position + 3));
}
/* code to create classes C and D */
static void setup_classes()
{
#ifdef TAGGING
pyobj zero = inject_int(0);
pyobj one = inject_int(1);
#else
pyobj zero = create_int(0);
pyobj one = create_int(1);
#endif
pyobj list0 = create_list(zero);
pyobj list1 = create_list(one);
// class C:
// def m(self):
// return self.f
C = create_class(list0);
// Add method m to the class.
set_attr(C, "m", create_closure(C_m, list0));
// class D(C):
// def m(self):
// return self.f + 1
set_subscript(list1, zero, C); // list1[0] = C
D = create_class(list1);
pyobj D_m_closure = create_closure(D_m, list0);
set_attr(D, "m", create_closure(D_m, list0));
pyobj D_n_closure = create_closure(D_n, list0);
set_attr(D, "n", create_closure(D_n, list0));
}
void multiple_refinement_concept_model_generator::
populate(const unsigned int position, result_type& v) {
v.prop_0(create_int(position + 0));
v.prop_1(create_int(position + 1));
v.prop_2(create_int(position + 2));
v.prop_3(create_int(position + 3));
v.prop_10(create_int(position + 4));
}
void class_c_generator::
populate(const unsigned int position, result_type& v) {
v.prop_0(create_int(position + 0));
v.prop_1(create_std_vector_dogen_std_model_class_a(position + 1));
v.prop_2(create_std_vector_dogen_std_model_class_a_unversioned_key(position + 2));
v.prop_3(create_std_vector_dogen_std_model_class_a_versioned_key(position + 3));
}
Bignum* square_root(Bignum *n, Bignum *r) {
Bignum temp, resto, r1, r2;
char buffer[LEN];
int pos, pos2, tambuf, aux;
temp.sinal = resto.sinal = 1;
if (n->len%2 == 1)
n->digits[n->len++] = '0';
aux = (int) (sqrt((n->digits[n->len-1] - '0')*10 + n->digits[n->len-2]-'0') + 1.0e-7);
create_int((n->digits[n->len-1] - '0')*10 + n->digits[n->len-2]-'0' - aux*aux,&resto);
buffer[0] = aux + '0';
tambuf = 1;
for (pos=n->len-3; pos > -1; pos-=2) {
shift(&resto,2);
resto.digits[1] = n->digits[pos], resto.digits[0] = n->digits[pos-1];
no_zeroes(&resto);
mult_int(create(buffer,tambuf,&temp),2,&r1);
shift(copy(&temp,&r1),1);
for (pos2=1; pos2 < 10; pos2++) {
temp.digits[0] = pos2 + '0';
if (compare(mult_int(&temp,pos2,&r1),&resto) > 0)
break;
}
buffer[tambuf++] = pos2 - 1 + '0';
temp.digits[0] = pos2 - 1 + '0';
copy(&resto,subtract(&resto,mult_int(&temp,pos2-1,&r1),&r2));
}
create(buffer,tambuf,r);
no_zeroes(n);
return r;
}
Bignum* power_int(Bignum *n, int p, Bignum *r) {
Bignum temp, aux;
if (p == 0) return create_int(1,r);
if (p == 1) return copy(r,n);
power_int(n,p/2,&temp);
if (p&1)
return multiply(multiply(&temp,&temp,&aux),n,r);
return multiply(&temp,&temp,r);
}
/*
* def m(self): return self.f + 1
*/
pyobj D_m(pyobj self) {
pyobj f = get_attr(self, "f");
int i = project_int(f);
#ifdef TAGGING
return inject_int(i+1);
#else
return create_int(i+1);
#endif
}
Term* statically_infer_length_func(Branch* branch, Term* term)
{
Term* input = term->input(0);
if (input->function == FUNCS.copy)
return statically_infer_length_func(branch, input->input(0));
if (input->function == FUNCS.list)
return create_int(branch, input->numInputs());
if (input->function == LIST_APPEND_FUNC) {
Term* leftLength = apply(branch, FUNCS.length, TermList(input->input(0)));
return apply(branch, FUNCS.add, TermList(
statically_infer_length_func(branch, leftLength),
create_int(branch, 1)));
}
// Give up
std::cout << "statically_infer_length_func didn't understand: "
<< input->function->name << std::endl;
return create_symbol_value(branch, name_Unknown);
}
Term* statically_infer_length_func(Block* block, Term* term)
{
Term* input = term->input(0);
if (input->function == FUNCS.copy)
return statically_infer_length_func(block, input->input(0));
if (input->function == FUNCS.list)
return create_int(block, input->numInputs());
if (input->function == FUNCS.list_append) {
Term* leftLength = apply(block, FUNCS.length, TermList(input->input(0)));
return apply(block, FUNCS.add, TermList(
statically_infer_length_func(block, leftLength),
create_int(block, 1)));
}
// Give up
std::cout << "statically_infer_length_func didn't understand: "
<< input->function->name << std::endl;
return create_string(block, "unknown");
}
Bignum* power(Bignum *base, Bignum *exp, Bignum *r) {
Bignum aux1, aux2;
int resto;
if (exp->len == 1 && exp->digits[0] == '0')
return create_int(1,r);
if (exp->len == 1 && exp->digits[0] == '1')
return copy(r,base);
div_int(exp,2,&aux1,&resto);
power(base,&aux1,&aux2);
if (resto == 0)
return multiply(&aux2,&aux2,r);
return multiply(multiply(&aux2,&aux2,&aux1),base,r);
}
void generate_source_for_function_calls() {
Branch branch;
Term* a = create_int(&branch, 5, "a");
Term* b = create_int(&branch, 9, "b");
Term* c = apply(&branch, "add", TermList(a,b));
test_assert(should_print_term_source_line(a));
test_assert(should_print_term_source_line(b));
test_assert(should_print_term_source_line(c));
test_equals(get_branch_source_text(&branch), "a = 5\nb = 9\nadd(a, b)");
// Same test with anonymous values
branch.clear();
Term* d = create_int(&branch, 3);
Term* e = create_int(&branch, 4);
/*Term* f =*/ apply(&branch, "add", TermList(d,e));
/*
TODO, fix this
test_assert(!should_print_term_source_line(d));
test_assert(!should_print_term_source_line(e));
test_assert(should_print_term_source_line(f));
test_equals(get_branch_source_text(branch), "add(3, 4)");
// Do a test where some calls are parser-created, and then user-created calls
// are added.
branch.clear();
branch.compile("a = 1");
branch.compile("b = 2");
a = create_int(branch, 3, "c");
b = create_int(branch, 4, "d");
apply(branch, "add", TermList(a,b));
test_equals(get_branch_source_text(branch), "a = 1\nb = 2\nc = 3\nd = 4\nadd(c, d)");
*/
}
void a_class_generator::
populate(const unsigned int position, result_type& v) {
v.bool_property(create_bool(position + 0));
v.char_property(create_char(position + 1));
v.uchar_property(create_unsigned_char(position + 2));
v.int_property(create_int(position + 3));
v.uint_property(create_unsigned_int(position + 4));
v.long_property(create_long(position + 5));
v.ulong_property(create_unsigned_long(position + 6));
v.long_long_property(create_long_long(position + 7));
v.ulong_long_property(create_unsigned_long_long(position + 8));
v.short_property(create_short(position + 9));
v.ushort_property(create_unsigned_short(position + 10));
v.double_property(create_double(position + 11));
v.float_property(create_float(position + 12));
}
/* Eval the args given to -test and computes the function, unused */
ast_st* eval_args(int argc, const char ** argv, int par, int * index) {
ast_st *tmp1, *tmp2;
kind_en op = Nothing;
int i;
for (i = 0; i < argc; i++) {
if (!strcmp(argv[i],"(")) {
tmp2 = eval_args(argc-i, argv+i+1, 1, index);
if (tmp2 == NULL) return NULL;
i += *index;
}
else if (!strcmp(argv[i], ")"))
if (par) {
*index = i+1;
return tmp1;
}
else {
printf("Closing parenthesis unmatched\n");
return NULL;
}
else if (is_op(argv[i])) {
op = get_op(argv[i]);
}
else {
int val = !strcmp(argv[i], "") ? 0 : atoi(argv[i]);
tmp2 = create_int(val);
if (op != Nothing) {
tmp1 = create_node(op, tmp1, tmp2);
op = Nothing;
} else tmp1 = tmp2;
}
}
if (!par)
return tmp1;
else {
printf("Opening parenthesis unmatched\n");
return NULL;
}
}
obj fn_do_events (obj args)
{
(void) args;
uint8_t n = 0;
if (tick_action && millis () - last_time >= timeout)
{
n += 1;
last_time = millis ();
apply_internal (tick_action, obj_NIL);
}
if (serial_action && Serial.available ())
{
n += 1;
apply_internal (serial_action, obj_NIL);
}
return (create_int (n));
}
void test_if_joining()
{
Branch branch;
// Test that a name defined in one branch is not rebound in outer scope
branch.eval("if true { apple = 5 }");
test_assert(!branch.contains("apple"));
// Test that a name which exists in the outer scope is rebound
Term* original_banana = create_int(&branch, 10, "banana");
branch.eval("if true { banana = 15 }");
test_assert(branch["banana"] != original_banana);
// Test that if a name is defined in both 'if' and 'else' branches, that it gets
// defined in the outer scope.
branch.eval("if true { Cardiff = 5 } else { Cardiff = 11 }");
test_assert(branch.contains("Cardiff"));
// Test that the type of the joined name is correct
branch.compile("if true { a = 4 } else { a = 5 }; a = a");
test_equals(get_output_type(branch["a"])->name, "int");
}
void simple_concept_model_generator::
populate(const unsigned int position, result_type& v) {
v.prop_0(create_int(position + 0));
v.prop_1(create_dogen_test_models_stereotypes_value(position + 1));
v.prop_10(create_int(position + 2));
}
void class_c_generator::
populate(const unsigned int position, result_type& v) {
v.prop_0(create_int(position + 0));
v.prop_1(create_std_vector_dogen_test_models_boost_model_class_a(position + 1));
}
int main()
{
setup_classes();
// c = C()
pyobj c = create_object(C);
// d = D()
pyobj d = create_object(D);
// TODO: call the __init__ method if it exists
#ifdef TAGGING
pyobj one = inject_int(1);
pyobj three = inject_int(3);
#else
pyobj one = create_int(1);
pyobj three = create_int(3);
#endif
// c.f = 1
set_attr(c, "f", one);
// d.f = 1
set_attr(d, "f", one);
pyobj i, j, k, h;
// i = c.m()
{
pyobj meth = get_attr(c, "m");
pyobj fun = get_function(meth);
void *fp = get_fun_ptr(fun);
pyobj (*f)(pyobj) = (pyobj (*)(pyobj)) fp; // cast to a function pointer type
i = f(get_receiver(meth));
}
// j = d.m()
{
pyobj meth = get_attr(d, "m");
pyobj fun = get_function(meth);
void *fp = get_fun_ptr(fun);
pyobj (*f)(pyobj) = (pyobj (*)(pyobj)) fp; // cast to a function pointer type
j = f(get_receiver(meth));
}
// d.n(3)
{
pyobj (*f)(pyobj, pyobj) = (pyobj (*)(pyobj, pyobj)) get_fun_ptr_from_attr(d, "n");
f(d, three);
}
// k = d.m()
{
pyobj meth = get_attr(d, "m");
pyobj fun = get_function(meth);
void *fp = get_fun_ptr(fun);
pyobj (*f)(pyobj) = (pyobj (*)(pyobj)) fp; // cast to a function pointer type
k = f(get_receiver(meth));
}
// h = i + j + k
{
#ifdef TAGGING
// optimized, but assumes i and j are integers
// h = i + j + k
// unoptimized, but checks that i and j are integers
h = inject_int(project_int(i) + project_int(j) + project_int(k));
#else
h = create_int(project_int(i) + project_int(j) + project_int(k));
#endif
}
// print i, j, k
print_any(i);
print_any(j);
print_any(k);
print_any(h);
return 0;
}
node_type factory::create_list(const std::list<long long> &other) {
boost::shared_ptr<list_node_interface> node(new list_node);
BOOST_FOREACH(const long long &v, other) {
node->push_back(create_int(v));
}
void identity_and_other_ver_unversioned_key_generator::
populate(const unsigned int position, result_type& v) {
v.prop_0(create_int(position + 0));
}
void class_derived_generator::
populate(const unsigned int position, result_type& v) {
dogen::boost_model::class_base_generator::populate(position, v);
v.prop_1(create_int(position + 0));
}
void just_identity_generator::
populate(const unsigned int position, result_type& v) {
v.prop_0(create_int(position + 0));
}
void parent_with_members_generator::
populate(const unsigned int position, result_type& v) {
v.prop_0(create_int(position + 0));
}
void first_class_generator::
populate(const unsigned int position, result_type& v) {
v.public_attribute(create_int(position + 0));
v.private_attribute(create_int(position + 1));
}
void child_generator::
populate(const unsigned int position, result_type& v) {
dogen::trivial_inheritance::parent_outside_generator::populate(position, v);
v.prop_1(create_int(position + 0));
}
void keyed_in_package_generator::
populate(const unsigned int position, result_type& v) {
v.prop_0(create_int(position + 0));
}
void class_3_generator::
populate(const unsigned int position, result_type& v) {
v.prop_0(create_int(position + 0));
}
void composite_identity_generator::
populate(const unsigned int position, result_type& v) {
v.prop_0(create_int(position + 0));
v.prop_1(create_int(position + 1));
v.prop_2(create_int(position + 2));
}
pointer parse_number(parser* parse)
{
size_t len = 0;
bool isFloat = false;
bool isHex = false;
bool isBinary = false;
const char* Start = parse->curr;
while(!is_delimiter(*parse->curr))
{
if(*parse->curr == '.')
isFloat = true;
if(is_number_char(*parse->curr) ||
(isHex && is_extended_hex_char(*parse->curr)))
len++;
else if(len == 1 &&
*parse->curr == 'x' &&
*Start == '0')
{
len++;
isHex = true;
}
else if(len == 0 && *parse->curr == 'b')
isBinary = true;
else
return parser_error(parse, "Unexpected char '%c' in number literal.", *parse->curr);
parse->curr++;
}
{
int TotalIs = isHex + isBinary + isFloat;
if(TotalIs > true)
{
char* buffer = new char[len+1];
strncpy(buffer, Start, len);
buffer[len] = '\0';
parser_error(parse, "Unexpected number literal: %s.", buffer);
delete buffer;
return NIL;
}
}
if(isFloat)
{
char* buffer = new char[len+1];
strncpy(buffer, Start, len);
buffer[len] = '\0';
float ret = atof(buffer);
delete buffer;
return create_real(ret);
}
else
{
// Might be smart to use a buffer here, in case strtol doesn't see all delimiters as we do.
int ret;
if(isHex)
ret = strtol(Start + 2, NULL, 16);
else if(isBinary)
ret = strtol(Start + 1, NULL, 2);
else
ret = strtol(Start, NULL, 10);
return create_int(ret);
}
}
void base_with_concept_generator::
populate(const unsigned int position, result_type& v) {
v.prop_0(create_int(position + 0));
v.prop_2(create_int(position + 1));
}
