//
// Returns true if the child has been found (and replaced).
//
bool ForallIntents::replaceChildFI(Expr* oldAst, Expr* newAst) {
INT_ASSERT(oldAst != NULL);
#define UPDATE(dest, newNode) \
if ((dest) == oldAst) { (dest) = newNode; return true; }
for (std::vector<Expr*>::iterator itv = fiVars.begin();
itv != fiVars.end(); itv++)
UPDATE(*itv, newAst);
for (std::vector<Expr*>::iterator itr = riSpecs.begin();
itr != riSpecs.end(); itr++)
UPDATE(*itr, newAst);
// Does this ever get invoked with newAst==NULL?
// If so, the 'if' should read "if (newSE || !newAst)".
INT_ASSERT(newAst);
if (SymExpr* newSE = toSymExpr(newAst)) {
UPDATE(iterRec, newSE);
UPDATE(leadIdx, newSE);
UPDATE(leadIdxCopy, newSE);
}
// nothing matched
#undef UPDATE
return false;
}
void CFootBotEntity::UpdateComponents() {
/* Update only the components that might change */
UPDATE(m_pcDistanceScannerEquippedEntity);
UPDATE(m_pcTurretEntity);
UPDATE(m_pcGripperEquippedEntity);
UPDATE(m_pcRABEquippedEntity);
UPDATE(m_pcLEDEquippedEntity);
}
/* Update a single UTF string. Return string->next */
void *
updateUTFString(void *object)
{
UString entry = object;
UString next = entry->next; /* grab before modifying */
UPDATE(entry->next);
UPDATE(entry->length);
UPDATE(entry->key);
return next;
}
static afs_int32 do_eval_policy( unsigned int policyIndex, afs_uint64 size,
char *fileName, afs_int32 (*evalclient)(void*, afs_int32), void *client,
afs_uint32 *props)
{
osddb_policy *pol = get_pol(policyIndex);
afs_int32 tcode;
int r;
if ( !pol ) {
ViceLog(0, ("failed to lookup policy %d\n", policyIndex));
return ENOENT;
}
for ( r = 0 ; r < pol->rules.pol_ruleList_len ; r++ ) {
pol_rule rule = pol->rules.pol_ruleList_val[r];
int matched = 1;
if ( rule.used_policy ) {
ViceLog(2, ("recursively evaluating policy %d\n", rule.used_policy));
tcode = do_eval_policy(
rule.used_policy, size, fileName, evalclient, client, props);
ViceLog(2, ("recursion done, props are now 0x%x\n", *props));
if ( ( tcode && tcode != ENOENT ) || POLPROP_FORCE(*props) )
return tcode;
}
else {
tcode = eval_condtree(&rule.condition, size, fileName,
evalclient, client, &matched);
if ( tcode == EINVAL ) {
ViceLog(0, ("policy %d may contain unknown predicate type\n",
policyIndex));
}
if ( tcode )
return tcode;
if ( matched ) {
ViceLog(2, ("updating: props 0x%x with 0x%x\n", *props, rule.properties));
UPDATE(POLPROP_LOCATION, POLICY_LOCATION_MASK);
UPDATE(POLPROP_NSTRIPES, POLICY_NSTRIPES_MASK);
UPDATE(POLPROP_SSTRIPES, POLICY_SSTRIPES_MASK);
UPDATE(POLPROP_NCOPIES, POLICY_NCOPIES_MASK);
UPDATE(POLPROP_FORCE, POLICY_CONT_OP_MASK);
if ( POLPROP_FORCE(rule.properties) ) {
TRACE_POLICY(2);
return 0;
}
}
}
}
TRACE_POLICY(2);
return 0;
}
static void _remove(ptst_t *ptst, node_t *a, int dir1, int dir2, qnode_t **pqn)
{
node_t *b = FOLLOW(a, dir1), *c = FOLLOW(b, dir2);
assert(FOLLOW(b, FLIP(dir2)) == NULL);
assert(!IS_BLUE(a));
assert(!IS_BLUE(b));
UPDATE(a, dir1, c);
UPDATE(b, FLIP(dir2), c);
b->p = a;
MK_BLUE(b);
gc_free(ptst, b, gc_id);
UNLOCK(a, pqn[0]);
UNLOCK(b, pqn[1]);
}
void ECRYPT_Trivium::TRIVIUM_process_bytes(
int action, void* ctxa, const u8* input, u8* output, u32 msglen) {
TRIVIUM_ctx* ctx = (TRIVIUM_ctx*)ctxa;
m64 s11, s12;
m64 s21, s22;
m64 s31, s32;
LOAD(ctx->state);
for (; (int)(msglen -= 16) >= 0; output += 16, input += 16) {
m64 t1, t2, t3, z[2];
UPDATE();
z[0] = XOR(XOR(s12, s22), s32);
ROTATE();
UPDATE();
z[1] = XOR(XOR(s12, s22), s32);
ROTATE();
M64TO64_CONVERT(z[0]);
((m64*)output)[0] = XOR(((m64*)input)[0], z[0]);
M64TO64_CONVERT(z[1]);
((m64*)output)[1] = XOR(((m64*)input)[1], z[1]);
}
for (msglen += 16; (int)msglen > 0; msglen -= 8, output += 8, input += 8) {
m64 t1, t2, t3, z;
UPDATE();
z = XOR(XOR(s12, s22), s32);
if (msglen >= 8) {
M64TO64_CONVERT(z);
((m64*)output)[0] = XOR(((m64*)input)[0], z);
} else {
u32 i;
for (i = 0; i < msglen; ++i, z = SF(z, 8))
output[i] = input[i] ^ M8V(z);
}
ROTATE();
}
STORE(ctx->state);
EMPTY();
}
void dijkstra(const digrafo_pesado& g, int v, vcosto& dist) {
int n = g.size();
cola c;
vbool vistos(n, false);
dist[v] = 0;
c.insert(estimado(dist[v], v));
while(!c.empty()) {
estimado es = PRIMERO(c); // look for the nearest element
c.erase(es); // tail it out
nodo p = es.second; // p is the node itself
vistos[p] = true;
forall(it, g[p]) { // for each neighbor p
eje e = *it;
costo s = e.first;
nodo w = e.second;
if(vistos[w]) continue; // if you already know the best distance, I do nothing
costo nuevo = dist[p] + s; //cost of going to p, and use and
if(dist[w] <= nuevo) continue; // if I can not improve w p, I do nothing
UPDATE(c, w, dist[w], nuevo); // I update the tail
dist[w] = nuevo; // I update the estimate of the cost to w
}
}
void
PatchView::button_clicked( int diffType )
{
QString sha;
switch( diffType )
{
case DIFF_TO_PARENT:
break;
case DIFF_TO_HEAD:
sha = "HEAD";
break;
case DIFF_TO_SHA:
sha = patchTab->lineEditDiff->text();
break;
}
if( sha == QGit::ZERO_SHA )
return;
//
// Check for a ref name or an abbreviated form
//
normalizedSha = ( sha.length() != 40 && !sha.isEmpty() ? git->getRefSha( sha ) : sha );
if( normalizedSha != st.diffToSha() )
{ // Avoid looping
st.setDiffToSha( normalizedSha ); // Could be empty
UPDATE();
}
}
void RevsView::on_loadCompleted(const FileHistory* fh, const QString& stats) {
if (!git->isMainHistory(fh))
return;
UPDATE(); // restore revision after a refresh
QApplication::postEvent(this, new MessageEvent(stats));
}
int STD_UPDATE(int i, int j, int k, char * success)
{
char str1[BUFFER_LEN];
char str2[BUFFER_LEN];
sprintf(str1, "%d", i);
sprintf(str2, "%d", j);
return UPDATE(str1, str2, k, success);
}
int main( int argc, char *argv[] )
{
long int sleep_time;
int server_port;
char server_ip[] = "000.000.000.000";
LOG_OPEN();
if (argc != 5)
{
print_help();
exit(EXIT_SUCCESS);
}
else
{
// to do: user input validation!
sensor_id = atoi(argv[1]);
sleep_time = atoi(argv[2]);
strncpy(server_ip, argv[3],strlen(server_ip));
server_port = atoi(argv[4]);
//printf("%d %ld %s %d\n", sensor_id, sleep_time, server_ip, server_port);
}
srand48( time(NULL) );
// open TCP connection to the server; server is listening to SERVER_IP and PORT
client = tcp_active_open( server_port, server_ip );
int i=LOOPS;
signal(SIGINT, my_handler);
while(running)
{
temperature = temperature + TEMP_DEV * ((drand48() - 0.5)/10);
time(×tamp);
// send data to server in this order (!!): <sensor_id><temperature><timestamp>
// remark: don't send as a struct!
tcp_send( client, (void *)&sensor_id, sizeof(sensor_id));
tcp_send( client, (void *)&temperature, sizeof(temperature));
tcp_send( client, (void *)×tamp, sizeof(timestamp));
LOG_PRINTF(sensor_id,temperature,timestamp);
sleep(sleep_time);
UPDATE(i);
}
i = 0;
tcp_close( &client );
LOG_CLOSE();
exit(EXIT_SUCCESS);
}
/* Update a hashtable. Call the functor on each of its elements */
static void
updateHashTable(HASHTABLE table, fixupFunction functor)
{
int i;
long bucketCount = table->bucketCount;
/* Update these two fields */
UPDATE(table->bucketCount);
UPDATE(table->count);
for (i = 0; i < bucketCount; i++) {
void *ptr = table->bucket[i];
UPDATE(table->bucket[i]);
while (ptr != NULL) {
ptr = functor(ptr);
}
}
}
DialogsProvider::~DialogsProvider()
{
WindowSettings *ws = p_intf->p_sys->p_window_settings;
#define UPDATE(id,w) \
{ \
if( w && w->IsShown() && !w->IsIconized() ) \
ws->SetSettings( WindowSettings::id, true, \
w->GetPosition(), w->GetSize() ); \
else \
ws->SetSettings( WindowSettings::id, false ); \
}
UPDATE( ID_PLAYLIST, p_playlist_dialog );
UPDATE( ID_MESSAGES, p_messages_dialog );
UPDATE( ID_FILE_INFO, p_fileinfo_dialog );
UPDATE( ID_BOOKMARKS, p_bookmarks_dialog );
#undef UPDATE
PopEventHandler(true);
/* Clean up */
if( p_open_dialog ) delete p_open_dialog;
if( p_prefs_dialog ) p_prefs_dialog->Destroy();
if( p_file_dialog ) delete p_file_dialog;
if( p_playlist_dialog ) delete p_playlist_dialog;
if( p_messages_dialog ) delete p_messages_dialog;
if( p_fileinfo_dialog ) delete p_fileinfo_dialog;
if( p_file_generic_dialog ) delete p_file_generic_dialog;
if( p_wizard_dialog ) delete p_wizard_dialog;
if( p_bookmarks_dialog ) delete p_bookmarks_dialog;
if( p_updatevlc_dialog ) delete p_updatevlc_dialog;
if( p_vlm_dialog ) delete p_vlm_dialog;
if( p_intf->p_sys->p_icon ) delete p_intf->p_sys->p_icon;
/* We must set this here because on win32 this destructor will be
* automatically called so we must not call it again on wxApp->OnExit().
* There shouldn't be any race conditions as all this should be done
* from the same thread. */
p_intf->p_sys->p_wxwindow = NULL;
}
void ECRYPT_Trivium::ECRYPT_ivsetup(const u8* iv) {
TRIVIUM_ctx* ctx = &_ctx;
const u32 ivlen = LOAD_IVLEN(ctx->init[0]);
u32 i;
u8* s = (u8*)(ctx->state + 2) + 16 - ivlen;
m64 s11, s12;
m64 s21, s22;
m64 s31, s32;
ctx->state[0] = ctx->init[0];
ctx->state[1] = ctx->init[1];
ctx->state[4] = PADDING;
ctx->state[5] = 0;
ctx->state[2] = ctx->state[3] = 0;
for (i = 0; i < ivlen; ++i, ++s)
*s = iv[i];
ctx->state[2] = U64TO64_CONVERT(ctx->state[2]);
ctx->state[3] = U64TO64_CONVERT(ctx->state[3]);
LOAD(ctx->state);
// default 9
for (i = 0; i < numRounds; ++i) {
m64 t1, t2, t3;
UPDATE();
ROTATE();
UPDATE();
ROTATE();
}
STORE(ctx->state);
EMPTY();
}
static node_t *rotate(ptst_t *ptst, node_t *a, int dir1,
int dir2, node_t **pc, qnode_t *pqn[])
{
node_t *b = FOLLOW(a, dir1), *c = FOLLOW(b, dir2);
node_t *bp = gc_alloc(ptst, gc_id), *cp = gc_alloc(ptst, gc_id);
qnode_t c_qn;
LOCK(c, &c_qn);
memcpy(bp, b, sizeof(*b));
memcpy(cp, c, sizeof(*c));
mcs_init(&bp->lock);
mcs_init(&cp->lock);
LOCK(bp, pqn[3]);
LOCK(cp, pqn[2]);
assert(!IS_BLUE(a));
assert(!IS_BLUE(b));
assert(!IS_BLUE(c));
UPDATE(cp, FLIP(dir2), bp);
UPDATE(bp, dir2, FOLLOW(c, FLIP(dir2)));
UPDATE(a, dir1, cp);
b->p = a;
MK_BLUE(b);
c->p = cp;
MK_BLUE(c);
gc_free(ptst, b, gc_id);
gc_free(ptst, c, gc_id);
UNLOCK(a, pqn[0]);
UNLOCK(b, pqn[1]);
UNLOCK(c, &c_qn);
*pc = bp;
return cp;
}
//inst : db . string . instaux
void inst(){
Test_Symbole(DB_TOKEN,DB_ERR);
Test_Symbole(POINT_TOKEN,POINT_ERR);
Test_Symbole(STRING_TOKEN,STRING_ERR);
Test_Symbole(POINT_TOKEN,POINT_ERR);
switch(sym_cour.code){
case FIND_TOKEN : sym_suiv(); Test_Symbole(PARO_TOKEN,PARO_ERR);QUERY();break;
case UPDATE_TOKEN : sym_suiv(); Test_Symbole(PARO_TOKEN,PARO_ERR);UPDATE();break;
case INSERT_TOKEN :sym_suiv(); Test_Symbole(PARO_TOKEN,PARO_ERR);INSERT();break;
default : Error(INST_ERR) ; break;
}
Test_Symbole(PARF_TOKEN,PARF_ERR);
}
void RevsView::on_newRevsAdded(const FileHistory* fh, const QVector<ShaString>&) {
if (!git->isMainHistory(fh) || !st.sha().isEmpty())
return;
HistoryView* lv = tab()->listViewLog;
if (lv->model()->rowCount() == 0)
return;
st.setSha(lv->sha(0));
st.setSelectItem(true);
UPDATE(); // give feedback to user as soon as possible
}
int main(int argc, char **argv)
{
VSTRING *buffer = vstring_alloc(100);
MAPS *path;
ARGV *result;
/*
* Parse JCL.
*/
if (argc != 2)
msg_fatal("usage: %s database", argv[0]);
/*
* Initialize.
*/
#define UPDATE(dst, src) { myfree(dst); dst = mystrdup(src); }
mail_conf_read();
msg_verbose = 1;
if (chdir(var_queue_dir) < 0)
msg_fatal("chdir %s: %m", var_queue_dir);
path = maps_create(argv[0], argv[1], DICT_FLAG_LOCK | DICT_FLAG_FOLD_FIX);
while (vstring_fgets_nonl(buffer, VSTREAM_IN)) {
msg_info("=== Address extension on, extension propagation on ===");
UPDATE(var_rcpt_delim, "+");
if ((result = mail_addr_map(path, STR(buffer), 1)) != 0)
argv_free(result);
msg_info("=== Address extension on, extension propagation off ===");
if ((result = mail_addr_map(path, STR(buffer), 0)) != 0)
argv_free(result);
msg_info("=== Address extension off ===");
UPDATE(var_rcpt_delim, "");
if ((result = mail_addr_map(path, STR(buffer), 1)) != 0)
argv_free(result);
}
vstring_free(buffer);
maps_free(path);
return (0);
}
void encode_vector(int ignore)
{
int ix; /* Computed Codebook Index */
int vx; /* Index of Recently Read Vector */
int lgx; /* Logarithmic Gain Index */
static real QMEM *vector; /* recently read vector in the queue */
static real
zero_response[IDIM],
weighted_speech[IDIM],
target[IDIM],
normtarg[IDIM],
cb_vec[IDIM],
pn[IDIM];
static real gain =1.0, scale=1.0;
vector = vector_end - IDIM;
if (vector < thequeue)
vector += QSIZE;
vx = vector-thequeue;
if (pwf_z_coeff_obsolete_p) {
UPDATE(pwf_z_coeff); UPDATE(pwf_p_coeff);
}
SPDEBUG(10,vector, IDIM);
pwfilter2(vector, weighted_speech);
SPDEBUG(1,weighted_speech, IDIM);
UPDATE(sf_coeff);
zresp(zero_response);
SPDEBUG(2,zero_response, IDIM);
sub_sig(weighted_speech, zero_response, target);
SPDEBUG(3,target, IDIM);
scale = 1.0 / gain;
sig_scale(scale, target, normtarg);
SPDEBUG(4,normtarg, IDIM);
UPDATE(imp_resp);
trev_conv(imp_resp, normtarg, pn);
SPDEBUG(6, pn, IDIM);
UPDATE(shape_energy);
ix = cb_index(pn);
put_index(ix);
cb_excitation(ix, cb_vec);
SPDEBUG(7, cb_vec, IDIM);
sig_scale(gain, cb_vec, qspeech+vx);
SPDEBUG(8, qspeech+vx, IDIM);
UPDATE(gp_coeff);
lgx = vx/IDIM;
gain = predict_gain(qspeech+vx, log_gains + lgx);
SPDEBUG(11, &gain, 1);
SPDEBUG(12, log_gains+lgx, 1);
mem_update(qspeech+vx, synspeech+vx);
SPDEBUG(9, synspeech+vx, IDIM);
dec_end = vx+IDIM;
if (dec_end >= QSIZE)
dec_end -= QSIZE;
NEXT_FFASE;
}
/**
* Fetch the GENERIC IFMIB and update the HC counters
*/
static int
fetch_generic_mib(struct mibif *ifp, const struct ifmibdata *old)
{
int name[6];
size_t len;
struct mibif_private *p = ifp->private;
name[0] = CTL_NET;
name[1] = PF_LINK;
name[2] = NETLINK_GENERIC;
name[3] = IFMIB_IFDATA;
name[4] = ifp->sysindex;
name[5] = IFDATA_GENERAL;
len = sizeof(ifp->mib);
if (sysctl(name, 6, &ifp->mib, &len, NULL, 0) == -1) {
if (errno != ENOENT)
syslog(LOG_WARNING, "sysctl(ifmib, %s) failed %m",
ifp->name);
return (-1);
}
/*
* Assume that one of the two following compounds is optimized away
*/
if (ULONG_MAX >= 0xffffffffffffffffULL) {
p->hc_inoctets = ifp->mib.ifmd_data.ifi_ibytes;
p->hc_outoctets = ifp->mib.ifmd_data.ifi_obytes;
p->hc_omcasts = ifp->mib.ifmd_data.ifi_omcasts;
p->hc_opackets = ifp->mib.ifmd_data.ifi_opackets;
p->hc_imcasts = ifp->mib.ifmd_data.ifi_imcasts;
p->hc_ipackets = ifp->mib.ifmd_data.ifi_ipackets;
} else if (ULONG_MAX >= 0xffffffff) {
#define UPDATE(HC, MIB) \
if (old->ifmd_data.MIB > ifp->mib.ifmd_data.MIB) \
p->HC += (0x100000000ULL + \
ifp->mib.ifmd_data.MIB) - \
old->ifmd_data.MIB; \
else \
p->HC += ifp->mib.ifmd_data.MIB - \
old->ifmd_data.MIB;
UPDATE(hc_inoctets, ifi_ibytes)
UPDATE(hc_outoctets, ifi_obytes)
UPDATE(hc_omcasts, ifi_omcasts)
UPDATE(hc_opackets, ifi_opackets)
UPDATE(hc_imcasts, ifi_imcasts)
UPDATE(hc_ipackets, ifi_ipackets)
#undef UPDATE
} else
abort();
return (0);
}
//------------------- update -------------------
void update() {
#define UPDATE(STATE) if(state_ == state::STATE) STATE(); else
UPDATE(on)
UPDATE(off)
UPDATE(flash)
UPDATE(fast)
UPDATE(blink)
UPDATE(slow)
UPDATE(very_fast)
; //last else
#undef UPDATE
}
//inst : db . string . instaux
void inst(){
collection=(char*)malloc(1024*sizeof(char));
Test_Symbole(DB_TOKEN,DB_ERR);
Test_Symbole(POINT_TOKEN,POINT_ERR);
strcpy(collection,sym_cour.nom);
strcat(collection,".txt");
Test_Symbole(STRING_TOKEN,STRING_ERR);
Test_Symbole(POINT_TOKEN,POINT_ERR);
switch(sym_cour.code){
case FIND_TOKEN : sym_suiv(); Test_Symbole(PARO_TOKEN,PARO_ERR);QUERY();break;
case UPDATE_TOKEN : sym_suiv(); Test_Symbole(PARO_TOKEN,PARO_ERR);UPDATE();break;
case INSERT_TOKEN :sym_suiv(); Test_Symbole(PARO_TOKEN,PARO_ERR);INSERT();break;
case REMOVE_TOKEN :sym_suiv(); Test_Symbole(PARO_TOKEN,PARO_ERR);REMOVE();break;
default : Error(INST_ERR) ; break;
}
Test_Symbole(PARF_TOKEN,PARF_ERR);
}
static Int32 N106SoundRenderReal2(void* pNezPlay)
{
N106SOUND *n106s = ((NSFNSF*)((NEZ_PLAY*)pNezPlay)->nsf)->n106s;
N106_WM *chp;
Int32 outputbuf=0,count=0,accum=0,chpn,real2=((1<<REAL_RENDERS) / n106s->chinuse);
Uint32 cyclesspd = n106s->chinuse << CPS_SHIFT;
//リアルモード
/*波形は、1chずつ出力される。
波形データ、基準は"8"。volを下げると、8に向かって+-が減衰していく。
波形データ8を再生中は高周波ノイズは出ない。8からの差とノイズの大きさは比例する。
*/
for (chp = &n106s->ch[0],chpn = 0
; chp < &n106s->ch[8]; chp++,chpn++)
{
accum = 0;
count = 0;
if (chp->mute || !chp->logvol) continue;
if (chp->update) UPDATE(chp);
chp->cycles2 += n106s->cps << REAL_RENDERS;
chp->output = LogToLinear(n106s->tone[((chp->phase >> PHASE_SHIFT) + chp->tadr) & 0xff] + chp->logvol + n106s->mastervolume, LOG_LIN_BITS - LIN_BITS - LIN_BITS - 11);
while (chp->cycles2 >= n106s->cpsf){
if (((Int32)chp->count / real2) + 8 - n106s->chinuse == chpn)accum += chp->output;
count++;
chp->cycles2 -= n106s->cpsf;
chp->count++;
if(chp->count >= (1<<REAL_RENDERS)){
chp->count = 0;
chp->cycles += n106s->cpsf;
chp->phase += chp->spd * (chp->cycles / cyclesspd);
chp->cycles %= cyclesspd;
//while(chp->cycles >= cyclesspd)chp->cycles -= cyclesspd;
chp->phase %= chp->tlen;
//while(chp->phase >= chp->tlen)chp->phase -= chp->tlen;
chp->output = LogToLinear(n106s->tone[((chp->phase >> PHASE_SHIFT) + chp->tadr) & 0xff] + chp->logvol + n106s->mastervolume, LOG_LIN_BITS - LIN_BITS - LIN_BITS - 11);
}
}
if (((Int32)chp->count / real2) == chpn)accum += chp->output;
count++;
if (chmask[DEV_N106_CH1+chpn])outputbuf += accum / count;
}
/* Update the hash entry of an interned string, and the corresponding String */
void*
updateInternString(void *object)
{
STRING_HASH_ENTRY entry = object;
STRING_HASH_ENTRY next = entry->next;
STRING_INSTANCE string = entry->string;
UPDATE(entry->next);
UPDATE(entry->string);
UPDATE(string->ofClass);
UPDATE(string->monitor);
UPDATE(string->array);
UPDATE(string->offset);
UPDATE(string->length);
return next;
}
static int32 N106SoundRender(void)
{
N106_WM *chp;
int32 accum = 0;
for (chp = &n106_sound.ch[8 - n106_sound.chinuse]; chp < &n106_sound.ch[8]; chp++)
{
uint32 cyclesspd = n106_sound.chinuse << 20;
if (chp->update) UPDATE(chp);
chp->cycles -= n106_sound.cps;
while (chp->cycles < 0)
{
chp->cycles += cyclesspd;
chp->phase += chp->spd;
}
while (chp->phase >= chp->tlen) chp->phase -= chp->tlen;
if (chp->mute) continue;
accum += LogToLinear(n106_sound.tone[((chp->phase >> 18) + chp->tadr) & 0xff] + chp->logvol + n106_sound.mastervolume, LOG_LIN_BITS - LIN_BITS - LIN_BITS - 10);
}
return accum >> 8;
}
void dxsi_encodedvalue(DexEncodedValue* obj, dx_shift* shift) {
unsigned int i;
uint8_t value_type;
value_type = (obj->argtype & 0x1f);
switch (value_type) {
case 0x17:
UPDATE(*((uint32_t*)obj->value));
break;
case 0x1C:
dxsi_encodedarray((DexEncodedArray*) obj->value,shift);
break;
case 0x1d:
dxsi_encodedannotation((DexEncodedAnnotation*)obj->value,shift);
break;
default:
break;
}
}
bool DataMapper<Subclass, T, I>::save(T * model)
{
if (!model)
{
return false;
}
Identity id = idOf(model);
QVariantMap record;
buildRecordFrom(model, record);
QList<QString> variables = record.keys();
if (isValidId(id))
{
record[identityFieldName()] = id;
QSqlQuery query = getDatabase().build(UPDATE(table()).SET(variables).WHERE(identityFieldName() + " = :" + identityFieldName()), record);
query.exec();
}
else
{
QSqlQuery query = getDatabase().build(INSERT().INTO(table()).SET(variables, true), record);
if (query.exec())
{
Identity id = query.lastInsertId().value<Identity>();
if (isValidId(id))
{
m_identities.registerModel(id, model);
}
}
}
saveRelationsOf(model);
return true;
}
setval_t set_update(set_t *s, setkey_t k, setval_t v, int overwrite)
{
node_t *f, *w;
qnode_t f_qn, w_qn;
int dir;
setval_t ov = NULL;
ptst_t *ptst;
k = CALLER_TO_INTERNAL_KEY(k);
ptst = critical_enter();
retry:
f = find(&s->root, k, &f_qn, &dir);
if ( (w = FOLLOW(f, dir)) != NULL )
{
/* Protected by parent lock. */
assert(!IS_BLUE(w));
ov = w->v;
if ( overwrite || (ov == NULL) ) w->v = v;
}
else
{
w = gc_alloc(ptst, gc_id);
w->l = NULL;
w->r = NULL;
w->v = v;
w->k = k;
mcs_init(&w->lock);
UPDATE(f, dir, w);
}
UNLOCK(f, &f_qn);
critical_exit(ptst);
return ov;
}
void imx233_timrot_setup(unsigned timer_nr, bool reload, unsigned count,
unsigned src, unsigned prescale, bool polarity, imx233_timer_fn_t fn)
{
int oldstatus = disable_interrupt_save(IRQ_FIQ_STATUS);
/* only enable interrupt if function is set */
bool irq = fn != NULL;
timer_fns[timer_nr] = fn;
/* make sure we start from stop state */
HW_TIMROT_TIMCTRLn(timer_nr) = BF_OR2(TIMROT_TIMCTRLn,
SELECT(BV_TIMROT_TIMCTRLn_SELECT__NEVER_TICK), UPDATE(1));
/* write count and take effect immediately with UPDATE
* manual says count-1 for reload timers */
HW_TIMROT_TIMCOUNTn(timer_nr) = reload ? count - 1 : count;
/* start timer */
HW_TIMROT_TIMCTRLn(timer_nr) = BF_OR6(TIMROT_TIMCTRLn, SELECT(src),
PRESCALE(prescale), POLARITY(polarity), RELOAD(reload), IRQ(irq),
IRQ_EN(irq));
imx233_icoll_enable_interrupt(INT_SRC_TIMER(timer_nr), irq);
restore_interrupt(oldstatus);
}
void
ISR_syscall(interrupt_frame frame)
{
UPDATE(&frame);
va_list ap;
syscall_result_t result;
thread_t *thisthr = curthread;
irq_enable();
mem_zero(&result, sizeof(result));
ap = (va_list) (frame.f_esp + 16);
thisthr->thr_flags |= THREAD_SYSCALL;
syscall(thisthr, frame.f_eax, &result, ap);
thisthr->thr_flags &= ~THREAD_SYSCALL;
signal_handle(thisthr);
// result
frame.f_eax = result.result;
frame.f_ecx = result.errno;
}
