static int getfocus_cb(Ihandle *ih)
{
printf("GETFOCUS_CB(%s)\n", get_name(ih));
return IUP_DEFAULT;
}
bool Directory::Entry::is_special() const {
return get_name() == Path::CURRENT_DIRECTORY
||
get_name() == Path::PARENT_DIRECTORY;
}
void
nest::aeif_cond_alpha::update( Time const& origin,
const long_t from,
const long_t to )
{
assert(
to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() );
assert( from < to );
assert( State_::V_M == 0 );
for ( long_t lag = from; lag < to; ++lag )
{
double t = 0.0;
if ( S_.r_ > 0 )
--S_.r_;
// numerical integration with adaptive step size control:
// ------------------------------------------------------
// gsl_odeiv_evolve_apply performs only a single numerical
// integration step, starting from t and bounded by step;
// the while-loop ensures integration over the whole simulation
// step (0, step] if more than one integration step is needed due
// to a small integration step size;
// note that (t+IntegrationStep > step) leads to integration over
// (t, step] and afterwards setting t to step, but it does not
// enforce setting IntegrationStep to step-t; this is of advantage
// for a consistent and efficient integration across subsequent
// simulation intervals
while ( t < B_.step_ )
{
const int status = gsl_odeiv_evolve_apply( B_.e_,
B_.c_,
B_.s_,
&B_.sys_, // system of ODE
&t, // from t
B_.step_, // to t <= step
&B_.IntegrationStep_, // integration step size
S_.y_ ); // neuronal state
if ( status != GSL_SUCCESS )
throw GSLSolverFailure( get_name(), status );
// check for unreasonable values; we allow V_M to explode
if ( S_.y_[ State_::V_M ] < -1e3 || S_.y_[ State_::W ] < -1e6
|| S_.y_[ State_::W ] > 1e6 )
throw NumericalInstability( get_name() );
// spikes are handled inside the while-loop
// due to spike-driven adaptation
if ( S_.r_ > 0 )
S_.y_[ State_::V_M ] = P_.V_reset_;
else if ( S_.y_[ State_::V_M ] >= P_.V_peak_ )
{
S_.y_[ State_::V_M ] = P_.V_reset_;
S_.y_[ State_::W ] += P_.b; // spike-driven adaptation
S_.r_ = V_.RefractoryCounts_;
set_spiketime( Time::step( origin.get_steps() + lag + 1 ) );
SpikeEvent se;
kernel().event_delivery_manager.send( *this, se, lag );
}
}
S_.y_[ State_::DG_EXC ] += B_.spike_exc_.get_value( lag ) * V_.g0_ex_;
S_.y_[ State_::DG_INH ] += B_.spike_inh_.get_value( lag ) * V_.g0_in_;
// set new input current
B_.I_stim_ = B_.currents_.get_value( lag );
// log state data
B_.logger_.record_data( origin.get_steps() + lag );
}
}
/* Constructor reads symbol table entries beginning at entry 'i'. We can't pass an array of COFFSymbolEntry_disk structs
* because the disk size is 18 bytes, which is not properly aligned according to the C standard. Therefore we pass the actual
* section and table index. The symbol occupies the specified table slot and st_num_aux_entries additional slots. */
void
SgAsmCoffSymbol::ctor(SgAsmPEFileHeader *fhdr, SgAsmGenericSection *symtab, SgAsmGenericSection *strtab, size_t idx)
{
static const bool debug = false;
COFFSymbol_disk disk;
symtab->read_content_local(idx * COFFSymbol_disk_size, &disk, COFFSymbol_disk_size);
if (disk.st_zero == 0) {
p_st_name_offset = ByteOrder::le_to_host(disk.st_offset);
if (p_st_name_offset < 4) throw FormatError("name collides with size field");
std::string s = strtab->read_content_local_str(p_st_name_offset);
set_name(new SgAsmBasicString(s));
} else {
char temp[9];
memcpy(temp, disk.st_name, 8);
temp[8] = '\0';
set_name(new SgAsmBasicString(temp));
p_st_name_offset = 0;
}
p_st_name = get_name()->get_string();
p_st_section_num = ByteOrder::le_to_host(disk.st_section_num);
p_st_type = ByteOrder::le_to_host(disk.st_type);
p_st_storage_class = ByteOrder::le_to_host(disk.st_storage_class);
p_st_num_aux_entries = ByteOrder::le_to_host(disk.st_num_aux_entries);
/* Bind to section number. We can do this now because we've already parsed the PE Section Table */
ROSE_ASSERT(fhdr->get_section_table()!=NULL);
if (p_st_section_num > 0) {
p_bound = fhdr->get_file()->get_section_by_id(p_st_section_num);
ROSE_ASSERT(p_bound != NULL);
}
/* Make initial guesses for storage class, type, and definition state. We'll adjust them after reading aux entries. */
p_value = ByteOrder::le_to_host(disk.st_value);
p_def_state = SYM_DEFINED;
switch (p_st_storage_class) {
case 0: p_binding = SYM_NO_BINDING; break; /*none*/
case 1: p_binding = SYM_LOCAL; break; /*stack*/
case 2: p_binding = SYM_GLOBAL; break; /*extern*/
case 3: p_binding = SYM_GLOBAL; break; /*static*/
case 4: p_binding = SYM_LOCAL; break; /*register*/
case 5: p_binding = SYM_GLOBAL; break; /*extern def*/
case 6: p_binding = SYM_LOCAL; break; /*label*/
case 7: p_binding = SYM_LOCAL; break; /*label(undef)*/
case 8: p_binding = SYM_LOCAL; break; /*struct member*/
case 9: p_binding = SYM_LOCAL; break; /*formal arg*/
case 10: p_binding = SYM_LOCAL; break; /*struct tag*/
case 11: p_binding = SYM_LOCAL; break; /*union member*/
case 12: p_binding = SYM_GLOBAL; break; /*union tag*/
case 13: p_binding = SYM_GLOBAL; break; /*typedef*/
case 14: p_binding = SYM_GLOBAL; break; /*static(undef)*/
case 15: p_binding = SYM_GLOBAL; break; /*enum tag*/
case 16: p_binding = SYM_LOCAL; break; /*enum member*/
case 17: p_binding = SYM_GLOBAL; break; /*register param*/
case 18: p_binding = SYM_LOCAL; break; /*bit field*/
case 100: p_binding = SYM_GLOBAL; break; /*block(bb or eb)*/
case 101: p_binding = SYM_GLOBAL; break; /*function*/
case 102: p_binding = SYM_LOCAL; break; /*struct end*/
case 103: p_binding = SYM_GLOBAL; break; /*file*/
case 104: p_binding = SYM_GLOBAL; break; /*section*/
case 105: p_binding = SYM_WEAK; break; /*weak extern*/
case 107: p_binding = SYM_LOCAL; break; /*CLR token*/
case 0xff: p_binding = SYM_GLOBAL; break; /*end of function*/
}
switch (p_st_type & 0xf0) {
case 0x00: p_type = SYM_NO_TYPE; break; /*none*/
case 0x10: p_type = SYM_DATA; break; /*ptr*/
case 0x20: p_type = SYM_FUNC; break; /*function*/
case 0x30: p_type = SYM_ARRAY; break; /*array*/
}
/* Read additional aux entries. We keep this as 'char' to avoid alignment problems. */
if (p_st_num_aux_entries > 0) {
p_aux_data = symtab->read_content_local_ucl((idx+1)*COFFSymbol_disk_size, p_st_num_aux_entries * COFFSymbol_disk_size);
if (get_type() == SYM_FUNC && p_st_section_num > 0) {
/* Function */
unsigned bf_idx = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[0]));
unsigned size = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[4]));
unsigned lnum_ptr = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[8]));
unsigned next_fn_idx = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[12]));
unsigned res1 = ByteOrder::le_to_host(*(uint16_t*)&(p_aux_data[16]));
set_size(size);
if (debug) {
fprintf(stderr, "COFF aux func %s: bf_idx=%u, size=%u, lnum_ptr=%u, next_fn_idx=%u, res1=%u\n",
escapeString(p_st_name).c_str(), bf_idx, size, lnum_ptr, next_fn_idx, res1);
}
} else if (p_st_storage_class == 101 /*function*/ && (0 == p_st_name.compare(".bf") || 0 == p_st_name.compare(".ef"))) {
/* Beginning/End of function */
unsigned res1 = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[0]));
unsigned lnum = ByteOrder::le_to_host(*(uint16_t*)&(p_aux_data[4])); /*line num within source file*/
unsigned res2 = ByteOrder::le_to_host(*(uint16_t*)&(p_aux_data[6]));
unsigned res3 = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[8]));
unsigned next_bf = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[12])); /*only for .bf; reserved in .ef*/
unsigned res4 = ByteOrder::le_to_host(*(uint16_t*)&(p_aux_data[16]));
if (debug) {
fprintf(stderr, "COFF aux %s: res1=%u, lnum=%u, res2=%u, res3=%u, next_bf=%u, res4=%u\n",
escapeString(p_st_name).c_str(), res1, lnum, res2, res3, next_bf, res4);
}
} else if (p_st_storage_class == 2/*external*/ && p_st_section_num == 0/*undef*/ && get_value()==0) {
/* Weak External */
unsigned sym2_idx = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[0]));
unsigned flags = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[4]));
unsigned res1 = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[8]));
unsigned res2 = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[12]));
unsigned res3 = ByteOrder::le_to_host(*(uint16_t*)&(p_aux_data[16]));
if (debug) {
fprintf(stderr, "COFF aux weak %s: sym2_idx=%u, flags=%u, res1=%u, res2=%u, res3=%u\n",
escapeString(p_st_name).c_str(), sym2_idx, flags, res1, res2, res3);
}
} else if (p_st_storage_class == 103/*file*/ && 0 == p_st_name.compare(".file")) {
/* This symbol is a file. The file name is stored in the aux data as either the name itself or an offset
* into the string table. Replace the fake ".file" with the real file name. */
const COFFSymbol_disk *d = (const COFFSymbol_disk*) &(p_aux_data[0]);
if (0 == d->st_zero) {
rose_addr_t fname_offset = ByteOrder::le_to_host(d->st_offset);
if (fname_offset < 4) throw FormatError("name collides with size field");
set_name(new SgAsmBasicString(strtab->read_content_local_str(fname_offset)));
if (debug) {
fprintf(stderr, "COFF aux file: offset=%"PRIu64", name=\"%s\"\n",
fname_offset, get_name()->get_string(true).c_str());
}
} else {
/* Aux data contains a NUL-padded name; the NULs (if any) are not part of the name. */
ROSE_ASSERT(p_st_num_aux_entries == 1);
char fname[COFFSymbol_disk_size+1];
memcpy(fname, &(p_aux_data[0]), COFFSymbol_disk_size);
fname[COFFSymbol_disk_size] = '\0';
set_name(new SgAsmBasicString(fname));
if (debug)
fprintf(stderr, "COFF aux file: inline-name=\"%s\"\n", get_name()->get_string(true).c_str());
}
set_type(SYM_FILE);
} else if (p_st_storage_class == 3/*static*/ && NULL != fhdr->get_file()->get_section_by_name(p_st_name, '$')) {
/* Section */
unsigned size = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[0])); /*same as section header SizeOfRawData */
unsigned nrel = ByteOrder::le_to_host(*(uint16_t*)&(p_aux_data[4])); /*number of relocations*/
unsigned nln_ents = ByteOrder::le_to_host(*(uint16_t*)&(p_aux_data[6])); /*number of line number entries */
unsigned cksum = ByteOrder::le_to_host(*(uint32_t*)&(p_aux_data[8]));
unsigned sect_id = ByteOrder::le_to_host(*(uint16_t*)&(p_aux_data[12])); /*1-base index into section table*/
unsigned comdat = p_aux_data[14]; /*comdat selection number if section is a COMDAT section*/
unsigned res1 = p_aux_data[15];
unsigned res2 = ByteOrder::le_to_host(*(uint16_t*)&(p_aux_data[16]));
set_size(size);
set_type(SYM_SECTION);
if (debug) {
fprintf(stderr,
"COFF aux section: size=%u, nrel=%u, nln_ents=%u, cksum=%u, sect_id=%u, comdat=%u, res1=%u, res2=%u\n",
size, nrel, nln_ents, cksum, sect_id, comdat, res1, res2);
}
} else if (p_st_storage_class==3/*static*/ && (p_st_type & 0xf)==0/*null*/ &&
get_value()==0 && NULL!=fhdr->get_file()->get_section_by_name(p_st_name)) {
/* COMDAT section */
/*FIXME: not implemented yet*/
fprintf(stderr, "COFF aux comdat %s: (FIXME) not implemented yet\n", escapeString(p_st_name).c_str());
hexdump(stderr, (rose_addr_t) symtab->get_offset()+(idx+1)*COFFSymbol_disk_size, " ", p_aux_data);
} else {
fprintf(stderr, "COFF aux unknown %s: (FIXME) st_storage_class=%u, st_type=0x%02x, st_section_num=%d\n",
escapeString(p_st_name).c_str(), p_st_storage_class, p_st_type, p_st_section_num);
hexdump(stderr, symtab->get_offset()+(idx+1)*COFFSymbol_disk_size, " ", p_aux_data);
}
}
}
static int serial_tozip(lua_State *L)
{
serial_type *s = (serial_type*)auxiliar_checkclass(L, "core{serial}", 1);
int ktype, etype;
bool skip;
/* Allows & disallows */
lua_rawgeti(L, LUA_REGISTRYINDEX, s->allow); // -5
lua_rawgeti(L, LUA_REGISTRYINDEX, s->disallow); // -4
lua_rawgeti(L, LUA_REGISTRYINDEX, s->disallow2); // -3
/* table is in the stack at index 't' */
lua_pushvalue(L, 2); /* table */
lua_pushnil(L); /* first key */
const char *filename = get_name(L, s, -2);
/* Init the buffer */
s->buf = malloc(2 * 1024);
s->buflen = 2 * 1024;
s->bufpos = 0;
writeTblFixed(s, "d={}\n", 5);
writeTblFixed(s, "setLoaded('", 11);
writeTbl(s, get_name(L, s, -2));
writeTblFixed(s, "', d)\n", 6);
while (lua_next(L, -2) != 0)
{
skip = FALSE;
ktype = lua_type(L, -2);
etype = lua_type(L, -1);
if (s->allow != LUA_REFNIL)
{
lua_pushvalue(L, -2); lua_rawget(L, -7);
skip = lua_isnil(L, -1); lua_pop(L, 1);
}
else if (s->disallow != LUA_REFNIL)
{
lua_pushvalue(L, -2); lua_rawget(L, -6);
skip = !lua_isnil(L, -1); lua_pop(L, 1);
}
if (s->disallow2 != LUA_REFNIL)
{
lua_pushvalue(L, -2); lua_rawget(L, -5);
skip = !lua_isnil(L, -1); lua_pop(L, 1);
}
if (!skip)
{
writeTblFixed(s, "d[", 2);
tbl_basic_serialize(L, s, ktype, -2);
writeTblFixed(s, "]=", 2);
tbl_basic_serialize(L, s, etype, -1);
writeTblFixed(s, "\n", 1);
}
/* removes 'value'; keeps 'key' for next iteration */
lua_pop(L, 1);
}
writeTblFixed(s, "\nreturn d", 9);
push_save(s->zf, s->zfname, filename, s->buf, s->bufpos);
lua_pushboolean(L, TRUE);
return 1;
}
const char *
ep_crypto_keytype_name(int keytype)
{
return get_name(KeyTypeStrings, keytype);
}
static bool process_response_answer(char **data, uint16_t* data_len,
const char* payload, uint16_t payload_len, fieldset_t* list)
{
log_trace("dns", "call to process_response_answer, data_len: %d", *data_len);
// Payload is the start of the DNS packet, including header
// data is handle to the start of this RR
// data_len is a pointer to the how much total data we have to work with.
// This is awful. I'm bad and should feel bad.
uint16_t bytes_consumed = 0;
char* answer_name = get_name(*data, *data_len, payload, payload_len,
&bytes_consumed);
// Error.
if (answer_name == NULL) {
return 1;
}
assert(bytes_consumed > 0);
if ( (bytes_consumed + sizeof(dns_answer_tail)) > *data_len) {
free(answer_name);
return 1;
}
dns_answer_tail* tail = (dns_answer_tail*)(*data + bytes_consumed);
uint16_t type = ntohs(tail->type);
uint16_t class = ntohs(tail->class);
uint32_t ttl = ntohl(tail->ttl);
uint16_t rdlength = ntohs(tail->rdlength);
char* rdata = tail->rdata;
if ((rdlength + bytes_consumed + sizeof(dns_answer_tail)) > *data_len) {
free(answer_name);
return 1;
}
// Build our new question fieldset
fieldset_t *afs = fs_new_fieldset();
fs_add_unsafe_string(afs, "name", answer_name, 1);
fs_add_uint64(afs, "type", type);
if (type > MAX_QTYPE || qtype_qtype_to_strid[type] == BAD_QTYPE_VAL) {
fs_add_string(afs, "type_str", (char*) BAD_QTYPE_STR, 0);
} else {
// I've written worse things than this 3rd arg. But I want to be fast.
fs_add_string(afs, "type_str",
(char*)qtype_strs[qtype_qtype_to_strid[type]], 0);
}
fs_add_uint64(afs, "class", class);
fs_add_uint64(afs, "ttl", ttl);
fs_add_uint64(afs, "rdlength", rdlength);
// XXX Fill this out for the other types we care about.
if (type == DNS_QTYPE_NS || type == DNS_QTYPE_CNAME) {
uint16_t rdata_bytes_consumed = 0;
char* rdata_name = get_name(rdata, rdlength, payload, payload_len,
&rdata_bytes_consumed);
if (rdata_name == NULL) {
fs_add_uint64(afs, "rdata_is_parsed", 0);
fs_add_binary(afs, "rdata", rdlength, rdata, 0);
} else {
fs_add_uint64(afs, "rdata_is_parsed", 1);
fs_add_unsafe_string(afs, "rdata", rdata_name, 1);
}
} else if (type == DNS_QTYPE_MX) {
uint16_t rdata_bytes_consumed = 0;
if (rdlength <= 4) {
fs_add_uint64(afs, "rdata_is_parsed", 0);
fs_add_binary(afs, "rdata", rdlength, rdata, 0);
} else {
char* rdata_name = get_name(rdata + 2, rdlength-2, payload,
payload_len, &rdata_bytes_consumed);
if (rdata_name == NULL) {
fs_add_uint64(afs, "rdata_is_parsed", 0);
fs_add_binary(afs, "rdata", rdlength, rdata, 0);
} else {
// (largest value 16bit) + " " + answer + null
char* rdata_with_pref = xmalloc(5 + 1 + strlen(rdata_name) + 1);
uint8_t num_printed = snprintf(rdata_with_pref, 6, "%hu ",
ntohs( *(uint16_t*)rdata));
memcpy(rdata_with_pref + num_printed, rdata_name,
strlen(rdata_name));
fs_add_uint64(afs, "rdata_is_parsed", 1);
fs_add_unsafe_string(afs, "rdata", rdata_with_pref, 1);
}
}
} else if (type == DNS_QTYPE_TXT) {
if (rdlength >= 1 && (rdlength - 1) != *(uint8_t*)rdata ) {
log_warn("dns", "TXT record with wrong TXT len. Not processing.");
fs_add_uint64(afs, "rdata_is_parsed", 0);
fs_add_binary(afs, "rdata", rdlength, rdata, 0);
} else {
fs_add_uint64(afs, "rdata_is_parsed", 1);
char* txt = xmalloc(rdlength);
memcpy(txt, rdata + 1, rdlength-1);
fs_add_unsafe_string(afs, "rdata", txt, 1);
}
} else if (type == DNS_QTYPE_A) {
if (rdlength != 4) {
log_warn("dns", "A record with IP of length %d. Not processing.",
rdlength);
fs_add_uint64(afs, "rdata_is_parsed", 0);
fs_add_binary(afs, "rdata", rdlength, rdata, 0);
} else {
fs_add_uint64(afs, "rdata_is_parsed", 1);
fs_add_unsafe_string(afs, "rdata",
(char*) inet_ntoa( *(struct in_addr*)rdata ), 0);
}
} else if (type == DNS_QTYPE_AAAA) {
if (rdlength != 16) {
log_warn("dns", "AAAA record with IP of length %d. Not processing.",
rdlength);
fs_add_uint64(afs, "rdata_is_parsed", 0);
fs_add_binary(afs, "rdata", rdlength, rdata, 0);
} else {
fs_add_uint64(afs, "rdata_is_parsed", 1);
char* ipv6_str = xmalloc(INET6_ADDRSTRLEN);
inet_ntop(AF_INET6, (struct sockaddr_in6*)rdata,
ipv6_str,INET6_ADDRSTRLEN);
fs_add_unsafe_string(afs, "rdata", ipv6_str, 1);
}
} else {
fs_add_uint64(afs, "rdata_is_parsed", 0);
fs_add_binary(afs, "rdata", rdlength, rdata, 0);
}
// Now we're adding the new fs to the list.
fs_add_fieldset(list, NULL, afs);
// Now update the pointers.
*data = *data + bytes_consumed + sizeof(dns_answer_tail) + rdlength;
*data_len = *data_len - bytes_consumed - sizeof(dns_answer_tail) - rdlength;
log_trace("dns", "return success from process_response_answer, data_len: %d",
*data_len);
return 0;
}
int microwave::init(OBJECT *parent)
{
if(parent != NULL){
if((parent->flags & OF_INIT) != OF_INIT){
char objname[256];
gl_verbose("microwave::init(): deferring initialization on %s", gl_name(parent, objname, 255));
return 2; // defer
}
}
OBJECT *hdr = OBJECTHDR(this);
hdr->flags |= OF_SKIPSAFE;
if (load.voltage_factor==0) load.voltage_factor = 1.0;
if(shape.type == MT_UNKNOWN){
init_noshape();
gl_warning("This device, %s, is considered very experimental and has not been validated.", get_name());
// initial demand
update_state(0.0);
} else if(shape.type == MT_ANALOG){
if(1){
;
}
} else if(shape.type == MT_PULSED){
if(1){
;
}
} else if(shape.type == MT_MODULATED){
if(1){
;
}
} else if(shape.type == MT_QUEUED){
gl_error("queued loadshapes not supported ~ will attempt to run as an unshaped load");
shape.type = MT_UNKNOWN;
init_noshape();
// initial demand
update_state(0.0);
} else {
gl_error("unrecognized loadshape");
return 0;
}
load.total = load.power = standby_power;
// waiting this long to initialize the parent class is normal
return residential_enduse::init(parent);
}
bool Host::send_datagram(Datagram content) {
return link_->send_datagram(get_name(), content);
}
static int enterwindow_cb(Ihandle *ih)
{
printf("ENTERWINDOW_CB(%s)\n", get_name(ih));
return IUP_DEFAULT;
}
static int button_cb(Ihandle *ih,int but,int pressed,int x,int y,char* status)
{
printf("BUTTON_CB(%s, but=%c (%d), x=%d, y=%d [%s])\n", get_name(ih),(char)but,pressed,x,y, status);
return IUP_DEFAULT;
}
static int leavewindow_cb(Ihandle *ih)
{
printf("LEAVEWINDOW_CB(%s)\n", get_name(ih));
return IUP_DEFAULT;
}
static int killfocus_cb(Ihandle *ih)
{
printf("KILLFOCUS_CB(%s)\n", get_name(ih));
return IUP_DEFAULT;
}
static int help_cb(Ihandle* ih)
{
printf("HELP_CB(%s)\n", get_name(ih));
return IUP_DEFAULT;
}
int sfs_readdir(int fd, char *mem_pointer)
{
inode directory = get_null_inode();
locations index_block = NULL;
uint32_t inode_location = 0;
uint32_t i = 0;
uint32_t num_locations = 0;
int count = 0;
byte* buf = NULL;
if(fd >= 0 && fd < NUMOFL)
{
/* Validate the file descriptor */
if(validate_fd(fd) < 0)
{
/*
* file descriptor not found in swoft
*/
print_error(INVALID_FILE_DESCRIPTOR);
return -1;
}
/*
* Retrieve the contents of the directory's index block. Use the Inode
* to retrieve the names of the contents. Store the values into
* mem_pointer.
*/
directory = get_swoft_inode(fd);
/* If the inode is not a directory return an error */
if(directory.type != 1)
{
/*
* Invalid file type error
*/
print_error(INVALID_FILE_TYPE);
return -1;
}
/*
* Iterate through the index block
* when the directory is empty
*/
index_block = iterate_index(directory.location, NULL);
if(index_block == NULL)
{
/*
* Invalid index block
*/
print_error(INDEX_ALLOCATION_ERROR);
return -1;
}
num_locations = count_files_in_dir(directory.location);
if(num_locations < 0)
{
/*
* Invalid index block
*/
print_error(INDEX_ALLOCATION_ERROR);
return -1;
}
if(num_locations == 0)
{
/*
* Empty Directory Read
*/
print_error(DIRECTORY_EMPTY);
return 0;
}
int cur_index = get_index_entry(*get_inode(directory.location));
if(num_locations == cur_index)
{
reset_index_entry();
return 0;
}
char* name = get_name(index_block[cur_index]);
strcpy(mem_pointer, name);
/* Update the directory inode date last accessed and write the inode back to disk */
directory.date_last_accessed = time(NULL);
/* Get the inode location */
inode_location = get_inode_loc(fd);
buf = allocate_buf(buf, BLKSIZE);
buf = (byte *) copy_to_buf((byte *) &directory, (byte *) buf, sizeof(inode), BLKSIZE);
if(write_block(inode_location, buf) < 0)
{
free(buf);
print_error(DISK_WRITE_ERROR);
return -1;
}
free(buf);
/*
* return value > 0 for a successful read dir
* return value = 0 if there is no contents in dir
* return value < 0 for a unsuccessful read dir
*/
print_error(SUCCESS);
return 1;
}
print_error(UNKNOWN);
return -1;
}
void item_list_gen2_keyitemimpl::set_item(
int position,
pkmn::e_item item,
int amount
)
{
// Input validation.
int end_boundary = std::min<int>(_num_items, _capacity-1);
pkmn::enforce_bounds("Position", position, 0, end_boundary);
boost::lock_guard<item_list_gen2_keyitemimpl> lock(*this);
if(item == pkmn::e_item::NONE)
{
if(amount != 0)
{
throw std::invalid_argument("\"None\" entries must have an amount of 0.");
}
else
{
pkmn::enforce_bounds("Amount", amount, 0, 99);
}
}
else
{
pkmn::database::item_entry entry(item, get_game());
if(entry.get_pocket() != get_name())
{
throw std::invalid_argument("This item does not belong in this pocket.");
}
if(amount != 1)
{
throw std::out_of_range("Amount: valid value 1");
}
for(int item_index = 0; item_index < _num_items; ++item_index)
{
if((_item_slots[item_index].item == item) && (item_index != position))
{
// TODO: all error messages should have what slot item is in
std::string err_msg = "This item is already present in slot ";
err_msg.append(std::to_string(item_index));
err_msg.append(".");
throw std::invalid_argument(err_msg.c_str());
}
}
}
_item_slots[position].item = item;
_item_slots[position].amount = amount;
if((item == pkmn::e_item::NONE) && (position < end_boundary))
{
_item_slots.erase(_item_slots.begin()+position);
_item_slots.emplace_back(pkmn::item_slot(pkmn::e_item::NONE, 0));
--_num_items;
}
else
{
++_num_items;
}
_to_native();
}
void nest::hh_psc_alpha::update(Time const & origin, const long_t from, const long_t to)
{
assert(to >= 0 && (delay) from < Scheduler::get_min_delay());
assert(from < to);
for ( long_t lag = from ; lag < to ; ++lag )
{
double_t t = 0.0 ;
const double_t U_old = S_.y_[State_::V_M];
// numerical integration with adaptive step size control:
// ------------------------------------------------------
// gsl_odeiv_evolve_apply performs only a single numerical
// integration step, starting from t and bounded by step;
// the while-loop ensures integration over the whole simulation
// step (0, step] if more than one integration step is needed due
// to a small integration step size;
// note that (t+IntegrationStep > step) leads to integration over
// (t, step] and afterwards setting t to step, but it does not
// enforce setting IntegrationStep to step-t; this is of advantage
// for a consistent and efficient integration across subsequent
// simulation intervals
while ( t < B_.step_ )
{
const int status = gsl_odeiv_evolve_apply(B_.e_, B_.c_, B_.s_,
&B_.sys_, // system of ODE
&t, // from t
B_.step_, // to t <= step
&B_.IntegrationStep_, // integration step size
S_.y_); // neuronal state
if ( status != GSL_SUCCESS )
throw GSLSolverFailure(get_name(), status);
}
S_.y_[State_::DI_EXC] += B_.spike_exc_.get_value(lag) * V_.PSCurrInit_E_;
S_.y_[State_::DI_INH] += B_.spike_inh_.get_value(lag) * V_.PSCurrInit_I_;
// sending spikes: crossing 0 mV, pseudo-refractoriness and local maximum...
// refractory?
if ( S_.r_ > 0 )
--S_.r_;
else
// ( threshold && maximum )
if ( S_.y_[State_::V_M] >= 0 && U_old > S_.y_[State_::V_M])
{
S_.r_ = V_.RefractoryCounts_;
set_spiketime(Time::step(origin.get_steps()+lag+1));
SpikeEvent se;
network()->send(*this, se, lag);
}
// log state data
B_.logger_.record_data(origin.get_steps() + lag);
// set new input current
B_.I_stim_ = B_.currents_.get_value(lag);
}
}
void
nest::iaf_cond_exp_sfa_rr::update( Time const& origin,
const long from,
const long to )
{
assert(
to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() );
assert( from < to );
for ( long lag = from; lag < to; ++lag )
{
double t = 0.0;
// numerical integration with adaptive step size control:
// ------------------------------------------------------
// gsl_odeiv_evolve_apply performs only a single numerical
// integration step, starting from t and bounded by step;
// the while-loop ensures integration over the whole simulation
// step (0, step] if more than one integration step is needed due
// to a small integration step size;
// note that (t+IntegrationStep > step) leads to integration over
// (t, step] and afterwards setting t to step, but it does not
// enforce setting IntegrationStep to step-t; this is of advantage
// for a consistent and efficient integration across subsequent
// simulation intervals
while ( t < B_.step_ )
{
const int status = gsl_odeiv_evolve_apply( B_.e_,
B_.c_,
B_.s_,
&B_.sys_, // system of ODE
&t, // from t
B_.step_, // to t <= step
&B_.IntegrationStep_, // integration step size
S_.y_ ); // neuronal state
if ( status != GSL_SUCCESS )
{
throw GSLSolverFailure( get_name(), status );
}
}
S_.y_[ State_::G_EXC ] += B_.spike_exc_.get_value( lag );
S_.y_[ State_::G_INH ] += B_.spike_inh_.get_value( lag );
// absolute refractory period
if ( S_.r_ )
{ // neuron is absolute refractory
--S_.r_;
S_.y_[ State_::V_M ] = P_.V_reset_;
}
else
// neuron is not absolute refractory
if ( S_.y_[ State_::V_M ] >= P_.V_th_ )
{
S_.r_ = V_.RefractoryCounts_;
S_.y_[ State_::V_M ] = P_.V_reset_;
set_spiketime( Time::step( origin.get_steps() + lag + 1 ) );
S_.y_[ State_::G_SFA ] += P_.q_sfa;
S_.y_[ State_::G_RR ] += P_.q_rr;
SpikeEvent se;
kernel().event_delivery_manager.send( *this, se, lag );
}
// set new input current
B_.I_stim_ = B_.currents_.get_value( lag );
// log state data
B_.logger_.record_data( origin.get_steps() + lag );
}
}
const char *
ep_crypto_keyenc_name(int key_enc_alg)
{
return get_name(KeyEncStrings, key_enc_alg);
}
/**
* Member function updating the neuron state by integrating the ODE.
* @param origin
* @param from
* @param to
*/
void nest::aeif_cond_alpha_RK5::update( Time const& origin,
const long from,
const long to ) // proceed in time
{
assert(
to >= 0 && ( delay ) from < kernel().connection_manager.get_min_delay() );
assert( from < to );
assert( State_::V_M == 0 );
for ( long lag = from; lag < to; ++lag ) // proceed by stepsize B_.step_
{
double t = 0.0; // internal time of the integration period
if ( S_.r_ > 0 ) // decrease remaining refractory steps if non-zero
--S_.r_;
// numerical integration with adaptive step size control:
// ------------------------------------------------------
// The numerical integration of the model equations is performed by
// a Dormand-Prince method (5th order Runge-Kutta method with
// adaptive stepsize control) as desribed in William H. Press et
// al., “Adaptive Stepsize Control for Runge-Kutta”, Chapter 17.2
// in Numerical Recipes (3rd edition, 2007), 910-914. The solver
// itself performs only a single NUMERICAL integration step,
// starting from t and of size B_.IntegrationStep_ (bounded by
// step); the while-loop ensures integration over the whole
// SIMULATION step (0, step] of size B_.step_ if more than one
// integration step is needed due to a small integration stepsize;
// note that (t+IntegrationStep > step) leads to integration over
// (t, step] and afterwards setting t to step, but it does not
// enforce setting IntegrationStep to step-t; this is of advantage
// for a consistent and efficient integration across subsequent
// simulation intervals.
double& h = B_.IntegrationStep_; // numerical integration step
double& tend = B_.step_; // end of simulation step
const double& MAXERR = P_.MAXERR; // maximum error
const double& HMIN = P_.HMIN; // minimal integration step
double err;
double t_return = 0.0;
while ( t < B_.step_ ) // while not yet reached end of simulation step
{
bool done = false;
do
{
if ( tend - t < h ) // stop integration at end of simulation step
h = tend - t;
t_return = t + h; // update t
// k1 = f(told, y)
aeif_cond_alpha_RK5_dynamics( S_.y_, S_.k1 );
// k2 = f(told + h/5, y + h*k1 / 5)
for ( int i = 0; i < S_.STATE_VEC_SIZE; ++i )
S_.yin[ i ] = S_.y_[ i ] + h * S_.k1[ i ] / 5.0;
aeif_cond_alpha_RK5_dynamics( S_.yin, S_.k2 );
// k3 = f(told + 3/10*h, y + 3/40*h*k1 + 9/40*h*k2)
for ( int i = 0; i < S_.STATE_VEC_SIZE; ++i )
S_.yin[ i ] = S_.y_[ i ]
+ h * ( 3.0 / 40.0 * S_.k1[ i ] + 9.0 / 40.0 * S_.k2[ i ] );
aeif_cond_alpha_RK5_dynamics( S_.yin, S_.k3 );
// k4
for ( int i = 0; i < S_.STATE_VEC_SIZE; ++i )
S_.yin[ i ] = S_.y_[ i ]
+ h * ( 44.0 / 45.0 * S_.k1[ i ] - 56.0 / 15.0 * S_.k2[ i ]
+ 32.0 / 9.0 * S_.k3[ i ] );
aeif_cond_alpha_RK5_dynamics( S_.yin, S_.k4 );
// k5
for ( int i = 0; i < S_.STATE_VEC_SIZE; ++i )
S_.yin[ i ] = S_.y_[ i ]
+ h
* ( 19372.0 / 6561.0 * S_.k1[ i ] - 25360.0 / 2187.0 * S_.k2[ i ]
+ 64448.0 / 6561.0 * S_.k3[ i ]
- 212.0 / 729.0 * S_.k4[ i ] );
aeif_cond_alpha_RK5_dynamics( S_.yin, S_.k5 );
// k6
for ( int i = 0; i < S_.STATE_VEC_SIZE; ++i )
S_.yin[ i ] = S_.y_[ i ]
+ h * ( 9017.0 / 3168.0 * S_.k1[ i ] - 355.0 / 33.0 * S_.k2[ i ]
+ 46732.0 / 5247.0 * S_.k3[ i ]
+ 49.0 / 176.0 * S_.k4[ i ]
- 5103.0 / 18656.0 * S_.k5[ i ] );
aeif_cond_alpha_RK5_dynamics( S_.yin, S_.k6 );
// 5th order
for ( int i = 0; i < S_.STATE_VEC_SIZE; ++i )
S_.ynew[ i ] = S_.y_[ i ]
+ h * ( 35.0 / 384.0 * S_.k1[ i ] + 500.0 / 1113.0 * S_.k3[ i ]
+ 125.0 / 192.0 * S_.k4[ i ]
- 2187.0 / 6784.0 * S_.k5[ i ]
+ 11.0 / 84.0 * S_.k6[ i ] );
aeif_cond_alpha_RK5_dynamics( S_.yin, S_.k7 );
// 4th order
for ( int i = 0; i < S_.STATE_VEC_SIZE; ++i )
{
S_.yref[ i ] = S_.y_[ i ]
+ h
* ( 5179.0 / 57600.0 * S_.k1[ i ] + 7571.0 / 16695.0 * S_.k3[ i ]
+ 393.0 / 640.0 * S_.k4[ i ]
- 92097.0 / 339200.0 * S_.k5[ i ]
+ 187.0 / 2100.0 * S_.k6[ i ]
+ 1.0 / 40.0 * S_.k7[ i ] );
}
err = std::fabs( S_.ynew[ 0 ] - S_.yref[ 0 ] ) / MAXERR
+ 1.0e-200; // error estimate,
// based on different orders for stepsize prediction. Small value added
// to prevent err==0
// The following flag 'done' is needed to ensure that we accept the
// result for h<=HMIN, irrespective of the error. (See below)
done = ( h <= HMIN ); // Always exit loop if h was <=HMIN already
// prediction of next integration stepsize. This step may result in a
// stepsize below HMIN.
// If this happens, we must
// 1. set the stepsize to HMIN
// 2. compute the result and accept it irrespective of the error,
// because we cannot decrease the stepsize any further.
// the 'done' flag, computed above ensure that the loop is terminated
// after the result was computed.
h *= 0.98 * std::pow( 1.0 / err, 1.0 / 5.0 );
h = std::max( h, HMIN );
} while ( ( err > 1.0 ) and ( not done ) ); // reject step if err > 1
for ( unsigned int i = 0; i < S_.STATE_VEC_SIZE; ++i )
S_.y_[ i ] = S_.ynew[ i ]; // pass updated values
t = t_return;
// check for unreasonable values; we allow V_M to explode
if ( S_.y_[ State_::V_M ] < -1e3 || S_.y_[ State_::W ] < -1e6
|| S_.y_[ State_::W ] > 1e6 )
throw NumericalInstability( get_name() );
// spikes are handled inside the while-loop
// due to spike-driven adaptation
if ( S_.r_ > 0 ) // if neuron is still in refractory period
S_.y_[ State_::V_M ] = P_.V_reset_; // clamp it to V_reset
else if ( S_.y_[ State_::V_M ] >= P_.V_peak_ ) // V_m >= V_peak: spike
{
S_.y_[ State_::V_M ] = P_.V_reset_;
S_.y_[ State_::W ] += P_.b; // spike-driven adaptation
S_.r_ = V_.RefractoryCounts_; // initialize refractory steps with
// refractory period
set_spiketime( Time::step( origin.get_steps() + lag + 1 ) );
SpikeEvent se;
kernel().event_delivery_manager.send( *this, se, lag );
}
} // while
S_.y_[ State_::DG_EXC ] +=
B_.spike_exc_.get_value( lag ) * V_.g0_ex_; // add incoming spikes
S_.y_[ State_::DG_INH ] += B_.spike_inh_.get_value( lag ) * V_.g0_in_;
// set new input current
B_.I_stim_ = B_.currents_.get_value( lag );
// log state data
B_.logger_.record_data( origin.get_steps() + lag );
} // for-loop
} // function update()
OptionMenu::OptionMenu() :
m_background("core/menu/wood"),
m_blackboard("core/menu/blackboard"),
ok_button(),
x_pos(),
y_pos(),
options(),
fullscreen_box(),
software_cursor_box(),
autoscroll_box(),
dragdrop_scroll_box(),
mousegrab_box(),
printfps_box(),
master_volume_box(),
sound_volume_box(),
music_volume_box(),
//defaults_label(),
//defaults_box(),
connections(),
m_language(),
m_language_map()
{
gui_manager->add(ok_button = new OptionMenuCloseButton(this,
Display::get_width()/2 + 245,
Display::get_height()/2 + 150));
x_pos = 0;
y_pos = 0;
ChoiceBox* resolution_box = new ChoiceBox(Rect());
{
std::vector<SDL_DisplayMode> resolutions = Display::get_fullscreen_video_modes();
Size fullscreen = config_manager.get_fullscreen_resolution();
int choice = static_cast<int>(resolutions.size()) - 1;
for (auto it = resolutions.begin(); it != resolutions.end(); ++it)
{
// add resolution to the box
std::ostringstream ostr;
ostr << it->w << "x" << it->h << "@" << it->refresh_rate;
resolution_box->add_choice(ostr.str());
// FIXME: ignoring refresh_rate
if (fullscreen.width == it->w &&
fullscreen.height == it->h)
{
choice = static_cast<int>(it - resolutions.begin());
}
}
resolution_box->set_current_choice(choice);
}
ChoiceBox* renderer_box = new ChoiceBox(Rect());
renderer_box->add_choice("sdl");
renderer_box->add_choice("delta");
renderer_box->add_choice("opengl");
switch(config_manager.get_renderer())
{
case SDL_FRAMEBUFFER: renderer_box->set_current_choice(0); break;
case DELTA_FRAMEBUFFER: renderer_box->set_current_choice(1); break;
case OPENGL_FRAMEBUFFER: renderer_box->set_current_choice(2); break;
default: assert(!"unknown renderer type");
}
m_language = dictionary_manager.get_language();
ChoiceBox* language_box = new ChoiceBox(Rect());
{
std::set<tinygettext::Language> languages = dictionary_manager.get_languages();
// English is the default language, thus it's not in the list of
// languages returned by tinygettext and we have to add it manually
languages.insert(tinygettext::Language::from_name("en"));
std::vector<tinygettext::Language> langs(languages.begin(), languages.end());
std::sort(langs.begin(), langs.end(), LanguageSorter());
for (auto i = langs.begin(); i != langs.end(); ++i)
{
m_language_map[i->get_name()] = *i;
language_box->add_choice(i->get_name());
if (m_language == *i)
{
language_box->set_current_choice(static_cast<int>(i - langs.begin()));
}
}
}
ChoiceBox* scroll_box = new ChoiceBox(Rect());
scroll_box->add_choice("Drag&Drop");
scroll_box->add_choice("Rubberband");
software_cursor_box = new CheckBox(Rect());
fullscreen_box = new CheckBox(Rect());
autoscroll_box = new CheckBox(Rect());
dragdrop_scroll_box = new CheckBox(Rect());
mousegrab_box = new CheckBox(Rect());
printfps_box = new CheckBox(Rect());
master_volume_box = new SliderBox(Rect(), 25);
sound_volume_box = new SliderBox(Rect(), 25);
music_volume_box = new SliderBox(Rect(), 25);
master_volume_box->set_value(config_manager.get_master_volume());
sound_volume_box->set_value(config_manager.get_sound_volume());
music_volume_box->set_value(config_manager.get_music_volume());
C(software_cursor_box->on_change.connect(std::bind(&OptionMenu::on_software_cursor_change, this, std::placeholders::_1)));
C(fullscreen_box->on_change.connect(std::bind(&OptionMenu::on_fullscreen_change, this, std::placeholders::_1)));
C(autoscroll_box->on_change.connect(std::bind(&OptionMenu::on_autoscroll_change, this, std::placeholders::_1)));
C(dragdrop_scroll_box->on_change.connect(std::bind(&OptionMenu::on_drag_drop_scrolling_change, this, std::placeholders::_1)));
C(mousegrab_box->on_change.connect(std::bind(&OptionMenu::on_mousegrab_change, this, std::placeholders::_1)));
C(printfps_box->on_change.connect(std::bind(&OptionMenu::on_printfps_change, this, std::placeholders::_1)));
C(master_volume_box->on_change.connect(std::bind(&OptionMenu::on_master_volume_change, this, std::placeholders::_1)));
C(sound_volume_box->on_change.connect(std::bind(&OptionMenu::on_sound_volume_change, this, std::placeholders::_1)));
C(music_volume_box->on_change.connect(std::bind(&OptionMenu::on_music_volume_change, this, std::placeholders::_1)));
C(language_box->on_change.connect(std::bind(&OptionMenu::on_language_change, this, std::placeholders::_1)));
C(resolution_box->on_change.connect(std::bind(&OptionMenu::on_resolution_change, this, std::placeholders::_1)));
C(renderer_box->on_change.connect(std::bind(&OptionMenu::on_renderer_change, this, std::placeholders::_1)));
x_pos = 0;
y_pos = 0;
add_item(_("Fullscreen"), fullscreen_box);
add_item(_("Mouse Grab"), mousegrab_box);
y_pos += 1;
add_item(_("Software Cursor"), software_cursor_box);
add_item(_("Autoscrolling"), autoscroll_box);
add_item(_("Drag&Drop Scrolling"), dragdrop_scroll_box);
y_pos += 1;
add_item(_("Print FPS"), printfps_box);
x_pos = 1;
y_pos = 0;
add_item(_("Resolution:"), resolution_box);
add_item(_("Renderer:"), renderer_box);
y_pos += 1;
add_item(_("Language:"), language_box);
y_pos += 1;
add_item(_("Master Volume:"), master_volume_box);
add_item(_("Sound Volume:"), sound_volume_box);
add_item(_("Music Volume:"), music_volume_box);
// Connect with ConfigManager
mousegrab_box->set_state(config_manager.get_mouse_grab(), false);
C(config_manager.on_mouse_grab_change.connect(std::bind(&CheckBox::set_state, mousegrab_box, std::placeholders::_1, false)));
printfps_box->set_state(config_manager.get_print_fps(), false);
C(config_manager.on_print_fps_change.connect(std::bind(&CheckBox::set_state, printfps_box, std::placeholders::_1, false)));
fullscreen_box->set_state(config_manager.get_fullscreen(), false);
C(config_manager.on_fullscreen_change.connect(std::bind(&CheckBox::set_state, fullscreen_box, std::placeholders::_1, false)));
software_cursor_box->set_state(config_manager.get_software_cursor(), false);
C(config_manager.on_software_cursor_change.connect(std::bind(&CheckBox::set_state, software_cursor_box, std::placeholders::_1, false)));
autoscroll_box->set_state(config_manager.get_auto_scrolling(), false);
C(config_manager.on_auto_scrolling_change.connect(std::bind(&CheckBox::set_state, autoscroll_box, std::placeholders::_1, false)));
dragdrop_scroll_box->set_state(config_manager.get_drag_drop_scrolling(), false);
C(config_manager.on_drag_drop_scrolling_change.connect(std::bind(&CheckBox::set_state, dragdrop_scroll_box, std::placeholders::_1, false)));
/*
defaults_label = new Label(_("Reset to Defaults:"), Rect(Vector2i(Display::get_width()/2 - 100, Display::get_height()/2 + 160), Size(170, 32)));
gui_manager->add(defaults_label);
defaults_box = new CheckBox(Rect(Vector2i(Display::get_width()/2 - 100 + 170, Display::get_height()/2 + 160), Size(32, 32)));
gui_manager->add(defaults_box);
*/
}
static void get_artist (char *buf) {
get_name(buf);
}
static void tbl_basic_serialize(lua_State *L, serial_type *s, int type, int idx)
{
if (type == LUA_TBOOLEAN) {
if (lua_toboolean(L, idx)) { writeTblFixed(s, "true", 4); }
else { writeTblFixed(s, "false", 5); }
} else if (type == LUA_TNUMBER) {
lua_pushvalue(L, idx);
size_t len;
const char *n = lua_tolstring(L, -1, &len);
writeTblFixed(s, n, len);
lua_pop(L, 1);
} else if (type == LUA_TSTRING) {
size_t len;
const char *str = lua_tolstring(L, idx, &len);
writeTblFixed(s, "\"", 1);
tbl_dump_string(s, str, len);
writeTblFixed(s, "\"", 1);
} else if (type == LUA_TFUNCTION) {
writeTblFixed(s, "loadstring(\"", 12);
lua_dump(L, tbl_dump_function, s);
writeTblFixed(s, "\")", 2);
} else if (type == LUA_TTABLE) {
lua_pushstring(L, "__CLASSNAME");
lua_rawget(L, idx - 1);
// This is an object, register for saving later
if (!lua_isnil(L, -1))
{
lua_pop(L, 1);
writeTblFixed(s, "loadObject('", 12);
writeTbl(s, get_name(L, s, idx));
writeTblFixed(s, "')", 2);
add_process(L, s, idx);
}
// This is just a table, save it
else
{
lua_pop(L, 1);
int ktype, etype;
writeTblFixed(s, "{", 1);
/* table is in the stack at index 't' */
lua_pushnil(L); /* first key */
while (lua_next(L, idx - 1) != 0)
{
ktype = lua_type(L, -2);
etype = lua_type(L, -1);
// Only save allowed types
if (
((ktype == LUA_TBOOLEAN) || (ktype == LUA_TNUMBER) || (ktype == LUA_TSTRING) || (ktype == LUA_TFUNCTION) || (ktype == LUA_TTABLE)) &&
((etype == LUA_TBOOLEAN) || (etype == LUA_TNUMBER) || (etype == LUA_TSTRING) || (etype == LUA_TFUNCTION) || (etype == LUA_TTABLE))
)
{
writeTblFixed(s, "[", 1);
tbl_basic_serialize(L, s, ktype, -2);
writeTblFixed(s, "]=", 2);
tbl_basic_serialize(L, s, etype, -1);
writeTblFixed(s, ",\n", 2);
}
/* removes 'value'; keeps 'key' for next iteration */
lua_pop(L, 1);
}
writeTblFixed(s, "}\n", 2);
}
} else {
printf("*WARNING* can not save value of type %s\n", lua_typename(L, type));
}
}
std::string Node_ATC18_DENRB_QN::get_formula()
{
return std::string(get_name());
}
bool Directory::Entry::is_hidden() const {
return !get_name().empty() && get_name()[0] == '.';
}
void
Config::load()
{
auto doc = ReaderDocument::from_file("config");
auto root = doc.get_root();
if (root.get_name() != "supertux-config")
{
throw std::runtime_error("File is not a supertux-config file");
}
auto config_mapping = root.get_mapping();
config_mapping.get("profile", profile);
config_mapping.get("show_fps", show_fps);
config_mapping.get("show_player_pos", show_player_pos);
config_mapping.get("developer", developer_mode);
config_mapping.get("confirmation_dialog", confirmation_dialog);
config_mapping.get("pause_on_focusloss", pause_on_focusloss);
if (is_christmas()) {
if (!config_mapping.get("christmas", christmas_mode))
{
christmas_mode = true;
}
}
config_mapping.get("transitions_enabled", transitions_enabled);
config_mapping.get("locale", locale);
config_mapping.get("random_seed", random_seed);
config_mapping.get("repository_url", repository_url);
boost::optional<ReaderMapping> config_video_mapping;
if (config_mapping.get("video", config_video_mapping))
{
config_video_mapping->get("fullscreen", use_fullscreen);
std::string video_string;
config_video_mapping->get("video", video_string);
video = VideoSystem::get_video_system(video_string);
config_video_mapping->get("vsync", try_vsync);
config_video_mapping->get("fullscreen_width", fullscreen_size.width);
config_video_mapping->get("fullscreen_height", fullscreen_size.height);
if (fullscreen_size.width < 0 || fullscreen_size.height < 0)
{
// Somehow, an invalid size got entered into the config file,
// let's use the "auto" setting instead.
fullscreen_size = Size(0, 0);
}
config_video_mapping->get("fullscreen_refresh_rate", fullscreen_refresh_rate);
config_video_mapping->get("window_width", window_size.width);
config_video_mapping->get("window_height", window_size.height);
config_video_mapping->get("window_resizable", window_resizable);
config_video_mapping->get("aspect_width", aspect_size.width);
config_video_mapping->get("aspect_height", aspect_size.height);
config_video_mapping->get("magnification", magnification);
}
boost::optional<ReaderMapping> config_audio_mapping;
if (config_mapping.get("audio", config_audio_mapping))
{
config_audio_mapping->get("sound_enabled", sound_enabled);
config_audio_mapping->get("music_enabled", music_enabled);
config_audio_mapping->get("sound_volume", sound_volume);
config_audio_mapping->get("music_volume", music_volume);
}
boost::optional<ReaderMapping> config_control_mapping;
if (config_mapping.get("control", config_control_mapping))
{
boost::optional<ReaderMapping> keymap_mapping;
if (config_control_mapping->get("keymap", keymap_mapping))
{
keyboard_config.read(*keymap_mapping);
}
boost::optional<ReaderMapping> joystick_mapping;
if (config_control_mapping->get("joystick", joystick_mapping))
{
joystick_config.read(*joystick_mapping);
}
}
boost::optional<ReaderCollection> config_addons_mapping;
if (config_mapping.get("addons", config_addons_mapping))
{
for (auto const& addon_node : config_addons_mapping->get_objects())
{
if (addon_node.get_name() == "addon")
{
auto addon = addon_node.get_mapping();
std::string id;
bool enabled = false;
if (addon.get("id", id) &&
addon.get("enabled", enabled))
{
addons.push_back({id, enabled});
}
}
else
{
log_warning << "Unknown token in config file: " << addon_node.get_name() << std::endl;
}
}
}
}
//+----------------------------------------------------------------------------
//
// method : PilatusPixelDetectorClass::write_class_property
//
// description : Set class description as property in database
//
//-----------------------------------------------------------------------------
void PilatusPixelDetectorClass::write_class_property()
{
// First time, check if database used
//--------------------------------------------
if (Tango::Util::_UseDb == false)
return;
Tango::DbData data;
string classname = get_name();
string header;
string::size_type start, end;
// Put title
Tango::DbDatum title("ProjectTitle");
string str_title("");
title << str_title;
data.push_back(title);
// Put Description
Tango::DbDatum description("Description");
vector<string> str_desc;
str_desc.push_back(" ");
description << str_desc;
data.push_back(description);
// put cvs or svn location
string filename(classname);
filename += "Class.cpp";
// Create a string with the class ID to
// get the string into the binary
string class_id(ClassId);
// check for cvs information
string src_path(CvsPath);
start = src_path.find("/");
if (start!=string::npos)
{
end = src_path.find(filename);
if (end>start)
{
string strloc = src_path.substr(start, end-start);
// Check if specific repository
start = strloc.find("/cvsroot/");
if (start!=string::npos && start>0)
{
string repository = strloc.substr(0, start);
if (repository.find("/segfs/")!=string::npos)
strloc = "ESRF:" + strloc.substr(start, strloc.length()-start);
}
Tango::DbDatum cvs_loc("cvs_location");
cvs_loc << strloc;
data.push_back(cvs_loc);
}
}
// check for svn information
else
{
string src_path(SvnPath);
start = src_path.find("://");
if (start!=string::npos)
{
end = src_path.find(filename);
if (end>start)
{
header = "$HeadURL: ";
start = header.length();
string strloc = src_path.substr(start, (end-start));
Tango::DbDatum svn_loc("svn_location");
svn_loc << strloc;
data.push_back(svn_loc);
}
}
}
// Get CVS or SVN revision tag
// CVS tag
string tagname(TagName);
header = "$Name: ";
start = header.length();
string endstr(" $");
end = tagname.find(endstr);
if (end!=string::npos && end>start)
{
string strtag = tagname.substr(start, end-start);
Tango::DbDatum cvs_tag("cvs_tag");
cvs_tag << strtag;
data.push_back(cvs_tag);
}
// SVN tag
string svnpath(SvnPath);
header = "$HeadURL: ";
start = header.length();
end = svnpath.find(endstr);
if (end!=string::npos && end>start)
{
string strloc = svnpath.substr(start, end-start);
string tagstr ("/tags/");
start = strloc.find(tagstr);
if ( start!=string::npos )
{
start = start + tagstr.length();
end = strloc.find(filename);
string strtag = strloc.substr(start, end-start-1);
Tango::DbDatum svn_tag("svn_tag");
svn_tag << strtag;
data.push_back(svn_tag);
}
}
// Get URL location
string httpServ(HttpServer);
if (httpServ.length()>0)
{
Tango::DbDatum db_doc_url("doc_url");
db_doc_url << httpServ;
data.push_back(db_doc_url);
}
// Put inheritance
Tango::DbDatum inher_datum("InheritedFrom");
vector<string> inheritance;
inheritance.push_back("Device_4Impl");
inher_datum << inheritance;
data.push_back(inher_datum);
// Call database and and values
//--------------------------------------------
get_db_class()->put_property(data);
}
IF::IF() {
selected_rule=0;
selected_condition=0;
ui=new UI::UI(CM::folder_path+"basicRule/"+get_name()+"/UI.txt");
true_mode=true;
}
Error EditorTextureImportPlugin::import2(const String& p_path, const Ref<ResourceImportMetadata>& p_from,EditorExportPlatform::ImageCompression p_compr, bool p_external){
ERR_FAIL_COND_V(p_from->get_source_count()==0,ERR_INVALID_PARAMETER);
Ref<ResourceImportMetadata> from=p_from;
Ref<ImageTexture> texture;
Vector<Ref<AtlasTexture> > atlases;
bool atlas = from->get_option("atlas");
int flags=from->get_option("flags");
uint32_t tex_flags=0;
if (flags&EditorTextureImportPlugin::IMAGE_FLAG_REPEAT)
tex_flags|=Texture::FLAG_REPEAT;
if (flags&EditorTextureImportPlugin::IMAGE_FLAG_FILTER)
tex_flags|=Texture::FLAG_FILTER;
if (!(flags&EditorTextureImportPlugin::IMAGE_FLAG_NO_MIPMAPS))
tex_flags|=Texture::FLAG_MIPMAPS;
int shrink=1;
if (from->has_option("shrink"))
shrink=from->get_option("shrink");
if (atlas) {
//prepare atlas!
Vector< Image > sources;
bool alpha=false;
bool crop = from->get_option("crop");
EditorProgress ep("make_atlas","Build Atlas For: "+p_path.get_file(),from->get_source_count()+3);
print_line("sources: "+itos(from->get_source_count()));
for(int i=0;i<from->get_source_count();i++) {
String path = EditorImportPlugin::expand_source_path(from->get_source_path(i));
ep.step("Loading Image: "+path,i);
print_line("source path: "+path);
Image src;
Error err = ImageLoader::load_image(path,&src);
if (err) {
EditorNode::add_io_error("Couldn't load image: "+path);
return err;
}
if (src.detect_alpha())
alpha=true;
sources.push_back(src);
}
ep.step("Converting Images",sources.size());
for(int i=0;i<sources.size();i++) {
if (alpha) {
sources[i].convert(Image::FORMAT_RGBA);
} else {
sources[i].convert(Image::FORMAT_RGB);
}
}
//texturepacker is not really good for optimizing, so..
//will at some point likely replace with my own
//first, will find the nearest to a square packing
int border=1;
Vector<Size2i> src_sizes;
Vector<Rect2> crops;
ep.step("Cropping Images",sources.size()+1);
for(int j=0;j<sources.size();j++) {
Size2i s;
if (crop) {
Rect2 crop = sources[j].get_used_rect();
print_line("CROP: "+crop);
s=crop.size;
crops.push_back(crop);
} else {
s=Size2i(sources[j].get_width(),sources[j].get_height());
}
s+=Size2i(border*2,border*2);
src_sizes.push_back(s); //add a line to constraint width
}
Vector<Point2i> dst_positions;
Size2i dst_size;
EditorAtlas::fit(src_sizes,dst_positions,dst_size);
print_line("size that workeD: "+itos(dst_size.width)+","+itos(dst_size.height));
ep.step("Blitting Images",sources.size()+2);
Image atlas;
atlas.create(nearest_power_of_2(dst_size.width),nearest_power_of_2(dst_size.height),0,alpha?Image::FORMAT_RGBA:Image::FORMAT_RGB);
for(int i=0;i<sources.size();i++) {
int x=dst_positions[i].x;
int y=dst_positions[i].y;
Ref<AtlasTexture> at = memnew( AtlasTexture );
Size2 sz = Size2(sources[i].get_width(),sources[i].get_height());
if (crop && sz!=crops[i].size) {
Rect2 rect = crops[i];
rect.size=sz-rect.size;
at->set_region(Rect2(x+border,y+border,crops[i].size.width,crops[i].size.height));
at->set_margin(rect);
atlas.blit_rect(sources[i],crops[i],Point2(x+border,y+border));
} else {
at->set_region(Rect2(x+border,y+border,sz.x,sz.y));
atlas.blit_rect(sources[i],Rect2(0,0,sources[i].get_width(),sources[i].get_height()),Point2(x+border,y+border));
}
String apath = p_path.get_base_dir().plus_file(from->get_source_path(i).get_file().basename()+".atex");
print_line("Atlas Tex: "+apath);
at->set_path(apath);
atlases.push_back(at);
}
if (ResourceCache::has(p_path)) {
texture = Ref<ImageTexture> ( ResourceCache::get(p_path)->cast_to<ImageTexture>() );
} else {
texture = Ref<ImageTexture>( memnew( ImageTexture ) );
}
texture->create_from_image(atlas,tex_flags);
} else {
ERR_FAIL_COND_V(from->get_source_count()!=1,ERR_INVALID_PARAMETER);
String src_path = EditorImportPlugin::expand_source_path(from->get_source_path(0));
if (ResourceCache::has(p_path)) {
Resource *r = ResourceCache::get(p_path);
texture = Ref<ImageTexture> ( r->cast_to<ImageTexture>() );
Image img;
Error err = img.load(src_path);
ERR_FAIL_COND_V(err!=OK,ERR_CANT_OPEN);
texture->create_from_image(img);
} else {
texture=ResourceLoader::load(src_path,"ImageTexture");
}
ERR_FAIL_COND_V(texture.is_null(),ERR_CANT_OPEN);
if (!p_external)
from->set_source_md5(0,FileAccess::get_md5(src_path));
}
int format=from->get_option("format");
float quality=from->get_option("quality");
if (!p_external) {
from->set_editor(get_name());
texture->set_path(p_path);
texture->set_import_metadata(from);
}
if (atlas) {
if (p_external) {
//used by exporter
Array rects(true);
for(int i=0;i<atlases.size();i++) {
rects.push_back(atlases[i]->get_region());
rects.push_back(atlases[i]->get_margin());
}
from->set_option("rects",rects);
} else {
//used by importer
for(int i=0;i<atlases.size();i++) {
String apath = atlases[i]->get_path();
atlases[i]->set_atlas(texture);
Error err = ResourceSaver::save(apath,atlases[i]);
if (err) {
EditorNode::add_io_error("Couldn't save atlas image: "+apath);
return err;
}
from->set_source_md5(i,FileAccess::get_md5(apath));
}
}
}
if (format==IMAGE_FORMAT_COMPRESS_DISK_LOSSLESS || format==IMAGE_FORMAT_COMPRESS_DISK_LOSSY) {
Image image=texture->get_data();
ERR_FAIL_COND_V(image.empty(),ERR_INVALID_DATA);
bool has_alpha=image.detect_alpha();
if (!has_alpha && image.get_format()==Image::FORMAT_RGBA) {
image.convert(Image::FORMAT_RGB);
}
if (image.get_format()==Image::FORMAT_RGBA && flags&IMAGE_FLAG_FIX_BORDER_ALPHA) {
image.fix_alpha_edges();
}
if (shrink>1) {
int orig_w=image.get_width();
int orig_h=image.get_height();
image.resize(orig_w/shrink,orig_h/shrink);
texture->create_from_image(image,tex_flags);
texture->set_size_override(Size2(orig_w,orig_h));
} else {
texture->create_from_image(image,tex_flags);
}
if (format==IMAGE_FORMAT_COMPRESS_DISK_LOSSLESS) {
texture->set_storage(ImageTexture::STORAGE_COMPRESS_LOSSLESS);
} else {
texture->set_storage(ImageTexture::STORAGE_COMPRESS_LOSSY);
}
texture->set_lossy_storage_quality(quality);
Error err = ResourceSaver::save(p_path,texture);
if (err!=OK) {
EditorNode::add_io_error("Couldn't save converted texture: "+p_path);
return err;
}
} else {
print_line("compress...");
Image image=texture->get_data();
ERR_FAIL_COND_V(image.empty(),ERR_INVALID_DATA);
bool has_alpha=image.detect_alpha();
if (!has_alpha && image.get_format()==Image::FORMAT_RGBA) {
image.convert(Image::FORMAT_RGB);
}
if (image.get_format()==Image::FORMAT_RGBA && flags&IMAGE_FLAG_FIX_BORDER_ALPHA) {
image.fix_alpha_edges();
}
int orig_w=image.get_width();
int orig_h=image.get_height();
if (shrink>1) {
image.resize(orig_w/shrink,orig_h/shrink);
texture->create_from_image(image,tex_flags);
texture->set_size_override(Size2(orig_w,orig_h));
}
if (!(flags&IMAGE_FLAG_NO_MIPMAPS)) {
image.generate_mipmaps();
}
if (format!=IMAGE_FORMAT_UNCOMPRESSED) {
compress_image(p_compr,image,flags&IMAGE_FLAG_COMPRESS_EXTRA);
}
print_line("COMPRESSED TO: "+itos(image.get_format()));
texture->create_from_image(image,tex_flags);
if (shrink>1) {
texture->set_size_override(Size2(orig_w,orig_h));
}
uint32_t save_flags=ResourceSaver::FLAG_COMPRESS;
Error err = ResourceSaver::save(p_path,texture,save_flags);
if (err!=OK) {
EditorNode::add_io_error("Couldn't save converted texture: "+p_path);
return err;
}
}
return OK;
}
static int action_cb(Ihandle *ih)
{
static int count = 1;
printf("ACTION(%s) - %d\n", get_name(ih), count); count++;
return IUP_DEFAULT;
}
