void Terrain::generate(int seed)
{
int i[MAP_SIZE_SMALL];
int range = 100;
int size = sizeof(i);
int number = 2 ^ 1;
i[0] = new_value(0, 100, range);
i[size] = new_value(0, 100, range);
while (size > 1)
{
int i1 = 0;
int i2 = size - 1;
for (int y = 1; y < number; y++)
{
}
number *= 2;
size /= 2;
}
}
unsigned Dialog::combo_box(const vector<wstring>& list_items, unsigned sel_idx, unsigned boxsize, FARDIALOGITEMFLAGS flags) {
DialogItem di;
di.type = DI_COMBOBOX;
di.x1 = x;
di.y1 = y;
if (boxsize == AUTO_SIZE) {
if (flags & DIF_DROPDOWNLIST) {
unsigned max_len = 1;
for (unsigned i = 0; i < list_items.size(); i++) {
if (max_len < list_items[i].size())
max_len = static_cast<unsigned>(list_items[i].size());
}
x += max_len + 5;
}
else
x = c_x_frame + client_xs;
}
else
x += boxsize;
if (x - c_x_frame > client_xs)
client_xs = x - c_x_frame;
di.x2 = x - 1 - 1; // -1 for down arrow
di.y2 = y;
di.flags = flags;
for (unsigned i = 0; i < list_items.size(); i++) {
if (di.list_idx)
new_value(list_items[i]);
else
di.list_idx = new_value(list_items[i]);
}
di.list_size = static_cast<unsigned>(list_items.size());
di.list_pos = sel_idx;
return new_item(di);
}
void
CRePair::new_value(uint *symbols_pair, uint *symbols_new_value, uint *k1, uint *j, uint pos)
{
uint izq,der;
izq=symbols_pair[2*pos];
der=symbols_pair[2*pos+1];
if (izq>max_value)
{
izq=izq-max_value-1;
if (symbols_new_value[izq] == 0)
{
symbols_new_value[izq]=*j;
bitset(symbols_new_bit,*j-1);
(*j)++;
new_value(symbols_pair,symbols_new_value,k1,j,izq);
}
else
{
symbols_new[*k1]=symbols_new_value[izq]+max_value;
(*j)++;
(*k1)++;
}
}
else
{
symbols_new[*k1]=izq;
(*j)++;
(*k1)++;
}
if (der>max_value)
{
der=der-max_value-1;
if (symbols_new_value[der] == 0)
{
symbols_new_value[der]=*j;
bitset(symbols_new_bit,*j-1);
(*j)++;
new_value(symbols_pair,symbols_new_value,k1,j,der);
}
else
{
symbols_new[*k1]=symbols_new_value[der]+max_value;
(*j)++;
(*k1)++;
}
}
else
{
symbols_new[*k1]=der;
(*j)++;
(*k1)++;
}
}
void test_hash_table_free_functions(void)
{
HashTable *hash_table;
int *key;
int *value;
int i;
/* Create a hash table, fill it with values */
hash_table = hash_table_new(int_hash, int_equal);
hash_table_register_free_functions(hash_table, free_key, free_value);
allocated_values = 0;
for (i=0; i<NUM_TEST_VALUES; ++i) {
key = new_key(i);
value = new_value(99);
hash_table_insert(hash_table, key, value);
}
assert(allocated_keys == NUM_TEST_VALUES);
assert(allocated_values == NUM_TEST_VALUES);
/* Check that removing a key works */
i = NUM_TEST_VALUES / 2;
hash_table_remove(hash_table, &i);
assert(allocated_keys == NUM_TEST_VALUES - 1);
assert(allocated_values == NUM_TEST_VALUES - 1);
/* Check that replacing an existing key works */
key = new_key(NUM_TEST_VALUES / 3);
value = new_value(999);
assert(allocated_keys == NUM_TEST_VALUES);
assert(allocated_values == NUM_TEST_VALUES);
hash_table_insert(hash_table, key, value);
assert(allocated_keys == NUM_TEST_VALUES - 1);
assert(allocated_values == NUM_TEST_VALUES - 1);
/* A free of the hash table should free all of the keys and values */
hash_table_free(hash_table);
assert(allocated_keys == 0);
assert(allocated_values == 0);
}
void test_set_free_function (void) {
Set* set;
int i;
int* value;
/* Create a set and fill it with 1000 values */
set = set_new (int_hash, int_equal);
set_register_free_function (set, free_value);
allocated_values = 0;
for (i = 0; i < 1000; ++i) {
value = new_value (i);
set_insert (set, value);
}
assert (allocated_values == 1000);
/* Test removing a value */
i = 500;
set_remove (set, &i);
assert (allocated_values == 999);
/* Test freeing the set */
set_free (set);
assert (allocated_values == 0);
}
GSList *math_string_to_infix(gchar *string)
{
GSList *infix = NULL;
gchar *expr = string;
for (; *expr; expr++) {
if (strchr("+-/*^()", *expr)) {
infix = g_slist_append(infix, new_operator(*expr));
} else if (strchr("@", *expr)) {
infix = g_slist_append(infix, new_variable(*expr));
} else if (strchr("-.1234567890", *expr)) {
gfloat value;
sscanf(expr, "%f", &value);
while (*expr && strchr(".1234567890", *expr))
expr++;
expr--;
infix = g_slist_append(infix, new_value(value));
} else if (!isspace(*expr)) {
g_print("Invalid token: [%c][%d]\n", *expr, *expr);
math_infix_free(infix, TRUE);
return NULL;
}
}
return infix;
}
void IllusionExcelFile::SetCellInt(long irow, long icolumn,int new_int)
{
COleVariant new_value((long)new_int);
excel_current_range_.ReleaseDispatch();
excel_current_range_ = excel_work_sheet_.get_Range(COleVariant(RCString(irow,icolumn)),covOptional);
excel_current_range_.put_Value2(new_value);
}
void DoubleValidator::OnChar(wxKeyEvent& event) {
int chr = event.GetKeyCode();
if (chr < WXK_SPACE || chr == WXK_DELETE || chr > WXK_START) {
event.Skip();
return;
}
if (chr == decimal_sep)
chr = '.';
auto str = new_value(static_cast<wxTextCtrl *>(GetWindow()), chr);
if (decimal_sep != '.')
replace(begin(str), end(str), (char)decimal_sep, '.');
double parsed;
bool can_parse = agi::util::try_parse(str, &parsed);
if ((min < 0 && str == '-') || str == '.')
event.Skip();
else if (can_parse && parsed >= min && parsed <= max)
event.Skip();
else if (can_parse && min < 0 && chr == '-') // allow negating an existing value even if it results in being out of range
event.Skip();
else if (!wxValidator::IsSilent())
wxBell();
}
int load_value (FILE *f, value *v, string *lnames)
{ value nv;
int tag;
if (!load_int (f, &tag)) return (0);
nv = new_value (tag);
nv -> dptr = (void *) lnames;
switch (tag)
{ case string_value:
if (!load_string (f, &nv -> u.str)) return (0);
break;
case integer_value:
if (!load_int (f, &nv -> u.inum)) return (0);
break;
case real_value:
if (!load_real(f, &nv -> u.rnum)) return (0);
break;
case tuple_value:
if (!load_value_list (f, &nv -> u.tuple, lnames)) return (0);
break;
case small_lattice_value:
if (!load_int (f, &nv -> u.slat)) return (0);
break;
case large_lattice_value:
if (!load_int_list (f, &nv -> u.elat)) return (0);
break;
default:
bad_tag (tag, "load_value");
};
*v = nv;
return (1);
};
void ReduceByKeyTransformer::handleReduceResult(vector<ReduceOperation*>& operations, const PbMessagePtr& key,
RddPartition* output, bool reuse_key) {
PbMessagePtr new_key;
PbMessagePtr new_value(output->getValueTemplate()->New());
if (reuse_key) {
new_key = key;
for (auto it = operations.begin(); it != operations.end(); ++it) {
if ((*it)->key) {
continue;
}
protobuf::MessageHelper().setMessageValue(new_value.get(), (*it)->descriptor, (*it)->getResult());
(*it)->reset(); /// clear reduce value for next group reduce loop
}
} else {
new_key.reset(output->getKeyTemplate()->New());
for (auto it = operations.begin(); it != operations.end(); ++it) {
if ((*it)->key) {
protobuf::MessageHelper().setMessageValue(new_key.get(), (*it)->descriptor, (*it)->getResult());
} else {
protobuf::MessageHelper().setMessageValue(new_value.get(), (*it)->descriptor, (*it)->getResult());
}
(*it)->reset(); /// clear reduce value for next group reduce loop
}
}
output->putLocal(new_key, new_value);
}
void LIRGenerator::do_AttemptUpdate(Intrinsic* x) {
assert(x->number_of_arguments() == 3, "wrong type");
LIRItem obj (x->argument_at(0), this); // AtomicLong object
LIRItem cmp_value (x->argument_at(1), this); // value to compare with field
LIRItem new_value (x->argument_at(2), this); // replace field with new_value if it matches cmp_value
// compare value must be in rdx,eax (hi,lo); may be destroyed by cmpxchg8 instruction
cmp_value.load_item_force(FrameMap::long0_opr);
// new value must be in rcx,ebx (hi,lo)
new_value.load_item_force(FrameMap::long1_opr);
// object pointer register is overwritten with field address
obj.load_item();
// generate compare-and-swap; produces zero condition if swap occurs
int value_offset = sun_misc_AtomicLongCSImpl::value_offset();
LIR_Opr addr = new_pointer_register();
__ leal(LIR_OprFact::address(new LIR_Address(obj.result(), value_offset, T_LONG)), addr);
LIR_Opr t1 = LIR_OprFact::illegalOpr; // no temp needed
LIR_Opr t2 = LIR_OprFact::illegalOpr; // no temp needed
__ cas_long(addr, cmp_value.result(), new_value.result(), t1, t2);
// generate conditional move of boolean result
LIR_Opr result = rlock_result(x);
__ cmove(lir_cond_equal, LIR_OprFact::intConst(1), LIR_OprFact::intConst(0), result, T_LONG);
}
AVS_Value * inline_avs_array_elt(AVS_Value * v, int index)
{
AVS_Value * ptr = 0;
ptr = new_value(1);
if(v)
*ptr = avs_array_elt( *v, index);
return ptr;
}
value new_tuple_value_from_array (int size, value *array)
{ value_list vl = new_value_list (size);
value nv = new_value (tuple_value);
int ix;
vl -> size = size;
for (ix = 0; ix < size; ix++) vl -> array[ix] = array[ix];
nv -> u.tuple = vl;
return (nv);
};
static inline GValue *
clone_value(const GValue *value)
{
GType type = G_VALUE_TYPE(value);
GValue *ret = new_value(type);
g_value_copy(value, ret);
return ret;
}
void CExcelFile::SetCellInt(long irow, long icolumn,int new_int)
{
COleVariant new_value((long)new_int);
CRange start_range = excel_work_sheet_.get_Range(COleVariant(_T("A1")),covOptional);
CRange write_range = start_range.get_Offset(COleVariant((long)irow -1),COleVariant((long)icolumn -1) );
write_range.put_Value2(new_value);
start_range.ReleaseDispatch();
write_range.ReleaseDispatch();
}
void IllusionExcelFile::SetCelltime(long irow, long icolumn, time_t new_time)
{
COleVariant new_value((COleDateTime)new_time);
CRange start_range = excel_work_sheet_.get_Range(COleVariant("A1"), covOptional);
CRange write_range = start_range.get_Offset(COleVariant((long)irow - 1), COleVariant((long)icolumn - 1));
write_range.put_Value2(new_value);
start_range.ReleaseDispatch();
write_range.ReleaseDispatch();
}
value new_large_lattice_value (int size, int *elat, string *lnames)
{ int_list il = new_int_list ();
value nv = new_value (large_lattice_value);
int ix;
room_int_list (il, size);
il -> size = size;
for (ix = 0; ix < size; ix++) il -> array[ix] = (elat)?(elat[ix]):0;
nv -> dptr = (void *) lnames;
nv -> u.elat = il;
return (nv);
};
void Dialog::frame(const wstring& text) {
if (text.size() > client_xs)
client_xs = text.size();
DialogItem di;
di.type = DI_DOUBLEBOX;
di.x1 = c_x_frame - 2;
di.y1 = c_y_frame - 1;
di.x2 = c_x_frame + client_xs + 1;
di.y2 = c_y_frame + client_ys;
di.text_idx = new_value(text);
new_item(di);
}
unsigned Dialog::separator(const wstring& text) {
DialogItem di;
di.type = DI_TEXT;
di.y1 = y;
di.y2 = y;
di.flags = DIF_SEPARATOR;
if (!text.empty()) {
di.flags |= DIF_CENTERTEXT;
di.text_idx = new_value(text);
}
return new_item(di);
}
unsigned Dialog::button(const wstring& text, FARDIALOGITEMFLAGS flags) {
DialogItem di;
di.type = DI_BUTTON;
di.x1 = x;
di.y1 = y;
x += get_label_len(text, flags) + 4;
if (x - c_x_frame > client_xs)
client_xs = x - c_x_frame;
di.y2 = y;
di.flags = flags;
di.text_idx = new_value(text);
return new_item(di);
}
static ex_value_t *
find_value (const ex_value_t *val)
{
ex_value_t *value;
value = Hash_FindElement (value_table, val);
if (value)
return value;
value = new_value ();
*value = *val;
Hash_AddElement (value_table, value);
return value;
}
void
fvalue_init(fvalue_t *fv, ftenum_t ftype)
{
ftype_t *ft;
FvalueNewFunc new_value;
FTYPE_LOOKUP(ftype, ft);
fv->ftype = ft;
new_value = ft->new_value;
if (new_value) {
new_value(fv);
}
}
/**
* Set a boolean property
* @param filter_param A RSFilterParam
* @param name The name of the property
* @param value A value to store
*/
void
rs_filter_param_set_boolean(RSFilterParam *filter_param, const gchar *name, const gboolean value)
{
GValue *val;
g_return_if_fail(RS_IS_FILTER_PARAM(filter_param));
g_return_if_fail(name != NULL);
g_return_if_fail(name[0] != '\0');
val = new_value(G_TYPE_BOOLEAN);
g_value_set_boolean(val, value);
rs_filter_param_set_gvalue(filter_param, name, val);
}
unsigned Dialog::check_box(const wstring& text, int value, FARDIALOGITEMFLAGS flags) {
DialogItem di;
di.type = DI_CHECKBOX;
di.x1 = x;
di.y1 = y;
x += get_label_len(text, flags) + 4;
if (x - c_x_frame > client_xs)
client_xs = x - c_x_frame;
di.y2 = y;
di.flags = flags;
di.selected = value;
di.text_idx = new_value(text);
return new_item(di);
}
t_value *create_value(t_value *values, char *name, char *value)
{
t_value *cur;
if (values == NULL)
{
return new_value(name, value);
}
cur = values;
while (cur->next != NULL)
{
if (strcmp(name, cur->name) == 0)
{
return NULL;
}
cur = cur->next;
}
cur->next = new_value(name, value);
return values;
}
/**
* Set a string property
* @param filter_param A RSFilterParam
* @param name The name of the property
* @param str NULL-terminated string to set (will be copied)
*/
void
rs_filter_param_set_string(RSFilterParam *filter_param, const gchar *name, const gchar *str)
{
GValue *val;
g_return_if_fail(RS_IS_FILTER_PARAM(filter_param));
g_return_if_fail(name != NULL);
g_return_if_fail(name[0] != '\0');
g_return_if_fail(str != NULL);
val = new_value(G_TYPE_STRING);
g_value_set_string(val, str);
rs_filter_param_set_gvalue(filter_param, name, val);
}
string& new_value() {
if (stack.empty()) return new_tree().data();
layer& l = stack.back();
switch (l.k) {
case leaf:
stack.pop_back();
return new_value();
case object:
l.k = key;
key_buffer.clear();
return key_buffer;
default:
return new_tree().data();
}
}
void Illusion_ExcelFile::set_cell_int(long iline, long icolumn, int new_int)
{
_variant_t new_value((long)new_int);
_variant_t v_pos("A1");
CRange start_range = excel_work_sheet_.get_Range(v_pos, CONST_VARIANT_OPTIONAL);
_variant_t v_row((long)iline - 1);
_variant_t v_column((long)icolumn - 1);
CRange write_range = start_range.get_Offset(v_row, v_column);
write_range.put_Value2(new_value);
start_range.ReleaseDispatch();
write_range.ReleaseDispatch();
}
/**
* Set a float property
* @param filter_param A RSFilterParam
* @param name The name of the property
* @param value A value to store
*/
void
rs_filter_param_set_float(RSFilterParam *filter_param, const gchar *name, const gfloat value)
{
GValue *val;
g_return_if_fail(RS_IS_FILTER_PARAM(filter_param));
g_return_if_fail(name != NULL);
g_return_if_fail(name[0] != '\0');
val = new_value(G_TYPE_FLOAT);
g_value_set_float(val, value);
rs_filter_param_set_gvalue(filter_param, name, val);
}
/**
* Set an object property
* @param filter_param A RSFilterParam
* @param name The name of the property
* @param value An object to store. Refcount will be incremented by one
*/
void
rs_filter_param_set_object(RSFilterParam *filter_param, const gchar *name, gpointer object)
{
GValue *val;
g_return_if_fail(RS_IS_FILTER_PARAM(filter_param));
g_return_if_fail(name != NULL);
g_return_if_fail(name[0] != '\0');
g_return_if_fail(G_IS_OBJECT(object));
val = new_value(G_OBJECT_TYPE(object));
g_value_set_object(val, object);
rs_filter_param_set_gvalue(filter_param, name, val);
}
