//do_i_send : true if the calling process (node) has to SEND data TO another process (node) in the current step
bool do_i_send( const TestInfo *ti, int step )
{
switch( ti->algoVar[0] ) {
case 1: return GET_ID(ti) < ACTIVE_PROCS(ti,step);
}
return ! ( GET_ID(ti) % ( GET_N(ti) / ACTIVE_PROCS(ti,step) ) );
}
bool recEventa::Read()
{
wxSQLite3StatementBuffer sql;
wxSQLite3Table result;
if( f_id == 0 ) {
Clear();
return false;
}
sql.Format(
"SELECT title, ref_id, type_id, date1_id, date2_id, place_id, note, date_pt"
" FROM Eventa WHERE id=" ID ";",
f_id
);
result = s_db->GetTable( sql );
if( result.GetRowCount() != 1 )
{
Clear();
return false;
}
result.SetRow( 0 );
f_title = result.GetAsString( 0 );
f_ref_id = GET_ID( result.GetInt64( 1 ) );
f_type_id = GET_ID( result.GetInt64( 2 ) );
f_date1_id = GET_ID( result.GetInt64( 3 ) );
f_date2_id = GET_ID( result.GetInt64( 4 ) );
f_place_id = GET_ID( result.GetInt64( 5 ) );
f_note = result.GetAsString( 6 );
f_date_pt = (long) result.GetInt( 7 );
return true;
}
//do_i_receive : return a number different from 0 if the calling process (node) has to RECEIVE data FROM another process (node) in the current step.
bool do_i_receive( const TestInfo *ti, int step )
{
switch( ti->algoVar[0] ) {
case 1: return ! do_i_send( ti, step ) && GET_ID(ti) < 2*ACTIVE_PROCS(ti,step);
}
return ! do_i_send( ti, step ) && ! ( GET_ID(ti) % ( GET_N(ti) / ACTIVE_PROCS(ti,step+1) ) ) ;
}
bool recFamilyIndEventa::Read()
{
wxSQLite3StatementBuffer sql;
wxSQLite3Table result;
if( f_id == 0 ) {
Clear();
return false;
}
sql.Format(
"SELECT fam_ind_id, eventa_id, conf, note "
"FROM FamilyIndEventa WHERE id=" ID ";",
f_id
);
result = s_db->GetTable( sql );
if( result.GetRowCount() != 1 )
{
Clear();
return false;
}
result.SetRow( 0 );
f_fam_ind_id = GET_ID( result.GetInt64( 0 ) );
f_eventa_id = GET_ID( result.GetInt64( 1 ) );
f_conf = result.GetDouble( 2 );
f_note = result.GetAsString( 3 );
return true;
}
bool recGalleryMedia::Read()
{
wxSQLite3StatementBuffer sql;
wxSQLite3Table result;
if ( f_id == 0 ) {
Clear();
return false;
}
sql.Format(
"SELECT title, gal_id, med_id, med_seq"
" FROM GalleryMedia WHERE id=" ID ";",
f_id
);
result = s_db->GetTable( sql );
if ( result.GetRowCount() != 1 )
{
Clear();
return false;
}
result.SetRow( 0 );
f_title = result.GetAsString( 0 );
f_gal_id = GET_ID( result.GetInt64( 1 ) );
f_med_id = GET_ID( result.GetInt64( 2 ) );
f_med_seq = result.GetInt( 3 );
return true;
}
recEventaPersonaVec recEventa::GetEventaPersonas( idt eaID )
{
recEventaPersonaVec vec;
wxSQLite3StatementBuffer sql;
sql.Format(
"SELECT id, per_id, role_id, note, per_seq"
" FROM EventaPersona WHERE eventa_id=" ID
" ORDER BY per_seq;",
eaID
);
wxSQLite3Table table = s_db->GetTable( sql );
recEventaPersona record;
record.FSetEventaID( eaID );
for( int i = 0 ; i < table.GetRowCount() ; i++ )
{
table.SetRow( i );
record.f_id = GET_ID( table.GetInt64( 0 ) );
record.f_per_id = GET_ID( table.GetInt64( 1 ) );
record.f_role_id = GET_ID( table.GetInt64( 2 ) );
record.f_note = table.GetAsString( 3 );
record.f_per_seq = table.GetInt( 4 );
vec.push_back( record );
}
return vec;
}
//to_who : return the rank of the process (node) from which i SEND data in the current step
int to_who( const TestInfo *ti, int step )
{
switch( ti->algoVar[0] ) {
case 1: return GET_ID(ti) + ACTIVE_PROCS(ti,step);
}
return GET_ID(ti) + ( GET_N(ti) / ACTIVE_PROCS(ti,step+1) );
}
/**
* @brief Scatters data among all processes
*
* @param[in,out] data Data to be scattered/received
* @param[in] counts Array containing the number of elements to be sent to each process
* @param[in] displs Array of displacements
* @param[in] root Rank of the root process
*/
void TEST_DAL_scatterv( Data *data, dal_size_t *counts, dal_size_t *displs, int root )
{
if( GET_ID() == root ) {
return TEST_DAL_scattervSend( data, counts, displs );
}
else {
return TEST_DAL_scattervReceive( data, counts[GET_ID()], root );
}
}
/*************************************************************************************************
* Inlines
*/
INLINE struct rs_resource* rs_resource_get(reshandle_t hdl) {
uint idx = GET_INDEX(hdl);
ASSERT(idx < (uint)g_rs.ress.item_cnt);
struct rs_resource* r = &((struct rs_resource*)g_rs.ress.buffer)[idx];
ASSERT(r->hdl != INVALID_HANDLE);
ASSERT(GET_ID(r->hdl) == GET_ID(hdl));
return r;
}
/*
* Init JNI fields that will be used to fetch the key and crypt/encrypt
*/
static int
InitJni(vlc_keystore *p_keystore, JNIEnv *p_env)
{
jclass clazz = NULL;
GET_CLASS("java/lang/Object");
GET_ID(GetMethodID, Object.toString, "toString", "()Ljava/lang/String;");
GET_CLASS("java/security/KeyStore");
GET_GLOBAL_CLASS(KeyStore);
GET_ID(GetStaticMethodID, KeyStore.getInstance, "getInstance",
"(Ljava/lang/String;)Ljava/security/KeyStore;");
GET_ID(GetMethodID, KeyStore.load, "load",
"(Ljava/security/KeyStore$LoadStoreParameter;)V");
GET_ID(GetMethodID, KeyStore.getEntry, "getEntry",
"(Ljava/lang/String;Ljava/security/KeyStore$ProtectionParameter;)"
"Ljava/security/KeyStore$Entry;");
GET_CLASS("java/security/KeyStore$SecretKeyEntry");
GET_ID(GetMethodID, KeyStore.SecretKeyEntry.getSecretKey, "getSecretKey",
"()Ljavax/crypto/SecretKey;");
GET_CLASS("javax/crypto/spec/IvParameterSpec");
GET_GLOBAL_CLASS(IvParameterSpec);
GET_ID(GetMethodID, IvParameterSpec.ctor, "<init>", "([B)V");
GET_CLASS("javax/crypto/Cipher");
GET_GLOBAL_CLASS(Cipher);
GET_ID(GetStaticMethodID, Cipher.getInstance, "getInstance",
"(Ljava/lang/String;)Ljavax/crypto/Cipher;");
GET_ID(GetMethodID, Cipher.init, "init",
"(ILjava/security/Key;Ljava/security/spec/AlgorithmParameterSpec;)V");
GET_ID(GetMethodID, Cipher.doFinal, "doFinal", "([B)[B");
GET_ID(GetMethodID, Cipher.getIV, "getIV", "()[B");
GET_CONST_INT(Cipher.ENCRYPT_MODE, "ENCRYPT_MODE");
GET_CONST_INT(Cipher.DECRYPT_MODE, "DECRYPT_MODE");
DEL_LREF(clazz);
jstring VLC_CIPHER = NEW_STR("AES/CBC/PKCS7Padding");
if (CHECK_EXCEPTION())
return VLC_EGENERIC;
fields.VLC_CIPHER = NEW_GREF(VLC_CIPHER);
DEL_LREF(VLC_CIPHER);
return VLC_SUCCESS;
}
void recSystem::Save()
{
wxSQLite3StatementBuffer sql;
wxSQLite3Table result;
if( f_id == 0 ) {
// Add new record
sql.Format(
"INSERT INTO System (val) VALUES ('%q');",
UTF8_(f_val)
);
s_db->ExecuteUpdate( sql );
f_id = GET_ID( s_db->GetLastRowId() );
} else {
// Does record exist
if( !Exists() ) {
// Add new record
sql.Format(
"INSERT INTO System (id, val)"
" VALUES (" ID " '%q');",
f_id, UTF8_(f_val)
);
} else {
// Update existing record
sql.Format(
"UPDATE System SET val='%q' WHERE id=" ID ";",
UTF8_(f_val), f_id
);
}
s_db->ExecuteUpdate( sql );
}
}
void gather( const TestInfo *ti, Data *data )
{
// node 0
if( ! GET_ID(ti) ) {
/*
int actualSize = *size;
int i;
// receiving sequentially from ohter nodes
for( i = 1; i < GET_N(ti); ++ i ) {
MPI_Status stat;
_MPI_Recv( a+actualSize, GET_M(ti)-actualSize, MPI_INT, nth_token_owner(ti,i), 0, MPI_COMM_WORLD, &stat );
_MPI_Get_count( &stat, MPI_INT, size );
actualSize += *size;
}
*size = actualSize;
*/
int i;
// receiving sequentially from ohter nodes
for( i = 1; i < GET_N(ti); ++ i ) {
DAL_receiveAU( data, nth_token_owner(ti,i) );
}
}
// other nodes
else {
// _MPI_Send ( a, *size, MPI_INT, 0, 0, MPI_COMM_WORLD );
// *size = 0;
DAL_sendU( data, 0 );
DAL_destroy( data );
}
}
void recAssociate::Save()
{
wxSQLite3StatementBuffer sql;
wxSQLite3Table result;
if ( f_id == 0 )
{
// Add new record
sql.Format(
"INSERT INTO Associate (path) VALUES ('%q');",
UTF8_( f_path )
);
s_db->ExecuteUpdate( sql );
f_id = GET_ID( s_db->GetLastRowId() );
} else {
// Does record exist
if ( !Exists() )
{
// Add new record
sql.Format(
"INSERT INTO Associate (id, path) "
"VALUES (" ID ", '%q');",
f_id, UTF8_( f_path )
);
} else {
// Update existing record
sql.Format(
"UPDATE Associate SET path='%q' WHERE id=" ID ";",
UTF8_( f_path ), f_id
);
}
s_db->ExecuteUpdate( sql );
}
}
/*
* GC help function:
* collect_not_referenced_only == 0 -> clht_gc_collect_all();
* collect_not_referenced_only != 0 -> clht_gc_collect();
*/
static int
clht_gc_collect_cond(clht_t* hashtable, int collect_not_referenced_only)
{
/* if version_min >= current version there is nothing to collect! */
if ((hashtable->version_min >= hashtable->ht->version) || TRYLOCK_ACQ(&hashtable->gc_lock))
{
/* printf("** someone else is performing gc\n"); */
return 0;
}
ticks s = getticks();
/* printf("[GCOLLE-%02d] LOCK : %zu\n", GET_ID(collect_not_referenced_only), hashtable->version); */
size_t version_min = hashtable->ht->version;
if (collect_not_referenced_only)
{
version_min = clht_gc_min_version_used(hashtable);
}
/* printf("[GCOLLE-%02d] gc collect versions < %3zu - current: %3zu - oldest: %zu\n", */
/* GET_ID(collect_not_referenced_only), version_min, hashtable->version, hashtable->version_min); */
int gced_num = 0;
if (hashtable->version_min >= version_min)
{
/* printf("[GCOLLE-%02d] UNLOCK: %zu (nothing to collect)\n", GET_ID(collect_not_referenced_only), hashtable->ht->version); */
TRYLOCK_RLS(hashtable->gc_lock);
}
else
{
/* printf("[GCOLLE-%02d] collect from %zu to %zu\n", GET_ID(collect_not_referenced_only), hashtable->version_min, version_min); */
clht_hashtable_t* cur = hashtable->ht_oldest;
while (cur != NULL && cur->version < version_min)
{
gced_num++;
clht_hashtable_t* nxt = cur->table_new;
/* printf("[GCOLLE-%02d] gc_free version: %6zu | current version: %6zu\n", GET_ID(collect_not_referenced_only), */
/* cur->version, hashtable->ht->version); */
nxt->table_prev = NULL;
clht_gc_free(cur);
cur = nxt;
}
hashtable->version_min = cur->version;
hashtable->ht_oldest = cur;
TRYLOCK_RLS(hashtable->gc_lock);
/* printf("[GCOLLE-%02d] UNLOCK: %zu\n", GET_ID(collect_not_referenced_only), cur->version); */
}
ticks e = getticks() - s;
printf("[GCOLLE-%02d] collected: %-3d | took: %13llu ti = %8.6f s\n",
GET_ID(collect_not_referenced_only), gced_num, (unsigned long long) e, e / 2.1e9);
return gced_num;
}
void send_force_logout(CONN_DATA *conn)
{
DESC_DATA *desc = GET_DESC(conn);
if (NULL==desc) return;
sys_log("FORCE_LOGOUT : %d, %s", GET_ID(conn), GET_LOGIN(conn)?GET_LOGIN(conn):"null");
packet_force_logout(desc, conn);
}
idt recDb::ExecuteID( const char* format, idt id )
{
wxSQLite3StatementBuffer sql;
sql.Format( format, id );
wxSQLite3ResultSet result = s_db->ExecuteQuery( sql );
return GET_ID( result.GetInt64( 0 ) );
}
wxString recEventa::GetDateStr( idt evID )
{
wxSQLite3StatementBuffer sql;
wxSQLite3ResultSet result;
wxString str;
sql.Format( "SELECT date1_id, date2_id FROM Eventa WHERE id=" ID ";", evID );
result = s_db->ExecuteQuery( sql );
if( result.Eof() ) return str;
idt date1ID = GET_ID( result.GetInt64( 0 ) );
idt date2ID = GET_ID( result.GetInt64( 1 ) );
str << recDate::GetStr( date1ID );
if( date2ID != 0 ) {
str << _(" To ") << recDate::GetStr( date2ID );
}
return str;
}
recIdVec recDb::ExecuteIdVec( const wxSQLite3StatementBuffer& sql )
{
wxSQLite3ResultSet result = s_db->ExecuteQuery( sql );
recIdVec ids;
while( result.NextRow() ) {
ids.push_back( GET_ID( result.GetInt64( 0 ) ) );
}
return ids;
}
extern int
mem_blocks_pool_get_block_index(const MEMORY_BLOCKS_POOL *pool, int id) {
int real_id = GET_ID(id);
int index = GET_INDEX(id);
if (pool->ids[index] == real_id)
return index;
return -1;
}
/*
* get_elements_above_id get a few hashes represented by @elements and
* @num_elements. The hashes fields are described by @num_offset, @data_offset
* and @id_offset in the same way as required by for_each_element. The function
* returns an array of @iters, represents an array of elements in the hashes
* buckets, which their ids are the smallest ids in all hashes but are all
* larger than the id given by min_id. Elements are only added to the iters
* array if their id belongs to the bucket @bucket. The number of elements in
* the returned array is returned by the function. @min_id is also updated to
* reflect the new min_id of all elements in iters.
*/
static size_t get_elements_above_id(const void **iters,
unsigned int num_elements,
const void **elements,
size_t num_offset,
size_t data_offset,
size_t id_offset,
u16 bucket,
short *min_id)
{
size_t num_iters = 0;
short min = SHRT_MAX;
const void *elem;
int i, j, last_stored = -1;
unsigned int equal_min = 0;
for_each_element(elem, i, j, elements, num_elements, num_offset,
data_offset) {
u16 id = *(u16 *)(elem + id_offset);
if (GET_NS_ID(id) != bucket)
continue;
if (GET_ID(id) < *min_id ||
(min != SHRT_MAX && GET_ID(id) > min))
continue;
/*
* We first iterate all hashes represented by @elements. When
* we do, we try to find an element @elem in the bucket @bucket
* which its id is min. Since we can't ensure the user sorted
* the elements in increasing order, we override this hash's
* minimal id element we found, if a new element with a smaller
* id was just found.
*/
iters[last_stored == i ? num_iters - 1 : num_iters++] = elem;
last_stored = i;
if (min == GET_ID(id))
equal_min++;
else
equal_min = 1;
min = GET_ID(id);
}
void rs_reportleaks()
{
struct rs_resource* rss = (struct rs_resource*)g_rs.ress.buffer;
for (int i = 0; i < g_rs.ress.item_cnt; i++) {
const struct rs_resource* r = &rss[i];
if (r->hdl != INVALID_HANDLE && r->ref_cnt > 0) {
log_printf(LOG_WARNING, "res-mgr: unreleased \"%s\" (ref_cnt = %d, id = %d)",
r->filepath, r->ref_cnt, GET_ID(r->hdl));
}
}
}
/*
* GetWindowStyleString - get string corrosponding to window style bits
*/
void GetWindowStyleString( HWND hwnd, char *str, char *sstr )
{
UINT id;
DWORD style;
DWORD exstyle;
char tmp[40];
int len;
char *rcstr;
int i;
int j;
style = GetWindowLong( hwnd, GWL_STYLE );
exstyle = GetWindowLong( hwnd, GWL_EXSTYLE );
GetHexStr( str, style, 8 );
str[8] = 0;
sstr[0] = 0;
if( style & WS_CHILD ) {
id = GET_ID( hwnd );
rcstr = GetRCString( STR_CHILD_ID );
sprintf( tmp, rcstr, id, UINT_STR_LEN, id );
strcat( str, tmp );
}
for( i = 0; i < StyleArraySize; i++ ) {
if( (style & StyleArray[i].mask) == StyleArray[i].flags ) {
strcat( sstr, StyleArray[i].name );
strcat( sstr, " " );
}
}
len = GetClassName( hwnd, tmp, sizeof( tmp ) );
tmp[len] = 0;
for( i = 0; i < ClassStylesSize; i++ ) {
if( !stricmp( tmp, ClassStyles[i].class_name ) ) {
for( j = 0; j < *ClassStyles[i].style_array_size; j++ ) {
if( (style & ClassStyles[i].style_array[j].mask) ==
ClassStyles[i].style_array[j].flags ) {
strcat( sstr, ClassStyles[i].style_array[j].name );
strcat( sstr, " " );
}
}
}
}
for( i = 0; i < ExStyleArraySize; i++ ) {
if( (exstyle & ExStyleArray[i].mask) == ExStyleArray[i].flags ) {
strcat( sstr, ExStyleArray[i].name );
strcat( sstr, " " );
}
}
} /* GetWindowStyleString */
/* Runs in task threads */
void rs_threaded_load_fn(void* params, void* result, uint thread_id, uint job_id, int worker_idx)
{
struct rs_load_job_params* lparams = (struct rs_load_job_params*)params;
struct rs_load_job_result* lresult = (struct rs_load_job_result*)result;
if (worker_idx >= (int)lparams->cnt)
return;
util_sleep(100);
void* ptr = NULL;
struct rs_load_data* ldata = lparams->load_items[worker_idx];
switch (ldata->type) {
case RS_RESOURCE_TEXTURE:
ptr = gfx_texture_loaddds(ldata->filepath, ldata->params.tex.first_mipidx,
ldata->params.tex.srgb, thread_id);
if (ptr != NULL)
log_printf(LOG_LOAD, "(texture) \"%s\" - id: %d", ldata->filepath, GET_ID(ldata->hdl));
break;
case RS_RESOURCE_MODEL:
ptr = gfx_model_load(g_rs.alloc, ldata->filepath, thread_id);
if (ptr != NULL)
log_printf(LOG_LOAD, "(model) \"%s\" - id: %d", ldata->filepath, GET_ID(ldata->hdl));
break;
case RS_RESOURCE_ANIMREEL:
ptr = anim_load(g_rs.alloc, ldata->filepath, thread_id);
if (ptr != NULL)
log_printf(LOG_LOAD, "(anim-reel) \"%s\" - id:%d", ldata->filepath, GET_ID(ldata->hdl));
break;
case RS_RESOURCE_PHXPREFAB:
ptr = phx_prefab_load(ldata->filepath, g_rs.alloc, thread_id);
if (ptr != NULL)
log_printf(LOG_LOAD, "(physics) \"%s\" - id: %d", ldata->filepath, GET_ID(ldata->hdl));
break;
case RS_RESOURCE_SCRIPT:
ptr = sct_load(ldata->filepath, thread_id);
if (ptr != NULL)
log_printf(LOG_LOAD, "(script) \"%s\" - id: %d", ldata->filepath, GET_ID(ldata->hdl));
break;
case RS_RESOURCE_ANIMCTRL:
ptr = anim_ctrl_load(g_rs.alloc, ldata->filepath, thread_id);
if (ptr != NULL)
log_printf(LOG_LOAD, "(anim-ctrl) \"%s\" - id: %d", ldata->filepath, GET_ID(ldata->hdl));
break;
default:
ASSERT(0);
}
if (ptr == NULL) {
log_printf(LOG_WARNING, "res-mgr: loading resource '%s' failed", ldata->filepath);
err_clear();
}
lresult->ptrs[worker_idx] = ptr;
}
void greet_memory_mtrigger(char_data *actor)
{
trig_data *t;
char_data *ch;
struct script_memory *mem;
char buf[MAX_INPUT_LENGTH];
int command_performed = 0;
for (ch = world[IN_ROOM(actor)].people; ch; ch = ch->next_in_room) {
if (!SCRIPT_MEM(ch) || !AWAKE(ch) || FIGHTING(ch) || (ch == actor) ||
AFF_FLAGGED(ch, AFF_CHARM))
continue;
/* find memory line with command only */
for (mem = SCRIPT_MEM(ch); mem && SCRIPT_MEM(ch); mem=mem->next) {
if (GET_ID(actor)!=mem->id) continue;
if (mem->cmd) {
command_interpreter(ch, mem->cmd); /* no script */
command_performed = 1;
break;
}
}
/* if a command was not performed execute the memory script */
if (mem && !command_performed) {
for (t = TRIGGERS(SCRIPT(ch)); t; t = t->next) {
if (IS_SET(GET_TRIG_TYPE(t), MTRIG_MEMORY) &&
CAN_SEE(ch, actor) &&
!GET_TRIG_DEPTH(t) &&
number(1, 100) <= GET_TRIG_NARG(t)) {
ADD_UID_VAR(buf, t, actor, "actor", 0);
script_driver(ch, t, MOB_TRIGGER, TRIG_NEW);
break;
}
}
}
/* delete the memory */
if (mem) {
if (SCRIPT_MEM(ch)==mem) {
SCRIPT_MEM(ch) = mem->next;
} else {
struct script_memory *prev;
prev = SCRIPT_MEM(ch);
while (prev->next != mem) prev = prev->next;
prev->next = mem->next;
}
if (mem->cmd) free(mem->cmd);
free(mem);
}
}
}
int
remind_headers_state(GtkWidget *window){
GtkWidget *view;
GList *cols,*node;
int count;
GtkTreeViewColumn *col;
dbg_out("here\n");
g_assert(window);
view=lookup_widget(GTK_WIDGET(window),"messageUserTree");
cols=gtk_tree_view_get_columns(GTK_TREE_VIEW(view));
for(node=g_list_first(cols),count=0;node;node=g_list_next (node),++count) {
g_assert(node->data);
col=node->data;
dbg_out("%d : %d\n",count,GET_ID(col));
hostinfo_set_ipmsg_header_order(count,GET_ID(col));
}
return 0;
}
recEventEventaVec recEventa::GetEventEventas( idt erID )
{
recEventEventaVec vec;
wxSQLite3StatementBuffer sql;
wxSQLite3ResultSet result;
sql.Format(
"SELECT id, event_id, conf, note FROM "
" EventEventa WHERE eventa_id=" ID ";",
erID
);
result = s_db->ExecuteQuery( sql );
recEventEventa eer(0);
eer.FSetEventaID( erID );
while( result.NextRow() ) {
eer.FSetID( GET_ID( result.GetInt64( 0 ) ) );
eer.FSetEventID( GET_ID( result.GetInt64( 1 ) ) );
eer.FSetConf( result.GetDouble( 2 ) );
eer.FSetNote( result.GetAsString( 3 ) );
vec.push_back( eer );
}
return vec;
}
recFamilyIndEventaVec recEventa::GetFamilyIndEventas( idt eaID )
{
recFamilyIndEventaVec vec;
wxSQLite3StatementBuffer sql;
wxSQLite3ResultSet result;
sql.Format(
"SELECT id, fam_ind_id, conf, note FROM "
" FamilyIndEventa WHERE eventa_id=" ID ";",
eaID
);
result = s_db->ExecuteQuery( sql );
recFamilyIndEventa fiea(0);
fiea.FSetEventaID( eaID );
while( result.NextRow() ) {
fiea.FSetID( GET_ID( result.GetInt64( 0 ) ) );
fiea.FSetFamIndID( GET_ID( result.GetInt64( 1 ) ) );
fiea.FSetConf( result.GetDouble( 2 ) );
fiea.FSetNote( result.GetAsString( 3 ) );
vec.push_back( fiea );
}
return vec;
}
struct ImBuf *IMB_loadiffmem(int *mem, int flags) {
int len,maxlen;
struct ImBuf *ibuf;
// IMB_loadiffmem shouldn't be used anymore in new development
// it's still here to be backwards compatible...
maxlen= (GET_BIG_LONG(mem+1) + 1) & ~1;
if (GET_ID(mem) == CAT) {
mem += 3;
maxlen -= 4;
while(maxlen > 0) {
if (GET_ID(mem) == FORM) {
len = ((GET_BIG_LONG(mem+1) + 1) & ~1) + 8;
if ((GET_ID(mem+2) == ILBM) || (GET_ID(mem+2) == ANIM)) break;
mem = (int *)((uchar *)mem +len);
maxlen -= len;
} else return(0);
}
}
if (maxlen > 0) {
if (GET_ID(mem) == FORM) {
if (GET_ID(mem+2) == ILBM) {
return (imb_loadamiga(mem, flags));
} else if (GET_ID(mem+5) == ILBM) { /* animaties */
return (imb_loadamiga(mem+3, flags));
} else if (GET_ID(mem+2) == ANIM) {
return (imb_loadanim(mem, flags));
}
} else if ((GS(mem) == IMAGIC) || (GSS(mem) == IMAGIC)) {
return (imb_loadiris((uchar *) mem,flags));
} else if ((BIG_LONG(mem[0]) & 0xfffffff0) == 0xffd8ffe0) {
return (0);
}
}
ibuf = imb_loadtarga((uchar *) mem,maxlen,flags);
if (ibuf) return(ibuf);
if (IB_verbose) fprintf(stderr,"Unknown fileformat\n");
return (0);
}
/*
* Init JNI fields that will be used by generateKey()
*/
static int
InitJniGenKey(vlc_keystore *p_keystore, JNIEnv *p_env)
{
jclass clazz = NULL;
GET_CLASS("android/security/keystore/KeyProperties");
GET_CONST_INT(KeyProperties.PURPOSE_ENCRYPT, "PURPOSE_ENCRYPT");
GET_CONST_INT(KeyProperties.PURPOSE_DECRYPT, "PURPOSE_DECRYPT");
GET_CONST_OBJ(KeyProperties.BLOCK_MODE_CBC,
"BLOCK_MODE_CBC", "Ljava/lang/String;");
GET_CONST_OBJ(KeyProperties.ENCRYPTION_PADDING_PKCS7,
"ENCRYPTION_PADDING_PKCS7", "Ljava/lang/String;");
GET_CONST_OBJ(KeyProperties.KEY_ALGORITHM_AES,
"KEY_ALGORITHM_AES", "Ljava/lang/String;");
GET_CLASS("android/security/keystore/KeyGenParameterSpec$Builder");
GET_GLOBAL_CLASS(KeyGenParameterSpec.Builder);
GET_ID(GetMethodID, KeyGenParameterSpec.Builder.ctor, "<init>",
"(Ljava/lang/String;I)V");
GET_ID(GetMethodID, KeyGenParameterSpec.Builder.setKeySize, "setKeySize",
"(I)Landroid/security/keystore/KeyGenParameterSpec$Builder;");
GET_ID(GetMethodID, KeyGenParameterSpec.Builder.setBlockModes, "setBlockModes",
"([Ljava/lang/String;)"
"Landroid/security/keystore/KeyGenParameterSpec$Builder;");
GET_ID(GetMethodID, KeyGenParameterSpec.Builder.setEncryptionPaddings,
"setEncryptionPaddings", "([Ljava/lang/String;)"
"Landroid/security/keystore/KeyGenParameterSpec$Builder;");
GET_ID(GetMethodID, KeyGenParameterSpec.Builder.build, "build",
"()Landroid/security/keystore/KeyGenParameterSpec;");
GET_CLASS("javax/crypto/KeyGenerator");
GET_GLOBAL_CLASS(KeyGenerator);
GET_ID(GetStaticMethodID, KeyGenerator.getInstance, "getInstance",
"(Ljava/lang/String;Ljava/lang/String;)Ljavax/crypto/KeyGenerator;");
GET_ID(GetMethodID, KeyGenerator.init, "init",
"(Ljava/security/spec/AlgorithmParameterSpec;)V");
GET_ID(GetMethodID, KeyGenerator.generateKey, "generateKey",
"()Ljavax/crypto/SecretKey;");
DEL_LREF(clazz);
return VLC_SUCCESS;
}
void entry_memory_mtrigger(char_data *ch)
{
trig_data *t;
char_data *actor;
struct script_memory *mem;
char buf[MAX_INPUT_LENGTH];
if (!SCRIPT_MEM(ch) || AFF_FLAGGED(ch, AFF_CHARM))
return;
for (actor = world[IN_ROOM(ch)].people; actor && SCRIPT_MEM(ch);
actor = actor->next_in_room) {
if (actor!=ch && SCRIPT_MEM(ch)) {
for (mem = SCRIPT_MEM(ch); mem && SCRIPT_MEM(ch); mem = mem->next) {
if (GET_ID(actor)==mem->id) {
struct script_memory *prev;
if (mem->cmd) command_interpreter(ch, mem->cmd);
else {
for (t = TRIGGERS(SCRIPT(ch)); t; t = t->next) {
if (TRIGGER_CHECK(t, MTRIG_MEMORY) && (number(1, 100) <=
GET_TRIG_NARG(t))){
ADD_UID_VAR(buf, t, actor, "actor", 0);
script_driver(ch, t, MOB_TRIGGER, TRIG_NEW);
break;
}
}
}
/* delete the memory */
if (SCRIPT_MEM(ch)==mem) {
SCRIPT_MEM(ch) = mem->next;
} else {
prev = SCRIPT_MEM(ch);
while (prev->next != mem) prev = prev->next;
prev->next = mem->next;
}
if (mem->cmd) free(mem->cmd);
free(mem);
}
} /* for (mem =..... */
}
}
}
