void
task1(intptr_t exinf)
{
ER ercd;
T_RTEX rtex;
/*
* 初期状態のチェック
*/
check_point(1);
check_state(false, false, TIPM_ENAALL, false, false, true);
ercd = ref_tex(TSK_SELF, &rtex);
check_ercd(ercd, E_OK);
check_assert((rtex.texstat & TTEX_DIS) != 0);
check_assert(rtex.pndptn == 0);
/*
* ras_texのエラー検出
*/
ercd = ras_tex(TASK3, 0x0001);
check_ercd(ercd, E_OBJ);
ercd = ras_tex(TASK4, 0x0001);
check_ercd(ercd, E_OBJ);
/*
* ref_texのエラー検出
*/
ercd = ref_tex(TASK3, &rtex);
check_ercd(ercd, E_OBJ);
ercd = ref_tex(TASK4, &rtex);
check_ercd(ercd, E_OBJ);
/*
* タスク例外処理の許可
*/
check_point(2);
ercd = ena_tex();
check_ercd(ercd, E_OK);
check_state(false, false, TIPM_ENAALL, false, false, false);
ercd = ref_tex(TSK_SELF, &rtex);
check_ercd(ercd, E_OK);
check_assert((rtex.texstat & TTEX_ENA) != 0);
check_assert(rtex.pndptn == 0);
/*
* タスク例外処理を要求
*/
check_point(3);
ercd = ras_tex(TSK_SELF, 0x0001);
/* ここでタスク例外処理ルーチンが動作する */
check_ercd(ercd, E_OK);
/*
* タスク例外処理からのリターンにより元の状態に戻っていることを
* チェック
*/
check_point(6);
check_state(false, false, TIPM_ENAALL, false, false, false);
/*
* ディスパッチ禁止，割込み優先度マスク変更，タスク例外処理禁止
*/
check_point(7);
ercd = dis_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMIN_INTPRI);
check_ercd(ercd, E_OK);
ercd = dis_tex();
check_ercd(ercd, E_OK);
check_state(false, false, TMIN_INTPRI, true, true, true);
/*
* タスク例外処理を要求
*/
check_point(8);
ercd = ras_tex(TASK1, 0x0002);
check_ercd(ercd, E_OK);
ercd = ref_tex(TSK_SELF, &rtex);
check_ercd(ercd, E_OK);
check_assert((rtex.texstat & TTEX_DIS) != 0);
check_assert(rtex.pndptn == 0x0002);
/*
* タスク例外処理を許可
*/
check_point(9);
ercd = ena_tex();
/* ここでタスク例外処理ルーチンが動作する */
check_ercd(ercd, E_OK);
/*
* タスク例外処理からのリターンにより元の状態に戻っていることを
* チェック
*/
check_point(19);
check_state(false, false, TMIN_INTPRI, true, true, false);
/*
* タスク2に切り換える
*/
check_point(20);
ercd = ena_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TIPM_ENAALL);
check_ercd(ercd, E_OK);
ercd = rot_rdq(TPRI_SELF);
/* ここで他のタスクが動作する */
check_ercd(ercd, E_OK);
/*
* タスク2に対してタスク例外処理を要求
*/
check_point(26);
ercd = ras_tex(TASK2, 0x0001);
check_ercd(ercd, E_OK);
ercd = ref_tex(TASK2, &rtex);
check_ercd(ercd, E_OK);
check_assert((rtex.texstat & TTEX_ENA) != 0);
check_assert(rtex.pndptn == 0x0001);
/*
* タスク2に切り換える
*/
check_point(27);
ercd = rot_rdq(TPRI_SELF);
/* ここで他のタスクが動作する */
check_ercd(ercd, E_OK);
/*
* タスク終了
*/
check_point(33);
}
void st_validate_state( struct st_context *st )
{
struct st_state_flags *state = &st->dirty;
GLuint i;
/* The bitmap cache is immune to pixel unpack changes.
* Note that GLUT makes several calls to glPixelStore for each
* bitmap char it draws so this is an important check.
*/
if (state->mesa & ~_NEW_PACKUNPACK)
st_flush_bitmap_cache(st);
check_program_state( st );
st_manager_validate_framebuffers(st);
if (state->st == 0)
return;
/*printf("%s %x/%x\n", __FUNCTION__, state->mesa, state->st);*/
if (1) {
/* Debug version which enforces various sanity checks on the
* state flags which are generated and checked to help ensure
* state atoms are ordered correctly in the list.
*/
struct st_state_flags examined, prev;
memset(&examined, 0, sizeof(examined));
prev = *state;
for (i = 0; i < Elements(atoms); i++) {
const struct st_tracked_state *atom = atoms[i];
struct st_state_flags generated;
/*printf("atom %s %x/%x\n", atom->name, atom->dirty.mesa, atom->dirty.st);*/
if (!(atom->dirty.mesa || atom->dirty.st) ||
!atom->update) {
printf("malformed atom %s\n", atom->name);
assert(0);
}
if (check_state(state, &atom->dirty)) {
atoms[i]->update( st );
/*printf("after: %x\n", atom->dirty.mesa);*/
}
accumulate_state(&examined, &atom->dirty);
/* generated = (prev ^ state)
* if (examined & generated)
* fail;
*/
xor_states(&generated, &prev, state);
assert(!check_state(&examined, &generated));
prev = *state;
}
/*printf("\n");*/
}
else {
for (i = 0; i < Elements(atoms); i++) {
if (check_state(state, &atoms[i]->dirty))
atoms[i]->update( st );
}
}
memset(state, 0, sizeof(*state));
}
void CStateManagerBloodsucker::execute ()
{
u32 state_id = u32(-1);
const CEntityAlive* enemy = object->EnemyMan.get_enemy();
if ( !object->is_drag_anim_jump() && !object->is_animated() )
{
if ( enemy )
{
if ( check_state(eStateCustom_Vampire) )
{
state_id = eStateCustom_Vampire;
}
else
{
switch ( object->EnemyMan.get_danger_type() )
{
case eStrong: state_id = eStatePanic; break;
case eWeak: state_id = eStateAttack; break;
}
}
}
else if ( object->HitMemory.is_hit() )
{
state_id = eStateHitted;
}
else if ( object->hear_interesting_sound )
{
state_id = eStateHearInterestingSound;
}
else
{
if ( can_eat() ) state_id = eStateEat;
else state_id = eStateRest;
}
///////////////////////////////////////////////////////////////////////////////
// Additional
///////////////////////////////////////////////////////////////////////////////
// check if start interesting sound state
// if ( (prev_substate != eStateHearInterestingSound) && (state_id == eStateHearInterestingSound) )
// {
// object->start_invisible_predator();
// }
// else
// // check if stop interesting sound state
// if ( (prev_substate == eStateHearInterestingSound) && (state_id != eStateHearInterestingSound) )
// {
// object->stop_invisible_predator();
// }
select_state(state_id);
// выполнить текущее состояние
get_state_current()->execute();
prev_substate = current_substate;
}
else
{
state_id = eStateCustom;
if ( object->is_drag_anim_jump() )
{
select_state(state_id);
// выполнить текущее состояние
get_state_current()->execute();
prev_substate = current_substate;
drag_object();
}
}
}
void
on_ok_fileselection_clicked(GtkWidget *file, GtkFileSelection *fs)
{
int fd, i, size;
char *cmd, buf[MAX_BUF];
#ifdef DEBUG
GtkWidget *error_dialog = NULL;
#endif
size = strlen(exec_path) + strlen(" -c ") + strlen(gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs))) + 1;
cmd = (char *) malloc (size*sizeof(char));
strcpy (cmd, exec_path);
strcat (cmd, " -c ");
strcat (cmd, gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
for(i = 0; i < MAX_PID; i++) {
if(table[i].process == NULL) {
cur_pid = i;
break;
}
}
runPeos(cmd);
free(cmd);
cmd = NULL;
fd = open ("message", O_RDONLY);
if(fd < 0) {
perror("An error has occurred when attempting to open 'message' \n");
exit(1);
}
read (fd, buf, MAX_BUF);
close (fd);
#ifdef DEBUG
if (strncmp ("Executing", buf, 9) != 0) {
error_dialog = create_errordialog();
gtk_widget_show (error_dialog);
} else {
#endif
gtk_widget_destroy (notebook);
freeAll_extra();
notebook = create_notebook();
gtk_widget_set_name (notebook, "notebook");
gtk_widget_ref (notebook);
gtk_object_set_data_full (GTK_OBJECT (Peos), "notebook", notebook,
(GtkDestroyNotify) gtk_widget_unref);
set_selection(1); /* with current action selected */
gtk_widget_show (notebook);
gtk_container_add (GTK_CONTAINER (vbox), notebook);
redisplay_menu();
check_state();
}
void check_state(void)
{
char *state;
if ( table[cur_pid].page.curr != NULL && strcmp (table[cur_pid].page.curr->name , "action") == 0) {
state = xmlGetProp(table[cur_pid].page.curr, "state");
if ( strcmp(state, "NONE") == 0) {
set_sensitive_dep(TRUE, TRUE, FALSE, FALSE, NULL);
} else if ( strcmp(state, "BLOCKED") == 0) {
set_sensitive_dep(TRUE, TRUE, FALSE, FALSE, NULL);
} else if ( strcmp(state, "RUN") == 0) {
set_sensitive_dep(FALSE, TRUE, TRUE, TRUE, NULL);
} else if ( strcmp(state, "SUSPEND") == 0) {
set_sensitive_dep(TRUE, TRUE, FALSE, TRUE, NULL);
} else if ( strcmp(state, "DONE") == 0) {
set_sensitive_dep(TRUE, FALSE, FALSE, FALSE, NULL);
} else if ( strcmp(state, "READY") == 0) {
set_sensitive_dep(TRUE, TRUE, FALSE, FALSE, NULL);
} else if ( strcmp(state, "AVAILABLE") == 0) {
set_sensitive_dep(TRUE, TRUE, FALSE, FALSE, NULL);
} else if ( strcmp(state, "PENDING") == 0) {
set_sensitive_dep(TRUE, TRUE, FALSE, FALSE, NULL);
}
if (GTK_IS_WIDGET (table[cur_pid].page.Start)) gtk_widget_destroy (table[cur_pid].page.Start);
table[cur_pid].page.Start = start_label(state);
} else {
set_sensitive_dep(FALSE, FALSE, FALSE, FALSE, FALSE);
if (GTK_IS_WIDGET (table[cur_pid].page.Start)) gtk_widget_destroy (table[cur_pid].page.Start);
table[cur_pid].page.Start = start_label("Start");
}
gtk_widget_ref (table[cur_pid].page.Start);
gtk_object_set_data_full (GTK_OBJECT (Peos), "Start", table[cur_pid].page.Start,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table[cur_pid].page.Start);
gtk_fixed_put (GTK_FIXED (table[cur_pid].page.fixed), table[cur_pid].page.Start, 16, 8);
gtk_widget_set_uposition (table[cur_pid].page.Start, 16, 8);
gtk_widget_set_usize (table[cur_pid].page.Start, 55, 22);
gtk_signal_connect (GTK_OBJECT (table[cur_pid].page.Start), "clicked",
GTK_SIGNAL_FUNC (on_Start_clicked),
NULL);
set_sensitive();
}
/**
* Attack the monster at the given location with a single blow.
*/
static bool py_attack_real(int y, int x, bool *fear) {
/* Information about the target of the attack */
monster_type *m_ptr = cave_monster_at(cave, y, x);
monster_race *r_ptr = &r_info[m_ptr->r_idx];
char m_name[80];
bool stop = FALSE;
/* The weapon used */
object_type *o_ptr = &p_ptr->inventory[INVEN_WIELD];
/* Information about the attack */
int bonus = p_ptr->state.to_h + o_ptr->to_h;
int chance = p_ptr->state.skills[SKILL_TO_HIT_MELEE] + bonus * BTH_PLUS_ADJ;
bool do_quake = FALSE;
bool success = FALSE;
/* Default to punching for one damage */
const char *hit_verb = "punch";
int dmg = 1;
u32b msg_type = MSG_HIT;
/* Extract monster name (or "it") */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Auto-Recall if possible and visible */
if (m_ptr->ml) monster_race_track(m_ptr->r_idx);
/* Track a new monster */
if (m_ptr->ml) health_track(p_ptr, m_ptr);
/* Handle player fear (only for invisible monsters) */
if (check_state(p_ptr, OF_AFRAID, p_ptr->state.flags)) {
msgt(MSG_AFRAID, "You are too afraid to attack %s!", m_name);
return FALSE;
}
/* Disturb the monster */
mon_clear_timed(m_ptr, MON_TMD_SLEEP, MON_TMD_FLG_NOMESSAGE, FALSE);
/* See if the player hit */
success = test_hit(chance, r_ptr->ac, m_ptr->ml);
/* If a miss, skip this hit */
if (!success) {
msgt(MSG_MISS, "You miss %s.", m_name);
return FALSE;
}
/* Handle normal weapon */
if (o_ptr->kind) {
int i;
const struct slay *best_s_ptr = NULL;
hit_verb = "hit";
/* Get the best attack from all slays or
* brands on all non-launcher equipment */
for (i = INVEN_LEFT; i < INVEN_TOTAL; i++) {
struct object *obj = &p_ptr->inventory[i];
if (obj->kind)
improve_attack_modifier(obj, m_ptr, &best_s_ptr, TRUE, FALSE);
}
improve_attack_modifier(o_ptr, m_ptr, &best_s_ptr, TRUE, FALSE);
if (best_s_ptr != NULL)
hit_verb = best_s_ptr->melee_verb;
dmg = damroll(o_ptr->dd, o_ptr->ds);
dmg *= (best_s_ptr == NULL) ? 1 : best_s_ptr->mult;
dmg += o_ptr->to_d;
dmg = critical_norm(o_ptr->weight, o_ptr->to_h, dmg, &msg_type);
/* Learn by use for the weapon */
object_notice_attack_plusses(o_ptr);
if (check_state(p_ptr, OF_IMPACT, p_ptr->state.flags) && dmg > 50) {
do_quake = TRUE;
wieldeds_notice_flag(p_ptr, OF_IMPACT);
}
}
/* Learn by use for other equipped items */
wieldeds_notice_on_attack();
/* Apply the player damage bonuses */
dmg += p_ptr->state.to_d;
/* No negative damage */
if (dmg <= 0) dmg = 0;
/* Tell the player what happened */
if (dmg <= 0)
msgt(MSG_MISS, "You fail to harm %s.", m_name);
else if (msg_type == MSG_HIT)
msgt(MSG_HIT, "You %s %s.", hit_verb, m_name);
else if (msg_type == MSG_HIT_GOOD)
msgt(MSG_HIT_GOOD, "You %s %s. %s", hit_verb, m_name, "It was a good hit!");
else if (msg_type == MSG_HIT_GREAT)
msgt(MSG_HIT_GREAT, "You %s %s. %s", hit_verb, m_name, "It was a great hit!");
else if (msg_type == MSG_HIT_SUPERB)
msgt(MSG_HIT_SUPERB, "You %s %s. %s", hit_verb, m_name, "It was a superb hit!");
else if (msg_type == MSG_HIT_HI_GREAT)
msgt(MSG_HIT_HI_GREAT, "You %s %s. %s", hit_verb, m_name, "It was a *GREAT* hit!");
else if (msg_type == MSG_HIT_HI_SUPERB)
msgt(MSG_HIT_HI_SUPERB, "You %s %s. %s", hit_verb, m_name, "It was a *SUPERB* hit!");
/* Complex message */
if (p_ptr->wizard)
msg("You do %d (out of %d) damage.", dmg, m_ptr->hp);
/* Confusion attack */
if (p_ptr->confusing) {
p_ptr->confusing = FALSE;
msg("Your hands stop glowing.");
mon_inc_timed(m_ptr, MON_TMD_CONF,
(10 + randint0(p_ptr->lev) / 10), MON_TMD_FLG_NOTIFY, FALSE);
}
/* Damage, check for fear and death */
stop = mon_take_hit(m_ptr, dmg, fear, NULL);
if (stop)
(*fear) = FALSE;
/* Apply earthquake brand */
if (do_quake) {
earthquake(p_ptr->py, p_ptr->px, 10);
if (cave->m_idx[y][x] == 0) stop = TRUE;
}
return stop;
}
/*
* Do an effect, given an object.
* Boost is the extent to which skill surpasses difficulty, used as % boost. It
* ranges from 0 to 138.
*/
bool effect_do(effect_type effect, bool *ident, bool aware, int dir, int beam,
int boost)
{
int py = p_ptr->py;
int px = p_ptr->px;
int dam, chance, dur;
if (effect < 1 || effect > EF_MAX)
{
msg("Bad effect passed to do_effect(). Please report this bug.");
return FALSE;
}
switch (effect)
{
case EF_POISON:
{
player_inc_timed(p_ptr, TMD_POISONED, damroll(2, 7) + 10, TRUE, TRUE);
*ident = TRUE;
return TRUE;
}
case EF_BLIND:
{
player_inc_timed(p_ptr, TMD_BLIND, damroll(4, 25) + 75, TRUE, TRUE);
*ident = TRUE;
return TRUE;
}
case EF_SCARE:
{
player_inc_timed(p_ptr, TMD_AFRAID, randint0(10) + 10, TRUE, TRUE);
*ident = TRUE;
return TRUE;
}
case EF_CONFUSE:
{
player_inc_timed(p_ptr, TMD_CONFUSED, damroll(4, 5) + 10, TRUE, TRUE);
*ident = TRUE;
return TRUE;
}
case EF_HALLUC:
{
player_inc_timed(p_ptr, TMD_IMAGE, randint0(250) + 250, TRUE, TRUE);
*ident = TRUE;
return TRUE;
}
case EF_PARALYZE:
{
player_inc_timed(p_ptr, TMD_PARALYZED, randint0(5) + 5, TRUE, TRUE);
*ident = TRUE;
return TRUE;
}
case EF_SLOW:
{
if (player_inc_timed(p_ptr, TMD_SLOW, randint1(25) + 15, TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_CURE_POISON:
{
if (player_clear_timed(p_ptr, TMD_POISONED, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_CURE_BLINDNESS:
{
if (player_clear_timed(p_ptr, TMD_BLIND, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_CURE_PARANOIA:
{
if (player_clear_timed(p_ptr, TMD_AFRAID, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_CURE_CONFUSION:
{
if (player_clear_timed(p_ptr, TMD_CONFUSED, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_CURE_MIND:
{
if (player_clear_timed(p_ptr, TMD_CONFUSED, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_AFRAID, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_IMAGE, TRUE)) *ident = TRUE;
if (!of_has(p_ptr->state.flags, OF_RES_CONFU) &&
player_inc_timed(p_ptr, TMD_OPP_CONF, damroll(4, 10), TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_CURE_BODY:
{
if (player_clear_timed(p_ptr, TMD_STUN, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CUT, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_POISONED, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_BLIND, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_CURE_LIGHT:
{
if (hp_player(20)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_BLIND, TRUE)) *ident = TRUE;
if (player_dec_timed(p_ptr, TMD_CUT, 20, TRUE)) *ident = TRUE;
if (player_dec_timed(p_ptr, TMD_CONFUSED, 20, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_CURE_SERIOUS:
{
if (hp_player(40)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CUT, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_BLIND, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CONFUSED, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_CURE_CRITICAL:
{
if (hp_player(60)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_BLIND, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CONFUSED, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_POISONED, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_STUN, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CUT, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_AMNESIA, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_CURE_FULL:
{
int amt = (p_ptr->mhp * 35) / 100;
if (amt < 300) amt = 300;
if (hp_player(amt)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_BLIND, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CONFUSED, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_POISONED, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_STUN, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CUT, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_AMNESIA, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_CURE_FULL2:
{
if (hp_player(1200)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_BLIND, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CONFUSED, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_POISONED, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_STUN, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CUT, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_AMNESIA, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_CURE_TEMP:
{
if (player_clear_timed(p_ptr, TMD_BLIND, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_POISONED, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CONFUSED, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_STUN, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CUT, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_HEAL1:
{
if (hp_player(500)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CUT, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_HEAL2:
{
if (hp_player(1000)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CUT, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_HEAL3:
{
if (hp_player(500)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_STUN, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CUT, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_GAIN_EXP:
{
if (p_ptr->exp < PY_MAX_EXP)
{
msg("You feel more experienced.");
player_exp_gain(p_ptr, 100000L);
*ident = TRUE;
}
return TRUE;
}
case EF_LOSE_EXP:
{
if (!check_state(p_ptr, OF_HOLD_LIFE, p_ptr->state.flags) && (p_ptr->exp > 0))
{
msg("You feel your memories fade.");
player_exp_lose(p_ptr, p_ptr->exp / 4, FALSE);
*ident = TRUE;
}
*ident = TRUE;
wieldeds_notice_flag(p_ptr, OF_HOLD_LIFE);
return TRUE;
}
case EF_RESTORE_EXP:
{
if (restore_level()) *ident = TRUE;
return TRUE;
}
case EF_RESTORE_MANA:
{
if (p_ptr->csp < p_ptr->msp)
{
p_ptr->csp = p_ptr->msp;
p_ptr->csp_frac = 0;
msg("Your feel your head clear.");
p_ptr->redraw |= (PR_MANA);
*ident = TRUE;
}
return TRUE;
}
case EF_GAIN_STR:
case EF_GAIN_INT:
case EF_GAIN_WIS:
case EF_GAIN_DEX:
case EF_GAIN_CON:
case EF_GAIN_CHR:
{
int stat = effect - EF_GAIN_STR;
if (do_inc_stat(stat)) *ident = TRUE;
return TRUE;
}
case EF_GAIN_ALL:
{
if (do_inc_stat(A_STR)) *ident = TRUE;
if (do_inc_stat(A_INT)) *ident = TRUE;
if (do_inc_stat(A_WIS)) *ident = TRUE;
if (do_inc_stat(A_DEX)) *ident = TRUE;
if (do_inc_stat(A_CON)) *ident = TRUE;
if (do_inc_stat(A_CHR)) *ident = TRUE;
return TRUE;
}
case EF_BRAWN:
{
/* Pick a random stat to decrease other than strength */
int stat = randint0(A_MAX-1) + 1;
if (do_dec_stat(stat, TRUE))
{
do_inc_stat(A_STR);
*ident = TRUE;
}
return TRUE;
}
case EF_INTELLECT:
{
/* Pick a random stat to decrease other than intelligence */
int stat = randint0(A_MAX-1);
if (stat >= A_INT) stat++;
if (do_dec_stat(stat, TRUE))
{
do_inc_stat(A_INT);
*ident = TRUE;
}
return TRUE;
}
case EF_CONTEMPLATION:
{
/* Pick a random stat to decrease other than wisdom */
int stat = randint0(A_MAX-1);
if (stat >= A_WIS) stat++;
if (do_dec_stat(stat, TRUE))
{
do_inc_stat(A_WIS);
*ident = TRUE;
}
return TRUE;
}
case EF_TOUGHNESS:
{
/* Pick a random stat to decrease other than constitution */
int stat = randint0(A_MAX-1);
if (stat >= A_CON) stat++;
if (do_dec_stat(stat, TRUE))
{
do_inc_stat(A_CON);
*ident = TRUE;
}
return TRUE;
}
case EF_NIMBLENESS:
{
/* Pick a random stat to decrease other than dexterity */
int stat = randint0(A_MAX-1);
if (stat >= A_DEX) stat++;
if (do_dec_stat(stat, TRUE))
{
do_inc_stat(A_DEX);
*ident = TRUE;
}
return TRUE;
}
case EF_PLEASING:
{
/* Pick a random stat to decrease other than charisma */
int stat = randint0(A_MAX-1);
if (do_dec_stat(stat, TRUE))
{
do_inc_stat(A_CHR);
*ident = TRUE;
}
return TRUE;
}
case EF_LOSE_STR:
case EF_LOSE_INT:
case EF_LOSE_WIS:
case EF_LOSE_DEX:
case EF_LOSE_CON:
case EF_LOSE_CHR:
{
int stat = effect - EF_LOSE_STR;
take_hit(p_ptr, damroll(5, 5), "stat drain");
(void)do_dec_stat(stat, FALSE);
*ident = TRUE;
return TRUE;
}
case EF_LOSE_CON2:
{
take_hit(p_ptr, damroll(10, 10), "poisonous food");
(void)do_dec_stat(A_CON, FALSE);
*ident = TRUE;
return TRUE;
}
case EF_RESTORE_STR:
case EF_RESTORE_INT:
case EF_RESTORE_WIS:
case EF_RESTORE_DEX:
case EF_RESTORE_CON:
case EF_RESTORE_CHR:
{
int stat = effect - EF_RESTORE_STR;
if (do_res_stat(stat)) *ident = TRUE;
return TRUE;
}
case EF_CURE_NONORLYBIG:
{
msg("You feel life flow through your body!");
restore_level();
(void)player_clear_timed(p_ptr, TMD_POISONED, TRUE);
(void)player_clear_timed(p_ptr, TMD_BLIND, TRUE);
(void)player_clear_timed(p_ptr, TMD_CONFUSED, TRUE);
(void)player_clear_timed(p_ptr, TMD_IMAGE, TRUE);
(void)player_clear_timed(p_ptr, TMD_STUN, TRUE);
(void)player_clear_timed(p_ptr, TMD_CUT, TRUE);
(void)player_clear_timed(p_ptr, TMD_AMNESIA, TRUE);
if (do_res_stat(A_STR)) *ident = TRUE;
if (do_res_stat(A_INT)) *ident = TRUE;
if (do_res_stat(A_WIS)) *ident = TRUE;
if (do_res_stat(A_DEX)) *ident = TRUE;
if (do_res_stat(A_CON)) *ident = TRUE;
if (do_res_stat(A_CHR)) *ident = TRUE;
/* Recalculate max. hitpoints */
update_stuff(p_ptr);
hp_player(5000);
*ident = TRUE;
return TRUE;
}
case EF_RESTORE_ALL:
{
/* Life, above, also gives these effects */
if (do_res_stat(A_STR)) *ident = TRUE;
if (do_res_stat(A_INT)) *ident = TRUE;
if (do_res_stat(A_WIS)) *ident = TRUE;
if (do_res_stat(A_DEX)) *ident = TRUE;
if (do_res_stat(A_CON)) *ident = TRUE;
if (do_res_stat(A_CHR)) *ident = TRUE;
return TRUE;
}
case EF_RESTORE_ST_LEV:
{
if (restore_level()) *ident = TRUE;
if (do_res_stat(A_STR)) *ident = TRUE;
if (do_res_stat(A_INT)) *ident = TRUE;
if (do_res_stat(A_WIS)) *ident = TRUE;
if (do_res_stat(A_DEX)) *ident = TRUE;
if (do_res_stat(A_CON)) *ident = TRUE;
if (do_res_stat(A_CHR)) *ident = TRUE;
return TRUE;
}
case EF_TMD_INFRA:
{
if (player_inc_timed(p_ptr, TMD_SINFRA, 100 + damroll(4, 25), TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_TMD_SINVIS:
{
if (player_clear_timed(p_ptr, TMD_BLIND, TRUE)) *ident = TRUE;
if (player_inc_timed(p_ptr, TMD_SINVIS, 12 + damroll(2, 6), TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_TMD_ESP:
{
if (player_clear_timed(p_ptr, TMD_BLIND, TRUE)) *ident = TRUE;
if (player_inc_timed(p_ptr, TMD_TELEPATHY, 12 + damroll(6, 6), TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_ENLIGHTENMENT:
{
msg("An image of your surroundings forms in your mind...");
wiz_light();
*ident = TRUE;
return TRUE;
}
case EF_ENLIGHTENMENT2:
{
msg("You begin to feel more enlightened...");
message_flush();
wiz_light();
(void)do_inc_stat(A_INT);
(void)do_inc_stat(A_WIS);
(void)detect_traps(TRUE);
(void)detect_doorstairs(TRUE);
(void)detect_treasure(TRUE, TRUE);
identify_pack();
*ident = TRUE;
return TRUE;
}
case EF_HERO:
{
dur = randint1(25) + 25;
if (hp_player(10)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_AFRAID, TRUE)) *ident = TRUE;
if (player_inc_timed(p_ptr, TMD_BOLD, dur, TRUE, TRUE)) *ident = TRUE;
if (player_inc_timed(p_ptr, TMD_HERO, dur, TRUE, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_SHERO:
{
dur = randint1(25) + 25;
if (hp_player(30)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_AFRAID, TRUE)) *ident = TRUE;
if (player_inc_timed(p_ptr, TMD_BOLD, dur, TRUE, TRUE)) *ident = TRUE;
if (player_inc_timed(p_ptr, TMD_SHERO, dur, TRUE, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_RESIST_ACID:
{
if (player_inc_timed(p_ptr, TMD_OPP_ACID, randint1(10) + 10, TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_RESIST_ELEC:
{
if (player_inc_timed(p_ptr, TMD_OPP_ELEC, randint1(10) + 10, TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_RESIST_FIRE:
{
if (player_inc_timed(p_ptr, TMD_OPP_FIRE, randint1(10) + 10, TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_RESIST_COLD:
{
if (player_inc_timed(p_ptr, TMD_OPP_COLD, randint1(10) + 10, TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_RESIST_POIS:
{
if (player_inc_timed(p_ptr, TMD_OPP_POIS, randint1(10) + 10, TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_RESIST_ALL:
{
if (player_inc_timed(p_ptr, TMD_OPP_ACID, randint1(20) + 20, TRUE, TRUE))
*ident = TRUE;
if (player_inc_timed(p_ptr, TMD_OPP_ELEC, randint1(20) + 20, TRUE, TRUE))
*ident = TRUE;
if (player_inc_timed(p_ptr, TMD_OPP_FIRE, randint1(20) + 20, TRUE, TRUE))
*ident = TRUE;
if (player_inc_timed(p_ptr, TMD_OPP_COLD, randint1(20) + 20, TRUE, TRUE))
*ident = TRUE;
if (player_inc_timed(p_ptr, TMD_OPP_POIS, randint1(20) + 20, TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_DETECT_TREASURE:
{
if (detect_treasure(aware, FALSE)) *ident = TRUE;
return TRUE;
}
case EF_DETECT_TRAP:
{
if (detect_traps(aware)) *ident = TRUE;
return TRUE;
}
case EF_DETECT_DOORSTAIR:
{
if (detect_doorstairs(aware)) *ident = TRUE;
return TRUE;
}
case EF_DETECT_INVIS:
{
if (detect_monsters_invis(aware)) *ident = TRUE;
return TRUE;
}
case EF_DETECT_EVIL:
{
if (detect_monsters_evil(aware)) *ident = TRUE;
return TRUE;
}
case EF_DETECT_ALL:
{
if (detect_all(aware)) *ident = TRUE;
return TRUE;
}
case EF_ENCHANT_TOHIT:
{
*ident = TRUE;
return enchant_spell(1, 0, 0);
}
case EF_ENCHANT_TODAM:
{
*ident = TRUE;
return enchant_spell(0, 1, 0);
}
case EF_ENCHANT_WEAPON:
{
*ident = TRUE;
return enchant_spell(randint1(3), randint1(3), 0);
}
case EF_ENCHANT_ARMOR:
{
*ident = TRUE;
return enchant_spell(0, 0, 1);
}
case EF_ENCHANT_ARMOR2:
{
*ident = TRUE;
return enchant_spell(0, 0, randint1(3) + 2);
}
case EF_RESTORE_ITEM:
{
*ident = TRUE;
return restore_item();
}
case EF_IDENTIFY:
{
*ident = TRUE;
if (!ident_spell()) return FALSE;
return TRUE;
}
case EF_REMOVE_CURSE:
{
if (remove_curse())
{
if (!p_ptr->timed[TMD_BLIND])
msg("The air around your body glows blue for a moment...");
else
msg("You feel as if someone is watching over you.");
*ident = TRUE;
}
return TRUE;
}
case EF_REMOVE_CURSE2:
{
remove_all_curse();
*ident = TRUE;
return TRUE;
}
case EF_LIGHT:
{
if (light_area(damroll(2, 8), 2)) *ident = TRUE;
return TRUE;
}
case EF_SUMMON_MON:
{
int i;
sound(MSG_SUM_MONSTER);
for (i = 0; i < randint1(3); i++)
{
if (summon_specific(py, px, p_ptr->depth, 0, 1))
*ident = TRUE;
}
return TRUE;
}
case EF_SUMMON_UNDEAD:
{
int i;
sound(MSG_SUM_UNDEAD);
for (i = 0; i < randint1(3); i++)
{
if (summon_specific(py, px, p_ptr->depth,
S_UNDEAD, 1))
*ident = TRUE;
}
return TRUE;
}
case EF_TELE_PHASE:
{
teleport_player(10);
*ident = TRUE;
return TRUE;
}
case EF_TELE_LONG:
{
teleport_player(100);
*ident = TRUE;
return TRUE;
}
case EF_TELE_LEVEL:
{
(void)teleport_player_level();
*ident = TRUE;
return TRUE;
}
case EF_CONFUSING:
{
if (p_ptr->confusing == 0)
{
msg("Your hands begin to glow.");
p_ptr->confusing = TRUE;
*ident = TRUE;
}
return TRUE;
}
case EF_MAPPING:
{
map_area();
*ident = TRUE;
return TRUE;
}
case EF_RUNE:
{
warding_glyph();
*ident = TRUE;
return TRUE;
}
case EF_ACQUIRE:
{
acquirement(py, px, p_ptr->depth, 1, TRUE);
*ident = TRUE;
return TRUE;
}
case EF_ACQUIRE2:
{
acquirement(py, px, p_ptr->depth, randint1(2) + 1,
TRUE);
*ident = TRUE;
return TRUE;
}
case EF_ANNOY_MON:
{
msg("There is a high pitched humming noise.");
aggravate_monsters(0);
*ident = TRUE;
return TRUE;
}
case EF_CREATE_TRAP:
{
/* Hack -- no traps in the town */
if (p_ptr->depth == 0)
return TRUE;
trap_creation();
msg("You hear a low-pitched whistling sound.");
*ident = TRUE;
return TRUE;
}
case EF_DESTROY_TDOORS:
{
if (destroy_doors_touch()) *ident = TRUE;
return TRUE;
}
case EF_RECHARGE:
{
*ident = TRUE;
if (!recharge(60)) return FALSE;
return TRUE;
}
case EF_BANISHMENT:
{
*ident = TRUE;
if (!banishment()) return FALSE;
return TRUE;
}
case EF_DARKNESS:
{
if (!check_state(p_ptr, OF_RES_DARK, p_ptr->state.flags))
(void)player_inc_timed(p_ptr, TMD_BLIND, 3 + randint1(5), TRUE, TRUE);
unlight_area(10, 3);
wieldeds_notice_flag(p_ptr, OF_RES_DARK);
*ident = TRUE;
return TRUE;
}
case EF_PROTEVIL:
{
if (player_inc_timed(p_ptr, TMD_PROTEVIL, randint1(25) + 3 *
p_ptr->lev, TRUE, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_SATISFY:
{
if (player_set_food(p_ptr, PY_FOOD_MAX - 1)) *ident = TRUE;
return TRUE;
}
case EF_CURSE_WEAPON:
{
if (curse_weapon()) *ident = TRUE;
return TRUE;
}
case EF_CURSE_ARMOR:
{
if (curse_armor()) *ident = TRUE;
return TRUE;
}
case EF_BLESSING:
{
if (player_inc_timed(p_ptr, TMD_BLESSED, randint1(12) + 6, TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_BLESSING2:
{
if (player_inc_timed(p_ptr, TMD_BLESSED, randint1(24) + 12, TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_BLESSING3:
{
if (player_inc_timed(p_ptr, TMD_BLESSED, randint1(48) + 24, TRUE, TRUE))
*ident = TRUE;
return TRUE;
}
case EF_RECALL:
{
set_recall();
*ident = TRUE;
return TRUE;
}
case EF_DEEP_DESCENT:
{
int i, target_depth = p_ptr->depth;
/* Calculate target depth */
for (i = 5; i > 0; i--) {
if (is_quest(target_depth)) break;
if (target_depth >= MAX_DEPTH - 1) break;
target_depth++;
}
if (target_depth > p_ptr->depth) {
msgt(MSG_TPLEVEL, "The air around you starts to swirl...");
p_ptr->deep_descent = 3 + randint1(4);
*ident = TRUE;
return TRUE;
} else {
msgt(MSG_TPLEVEL, "You sense a malevolent presence blocking passage to the levels below.");
*ident = TRUE;
return FALSE;
}
}
case EF_LOSHASTE:
{
if (speed_monsters()) *ident = TRUE;
return TRUE;
}
case EF_LOSSLEEP:
{
if (sleep_monsters(aware)) *ident = TRUE;
return TRUE;
}
case EF_LOSSLOW:
{
if (slow_monsters()) *ident = TRUE;
return TRUE;
}
case EF_LOSCONF:
{
if (confuse_monsters(aware)) *ident = TRUE;
return TRUE;
}
case EF_LOSKILL:
{
(void)mass_banishment();
*ident = TRUE;
return TRUE;
}
case EF_EARTHQUAKES:
{
earthquake(py, px, 10);
*ident = TRUE;
return TRUE;
}
case EF_DESTRUCTION2:
{
destroy_area(py, px, 15, TRUE);
*ident = TRUE;
return TRUE;
}
case EF_ILLUMINATION:
{
if (light_area(damroll(2, 15), 3)) *ident = TRUE;
return TRUE;
}
case EF_CLAIRVOYANCE:
{
*ident = TRUE;
wiz_light();
(void)detect_traps(TRUE);
(void)detect_doorstairs(TRUE);
return TRUE;
}
case EF_PROBING:
{
*ident = probing();
return TRUE;
}
case EF_STONE_TO_MUD:
{
if (wall_to_mud(dir)) *ident = TRUE;
return TRUE;
}
case EF_CONFUSE2:
{
*ident = TRUE;
confuse_monster(dir, 20, aware);
return TRUE;
}
case EF_BIZARRE:
{
*ident = TRUE;
ring_of_power(dir);
return TRUE;
}
case EF_STAR_BALL:
{
int i;
*ident = TRUE;
for (i = 0; i < 8; i++) fire_ball(GF_ELEC, ddd[i],
(150 * (100 + boost) / 100), 3);
return TRUE;
}
case EF_RAGE_BLESS_RESIST:
{
dur = randint1(50) + 50;
*ident = TRUE;
(void)hp_player(30);
(void)player_clear_timed(p_ptr, TMD_AFRAID, TRUE);
(void)player_inc_timed(p_ptr, TMD_BOLD, dur, TRUE, TRUE);
(void)player_inc_timed(p_ptr, TMD_SHERO, dur, TRUE, TRUE);
(void)player_inc_timed(p_ptr, TMD_BLESSED, randint1(50) + 50, TRUE, TRUE);
(void)player_inc_timed(p_ptr, TMD_OPP_ACID, randint1(50) + 50, TRUE, TRUE);
(void)player_inc_timed(p_ptr, TMD_OPP_ELEC, randint1(50) + 50, TRUE, TRUE);
(void)player_inc_timed(p_ptr, TMD_OPP_FIRE, randint1(50) + 50, TRUE, TRUE);
(void)player_inc_timed(p_ptr, TMD_OPP_COLD, randint1(50) + 50, TRUE, TRUE);
(void)player_inc_timed(p_ptr, TMD_OPP_POIS, randint1(50) + 50, TRUE, TRUE);
return TRUE;
}
case EF_SLEEPII:
{
*ident = TRUE;
sleep_monsters_touch(aware);
return TRUE;
}
case EF_RESTORE_LIFE:
{
*ident = TRUE;
restore_level();
return TRUE;
}
case EF_MISSILE:
{
*ident = TRUE;
dam = damroll(3, 4) * (100 + boost) / 100;
fire_bolt_or_beam(beam, GF_MISSILE, dir, dam);
return TRUE;
}
case EF_DISPEL_EVIL:
{
*ident = TRUE;
dam = p_ptr->lev * 5 * (100 + boost) / 100;
dispel_evil(dam);
return TRUE;
}
case EF_DISPEL_EVIL60:
{
dam = 60 * (100 + boost) / 100;
if (dispel_evil(dam)) *ident = TRUE;
return TRUE;
}
case EF_DISPEL_UNDEAD:
{
dam = 60 * (100 + boost) / 100;
if (dispel_undead(dam)) *ident = TRUE;
return TRUE;
}
case EF_DISPEL_ALL:
{
dam = 120 * (100 + boost) / 100;
if (dispel_monsters(dam)) *ident = TRUE;
return TRUE;
}
case EF_HASTE:
{
if (!p_ptr->timed[TMD_FAST])
{
if (player_set_timed(p_ptr, TMD_FAST, damroll(2, 10) + 20, TRUE)) *ident = TRUE;
}
else
{
(void)player_inc_timed(p_ptr, TMD_FAST, 5, TRUE, TRUE);
}
return TRUE;
}
case EF_HASTE1:
{
if (!p_ptr->timed[TMD_FAST])
{
if (player_set_timed(p_ptr, TMD_FAST, randint1(20) + 20, TRUE)) *ident = TRUE;
}
else
{
(void)player_inc_timed(p_ptr, TMD_FAST, 5, TRUE, TRUE);
}
return TRUE;
}
case EF_HASTE2:
{
if (!p_ptr->timed[TMD_FAST])
{
if (player_set_timed(p_ptr, TMD_FAST, randint1(75) + 75, TRUE)) *ident = TRUE;
}
else
{
(void)player_inc_timed(p_ptr, TMD_FAST, 5, TRUE, TRUE);
}
return TRUE;
}
case EF_FIRE_BOLT:
{
*ident = TRUE;
dam = damroll(9, 8) * (100 + boost) / 100;
fire_bolt(GF_FIRE, dir, dam);
return TRUE;
}
case EF_FIRE_BOLT2:
{
dam = damroll(12, 8) * (100 + boost) / 100;
fire_bolt_or_beam(beam, GF_FIRE, dir, dam);
*ident = TRUE;
return TRUE;
}
case EF_FIRE_BOLT3:
{
dam = damroll(16, 8) * (100 + boost) / 100;
fire_bolt_or_beam(beam, GF_FIRE, dir, dam);
*ident = TRUE;
return TRUE;
}
case EF_FIRE_BOLT72:
{
dam = 72 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_FIRE, dir, dam, 2);
return TRUE;
}
case EF_FIRE_BALL:
{
dam = 144 * (100 + boost) / 100;
fire_ball(GF_FIRE, dir, dam, 2);
*ident = TRUE;
return TRUE;
}
case EF_FIRE_BALL2:
{
dam = 120 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_FIRE, dir, dam, 3);
return TRUE;
}
case EF_FIRE_BALL200:
{
dam = 200 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_FIRE, dir, dam, 3);
return TRUE;
}
case EF_COLD_BOLT:
{
dam = damroll(6, 8) * (100 + boost) / 100;
*ident = TRUE;
fire_bolt_or_beam(beam, GF_COLD, dir, dam);
return TRUE;
}
case EF_COLD_BOLT2:
{
dam = damroll(12, 8) * (100 + boost) / 100;
*ident = TRUE;
fire_bolt(GF_COLD, dir, dam);
return TRUE;
}
case EF_COLD_BALL2:
{
dam = 200 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_COLD, dir, dam, 3);
return TRUE;
}
case EF_COLD_BALL50:
{
dam = 50 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_COLD, dir, dam, 2);
return TRUE;
}
case EF_COLD_BALL100:
{
dam = 100 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_COLD, dir, dam, 2);
return TRUE;
}
case EF_COLD_BALL160:
{
dam = 160 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_COLD, dir, dam, 3);
return TRUE;
}
case EF_ACID_BOLT:
{
dam = damroll(5, 8) * (100 + boost) / 100;
*ident = TRUE;
fire_bolt(GF_ACID, dir, dam);
return TRUE;
}
case EF_ACID_BOLT2:
{
dam = damroll(10, 8) * (100 + boost) / 100;
fire_bolt_or_beam(beam, GF_ACID, dir, dam);
*ident = TRUE;
return TRUE;
}
case EF_ACID_BOLT3:
{
dam = damroll(12, 8) * (100 + boost) / 100;
fire_bolt_or_beam(beam, GF_ACID, dir, dam);
*ident = TRUE;
return TRUE;
}
case EF_ACID_BALL:
{
dam = 120 * (100 + boost) / 100;
fire_ball(GF_ACID, dir, dam, 2);
*ident = TRUE;
return TRUE;
}
case EF_ELEC_BOLT:
{
dam = damroll(6, 6) * (100 + boost) / 100;
*ident = TRUE;
fire_beam(GF_ELEC, dir, dam);
return TRUE;
}
case EF_ELEC_BALL:
{
dam = 64 * (100 + boost) / 100;
fire_ball(GF_ELEC, dir, dam, 2);
*ident = TRUE;
return TRUE;
}
case EF_ELEC_BALL2:
{
dam = 250 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_ELEC, dir, dam, 3);
return TRUE;
}
case EF_ARROW:
{
dam = 150 * (100 + boost) / 100;
*ident = TRUE;
fire_bolt(GF_ARROW, dir, dam);
return TRUE;
}
case EF_REM_FEAR_POIS:
{
*ident = TRUE;
(void)player_clear_timed(p_ptr, TMD_AFRAID, TRUE);
(void)player_clear_timed(p_ptr, TMD_POISONED, TRUE);
return TRUE;
}
case EF_STINKING_CLOUD:
{
dam = 12 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_POIS, dir, dam, 3);
return TRUE;
}
case EF_DRAIN_LIFE1:
{
dam = 90 * (100 + boost) / 100;
if (drain_life(dir, dam)) *ident = TRUE;
return TRUE;
}
case EF_DRAIN_LIFE2:
{
dam = 120 * (100 + boost) / 100;
if (drain_life(dir, dam)) *ident = TRUE;
return TRUE;
}
case EF_DRAIN_LIFE3:
{
dam = 150 * (100 + boost) / 100;
if (drain_life(dir, dam)) *ident = TRUE;
return TRUE;
}
case EF_DRAIN_LIFE4:
{
dam = 250 * (100 + boost) / 100;
if (drain_life(dir, dam)) *ident = TRUE;
return TRUE;
}
case EF_FIREBRAND:
{
*ident = TRUE;
if (!brand_bolts()) return FALSE;
return TRUE;
}
case EF_MANA_BOLT:
{
dam = damroll(12, 8) * (100 + boost) / 100;
fire_bolt(GF_MANA, dir, dam);
*ident = TRUE;
return TRUE;
}
case EF_MON_HEAL:
{
if (heal_monster(dir)) *ident = TRUE;
return TRUE;
}
case EF_MON_HASTE:
{
if (speed_monster(dir)) *ident = TRUE;
return TRUE;
}
case EF_MON_SLOW:
{
if (slow_monster(dir)) *ident = TRUE;
return TRUE;
}
case EF_MON_CONFUSE:
{
if (confuse_monster(dir, 10, aware)) *ident = TRUE;
return TRUE;
}
case EF_MON_SLEEP:
{
if (sleep_monster(dir, aware)) *ident = TRUE;
return TRUE;
}
case EF_MON_CLONE:
{
if (clone_monster(dir)) *ident = TRUE;
return TRUE;
}
case EF_MON_SCARE:
{
if (fear_monster(dir, 10, aware)) *ident = TRUE;
return TRUE;
}
case EF_LIGHT_LINE:
{
msg("A line of shimmering blue light appears.");
light_line(dir);
*ident = TRUE;
return TRUE;
}
case EF_TELE_OTHER:
{
if (teleport_monster(dir)) *ident = TRUE;
return TRUE;
}
case EF_DISARMING:
{
if (disarm_trap(dir)) *ident = TRUE;
return TRUE;
}
case EF_TDOOR_DEST:
{
if (destroy_door(dir)) *ident = TRUE;
return TRUE;
}
case EF_POLYMORPH:
{
if (poly_monster(dir)) *ident = TRUE;
return TRUE;
}
case EF_STARLIGHT:
{
int i;
if (!p_ptr->timed[TMD_BLIND])
msg("Light shoots in all directions!");
for (i = 0; i < 8; i++) light_line(ddd[i]);
*ident = TRUE;
return TRUE;
}
case EF_STARLIGHT2:
{
int k;
for (k = 0; k < 8; k++) strong_light_line(ddd[k]);
*ident = TRUE;
return TRUE;
}
case EF_BERSERKER:
{
dur = randint1(50) + 50;
if (player_inc_timed(p_ptr, TMD_BOLD, dur, TRUE, TRUE)) *ident = TRUE;
if (player_inc_timed(p_ptr, TMD_SHERO, dur, TRUE, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_SUN_HERO:
{
(void)light_area(damroll(20, 10), 8);
dur = randint1(25) + 25;
if (player_inc_timed(p_ptr, TMD_BOLD, dur, TRUE, TRUE)) *ident = TRUE;
if (player_inc_timed(p_ptr, TMD_SHERO, dur, TRUE, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_WONDER:
{
if (effect_wonder(dir, randint1(100) + p_ptr->lev / 5,
beam)) *ident = TRUE;
return TRUE;
}
case EF_WAND_BREATH:
{
/* table of random ball effects and their damages */
const int breath_types[] = {
GF_ACID, 200,
GF_ELEC, 160,
GF_FIRE, 200,
GF_COLD, 160,
GF_POIS, 120
};
/* pick a random (type, damage) tuple in the table */
int which = 2 * randint0(sizeof(breath_types) / (2 * sizeof(int)));
fire_ball(breath_types[which], dir, breath_types[which + 1], 3);
*ident = TRUE;
return TRUE;
}
case EF_STAFF_MAGI:
{
if (do_res_stat(A_INT)) *ident = TRUE;
if (p_ptr->csp < p_ptr->msp)
{
p_ptr->csp = p_ptr->msp;
p_ptr->csp_frac = 0;
*ident = TRUE;
msg("Your feel your head clear.");
p_ptr->redraw |= (PR_MANA);
}
return TRUE;
}
case EF_STAFF_HOLY:
{
dam = 120 * (100 + boost) / 100;
if (dispel_evil(dam)) *ident = TRUE;
if (player_inc_timed(p_ptr, TMD_PROTEVIL, randint1(25) + 3 *
p_ptr->lev, TRUE, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_POISONED, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_AFRAID, TRUE)) *ident = TRUE;
if (hp_player(50)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_STUN, TRUE)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_CUT, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_DRINK_BREATH:
{
const int breath_types[] =
{
GF_FIRE, 80,
GF_COLD, 80,
};
int which = 2 * randint0(N_ELEMENTS(breath_types) / 2);
fire_ball(breath_types[which], dir, breath_types[which + 1], 2);
*ident = TRUE;
return TRUE;
}
case EF_DRINK_GOOD:
{
msg("You feel less thirsty.");
*ident = TRUE;
return TRUE;
}
case EF_DRINK_DEATH:
{
msg("A feeling of Death flows through your body.");
take_hit(p_ptr, 5000, "a potion of Death");
*ident = TRUE;
return TRUE;
}
case EF_DRINK_RUIN:
{
msg("Your nerves and muscles feel weak and lifeless!");
take_hit(p_ptr, damroll(10, 10), "a potion of Ruination");
player_stat_dec(p_ptr, A_DEX, TRUE);
player_stat_dec(p_ptr, A_WIS, TRUE);
player_stat_dec(p_ptr, A_CON, TRUE);
player_stat_dec(p_ptr, A_STR, TRUE);
player_stat_dec(p_ptr, A_CHR, TRUE);
player_stat_dec(p_ptr, A_INT, TRUE);
*ident = TRUE;
return TRUE;
}
case EF_DRINK_DETONATE:
{
msg("Massive explosions rupture your body!");
take_hit(p_ptr, damroll(50, 20), "a potion of Detonation");
(void)player_inc_timed(p_ptr, TMD_STUN, 75, TRUE, TRUE);
(void)player_inc_timed(p_ptr, TMD_CUT, 5000, TRUE, TRUE);
*ident = TRUE;
return TRUE;
}
case EF_DRINK_SALT:
{
msg("The potion makes you vomit!");
player_set_food(p_ptr, PY_FOOD_STARVE - 1);
(void)player_clear_timed(p_ptr, TMD_POISONED, TRUE);
(void)player_inc_timed(p_ptr, TMD_PARALYZED, 4, TRUE, FALSE);
*ident = TRUE;
return TRUE;
}
case EF_FOOD_GOOD:
{
msg("That tastes good.");
*ident = TRUE;
return TRUE;
}
case EF_FOOD_WAYBREAD:
{
msg("That tastes good.");
(void)player_clear_timed(p_ptr, TMD_POISONED, TRUE);
(void)hp_player(damroll(4, 8));
*ident = TRUE;
return TRUE;
}
case EF_SHROOM_EMERGENCY:
{
(void)player_set_timed(p_ptr, TMD_IMAGE, rand_spread(250, 50), TRUE);
(void)player_set_timed(p_ptr, TMD_OPP_FIRE, rand_spread(30, 10), TRUE);
(void)player_set_timed(p_ptr, TMD_OPP_COLD, rand_spread(30, 10), TRUE);
(void)hp_player(200);
*ident = TRUE;
return TRUE;
}
case EF_SHROOM_TERROR:
{
if (player_set_timed(p_ptr, TMD_TERROR, rand_spread(100, 20), TRUE))
*ident = TRUE;
return TRUE;
}
case EF_SHROOM_STONE:
{
if (player_set_timed(p_ptr, TMD_STONESKIN, rand_spread(80, 20), TRUE))
*ident = TRUE;
return TRUE;
}
case EF_SHROOM_DEBILITY:
{
int stat = one_in_(2) ? A_STR : A_CON;
if (p_ptr->csp < p_ptr->msp)
{
p_ptr->csp = p_ptr->msp;
p_ptr->csp_frac = 0;
msg("Your feel your head clear.");
p_ptr->redraw |= (PR_MANA);
*ident = TRUE;
}
(void)do_dec_stat(stat, FALSE);
*ident = TRUE;
return TRUE;
}
case EF_SHROOM_SPRINTING:
{
if (player_inc_timed(p_ptr, TMD_SPRINT, 100, TRUE, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_SHROOM_PURGING:
{
player_set_food(p_ptr, PY_FOOD_FAINT - 1);
if (do_res_stat(A_STR)) *ident = TRUE;
if (do_res_stat(A_CON)) *ident = TRUE;
if (player_clear_timed(p_ptr, TMD_POISONED, TRUE)) *ident = TRUE;
return TRUE;
}
case EF_RING_ACID:
{
dam = 70 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_ACID, dir, dam, 2);
player_inc_timed(p_ptr, TMD_OPP_ACID, randint1(20) + 20, TRUE, TRUE);
return TRUE;
}
case EF_RING_FLAMES:
{
dam = 80 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_FIRE, dir, dam, 2);
player_inc_timed(p_ptr, TMD_OPP_FIRE, randint1(20) + 20, TRUE, TRUE);
return TRUE;
}
case EF_RING_ICE:
{
dam = 75 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_COLD, dir, dam, 2);
player_inc_timed(p_ptr, TMD_OPP_COLD, randint1(20) + 20, TRUE, TRUE);
return TRUE;
}
case EF_RING_LIGHTNING:
{
dam = 85 * (100 + boost) / 100;
*ident = TRUE;
fire_ball(GF_ELEC, dir, dam, 2);
player_inc_timed(p_ptr, TMD_OPP_ELEC, randint1(20) + 20, TRUE, TRUE);
return TRUE;
}
case EF_DRAGON_BLUE:
{
dam = 100 * (100 + boost) / 100;
msgt(MSG_BR_ELEC, "You breathe lightning.");
fire_ball(GF_ELEC, dir, dam, 2);
return TRUE;
}
case EF_DRAGON_GREEN:
{
dam = 150 * (100 + boost) / 100;
msgt(MSG_BR_GAS, "You breathe poison gas.");
fire_ball(GF_POIS, dir, dam, 2);
return TRUE;
}
case EF_DRAGON_RED:
{
dam = 200 * (100 + boost) / 100;
msgt(MSG_BR_FIRE, "You breathe fire.");
fire_ball(GF_FIRE, dir, dam, 2);
return TRUE;
}
case EF_DRAGON_MULTIHUED:
{
static const struct
{
int msg_sound;
const char *msg;
int typ;
} mh[] =
{
{ MSG_BR_ELEC, "lightning", GF_ELEC },
{ MSG_BR_FROST, "frost", GF_COLD },
{ MSG_BR_ACID, "acid", GF_ACID },
{ MSG_BR_GAS, "poison gas", GF_POIS },
{ MSG_BR_FIRE, "fire", GF_FIRE }
};
int chance = randint0(5);
dam = 250 * (100 + boost) / 100;
msgt(mh[chance].msg_sound, "You breathe %s.", mh[chance].msg);
fire_ball(mh[chance].typ, dir, dam, 2);
return TRUE;
}
case EF_DRAGON_BRONZE:
{
dam = 120 * (100 + boost) / 100;
msgt(MSG_BR_CONF, "You breathe confusion.");
fire_ball(GF_CONFU, dir, dam, 2);
return TRUE;
}
case EF_DRAGON_GOLD:
{
dam = 130 * (100 + boost) / 100;
msgt(MSG_BR_SOUND, "You breathe sound.");
fire_ball(GF_SOUND, dir, dam, 2);
return TRUE;
}
case EF_DRAGON_CHAOS:
{
dam = 220 * (100 + boost) / 100;
chance = randint0(2);
msgt((chance == 1 ? MSG_BR_CHAOS : MSG_BR_DISEN),
"You breathe %s.",
((chance == 1 ? "chaos" : "disenchantment")));
fire_ball((chance == 1 ? GF_CHAOS : GF_DISEN),
dir, dam, 2);
return TRUE;
}
case EF_DRAGON_LAW:
{
dam = 230 * (100 + boost) / 100;
chance = randint0(2);
msgt((chance == 1 ? MSG_BR_SOUND : MSG_BR_SHARDS), "You breathe %s.",
((chance == 1 ? "sound" : "shards")));
fire_ball((chance == 1 ? GF_SOUND : GF_SHARD),
dir, dam, 2);
return TRUE;
}
case EF_DRAGON_BALANCE:
{
dam = 250 * (100 + boost) / 100;
chance = randint0(4);
msg("You breathe %s.",
((chance == 1) ? "chaos" :
((chance == 2) ? "disenchantment" :
((chance == 3) ? "sound" : "shards"))));
fire_ball(((chance == 1) ? GF_CHAOS :
((chance == 2) ? GF_DISEN :
((chance == 3) ? GF_SOUND : GF_SHARD))),
dir, dam, 2);
return TRUE;
}
case EF_DRAGON_SHINING:
{
dam = 200 * (100 + boost) / 100;
chance = randint0(2);
msgt((chance == 0 ? MSG_BR_LIGHT : MSG_BR_DARK), "You breathe %s.",
((chance == 0 ? "light" : "darkness")));
fire_ball((chance == 0 ? GF_LIGHT : GF_DARK), dir, dam,
2);
return TRUE;
}
case EF_DRAGON_POWER:
{
dam = 300 * (100 + boost) / 100;
msgt(MSG_BR_ELEMENTS, "You breathe the elements.");
fire_ball(GF_MISSILE, dir, dam, 2);
return TRUE;
}
case EF_TRAP_DOOR:
{
msg("You fall through a trap door!");
if (check_state(p_ptr, OF_FEATHER, p_ptr->state.flags)) {
msg("You float gently down to the next level.");
} else {
take_hit(p_ptr, damroll(2, 8), "a trap");
}
wieldeds_notice_flag(p_ptr, OF_FEATHER);
dungeon_change_level(p_ptr->depth + 1);
return TRUE;
}
case EF_TRAP_PIT:
{
msg("You fall into a pit!");
if (check_state(p_ptr, OF_FEATHER, p_ptr->state.flags)) {
msg("You float gently to the bottom of the pit.");
} else {
take_hit(p_ptr, damroll(2, 6), "a trap");
}
wieldeds_notice_flag(p_ptr, OF_FEATHER);
return TRUE;
}
case EF_TRAP_PIT_SPIKES:
{
msg("You fall into a spiked pit!");
if (check_state(p_ptr, OF_FEATHER, p_ptr->state.flags)) {
msg("You float gently to the floor of the pit.");
msg("You carefully avoid touching the spikes.");
} else {
int dam = damroll(2, 6);
/* Extra spike damage */
if (one_in_(2)) {
msg("You are impaled!");
dam *= 2;
(void)player_inc_timed(p_ptr, TMD_CUT, randint1(dam), TRUE, TRUE);
}
take_hit(p_ptr, dam, "a trap");
}
wieldeds_notice_flag(p_ptr, OF_FEATHER);
return TRUE;
}
case EF_TRAP_PIT_POISON:
{
msg("You fall into a spiked pit!");
if (check_state(p_ptr, OF_FEATHER, p_ptr->state.flags)) {
msg("You float gently to the floor of the pit.");
msg("You carefully avoid touching the spikes.");
} else {
int dam = damroll(2, 6);
/* Extra spike damage */
if (one_in_(2)) {
msg("You are impaled on poisonous spikes!");
(void)player_inc_timed(p_ptr, TMD_CUT, randint1(dam * 2), TRUE, TRUE);
(void)player_inc_timed(p_ptr, TMD_POISONED, randint1(dam * 4), TRUE, TRUE);
}
take_hit(p_ptr, dam, "a trap");
}
wieldeds_notice_flag(p_ptr, OF_FEATHER);
return TRUE;
}
case EF_TRAP_RUNE_SUMMON:
{
int i;
int num = 2 + randint1(3);
msgt(MSG_SUM_MONSTER, "You are enveloped in a cloud of smoke!");
/* Remove trap */
cave->info[py][px] &= ~(CAVE_MARK);
cave_set_feat(cave, py, px, FEAT_FLOOR);
for (i = 0; i < num; i++)
(void)summon_specific(py, px, p_ptr->depth, 0, 1);
return TRUE;
}
case EF_TRAP_RUNE_TELEPORT:
{
msg("You hit a teleport trap!");
teleport_player(100);
return TRUE;
}
case EF_TRAP_SPOT_FIRE:
{
int dam;
msg("You are enveloped in flames!");
dam = damroll(4, 6);
dam = adjust_dam(p_ptr, GF_FIRE, dam, RANDOMISE,
check_for_resist(p_ptr, GF_FIRE, p_ptr->state.flags, TRUE));
if (dam) {
take_hit(p_ptr, dam, "a fire trap");
inven_damage(p_ptr, GF_FIRE, MIN(dam * 5, 300));
}
return TRUE;
}
case EF_TRAP_SPOT_ACID:
{
int dam;
msg("You are splashed with acid!");
dam = damroll(4, 6);
dam = adjust_dam(p_ptr, GF_ACID, dam, RANDOMISE,
check_for_resist(p_ptr, GF_ACID, p_ptr->state.flags, TRUE));
if (dam) {
take_hit(p_ptr, dam, "an acid trap");
inven_damage(p_ptr, GF_ACID, MIN(dam * 5, 300));
}
return TRUE;
}
case EF_TRAP_DART_SLOW:
{
if (trap_check_hit(125)) {
msg("A small dart hits you!");
take_hit(p_ptr, damroll(1, 4), "a trap");
(void)player_inc_timed(p_ptr, TMD_SLOW, randint0(20) + 20, TRUE, FALSE);
} else {
msg("A small dart barely misses you.");
}
return TRUE;
}
case EF_TRAP_DART_LOSE_STR:
{
if (trap_check_hit(125)) {
msg("A small dart hits you!");
take_hit(p_ptr, damroll(1, 4), "a trap");
(void)do_dec_stat(A_STR, FALSE);
} else {
msg("A small dart barely misses you.");
}
return TRUE;
}
case EF_TRAP_DART_LOSE_DEX:
{
if (trap_check_hit(125)) {
msg("A small dart hits you!");
take_hit(p_ptr, damroll(1, 4), "a trap");
(void)do_dec_stat(A_DEX, FALSE);
} else {
msg("A small dart barely misses you.");
}
return TRUE;
}
case EF_TRAP_DART_LOSE_CON:
{
if (trap_check_hit(125)) {
msg("A small dart hits you!");
take_hit(p_ptr, damroll(1, 4), "a trap");
(void)do_dec_stat(A_CON, FALSE);
} else {
msg("A small dart barely misses you.");
}
return TRUE;
}
case EF_TRAP_GAS_BLIND:
{
msg("You are surrounded by a black gas!");
(void)player_inc_timed(p_ptr, TMD_BLIND, randint0(50) + 25, TRUE, TRUE);
return TRUE;
}
case EF_TRAP_GAS_CONFUSE:
{
msg("You are surrounded by a gas of scintillating colors!");
(void)player_inc_timed(p_ptr, TMD_CONFUSED, randint0(20) + 10, TRUE, TRUE);
return TRUE;
}
case EF_TRAP_GAS_POISON:
{
msg("You are surrounded by a pungent green gas!");
(void)player_inc_timed(p_ptr, TMD_POISONED, randint0(20) + 10, TRUE, TRUE);
return TRUE;
}
case EF_TRAP_GAS_SLEEP:
{
msg("You are surrounded by a strange white mist!");
(void)player_inc_timed(p_ptr, TMD_PARALYZED, randint0(10) + 5, TRUE, TRUE);
return TRUE;
}
case EF_XXX:
case EF_MAX:
break;
}
/* Not used */
msg("Effect not handled.");
return FALSE;
}
int
on_OK_clicked(GtkButton *button, gpointer user_data)
{
char *cmd, buf[3], *buf2, *input, *tmp, *name, *enter, *enter_tmp;
int i, size;
input = gtk_entry_get_text(GTK_ENTRY (entry1));
if(input == NULL) {
perror("Inefficient memroy: input is NULL. Aborting.");
RTN_ON_OK_CLICKED = EXIT_FAILURE;
exit(1);
} else {
size = strlen("\'") + strlen(input) + strlen("\'") + 1;
enter = (char *) malloc (size*sizeof(char));
strcpy (enter, "\'");
strcat (enter, input);
strcat (enter, "\'");
size = 0; /* for reuse */
}
if (table[cur_pid].process != NULL ) {
if (input != NULL) {
sprintf(buf, "%d", cur_pid); /* Moved here to satisfy below */
name = xmlGetProp(table[cur_pid].page.curr,"name");
size = strlen(exec_path) + strlen(" -n") + sizeof(cur_pid) + strlen(buf)
+ strlen(" ") + strlen(name) + strlen(" start ") + 1;
cmd = (char *) malloc (size);
size = 0;
strcpy (cmd, exec_path);
strcat (cmd, " -n ");
strcat (cmd, buf);
strcat (cmd, " ");
strcat (cmd, name);
strcat (cmd, " start ");
runPeos(cmd);
free(cmd);
cmd = NULL;
size = strlen(exec_path) + strlen(" -r ") + strlen(buf) + strlen(" ")
+ strlen(res_name) + strlen(" ") + strlen(enter) + strlen(" ") + 1;
cmd = (char *) malloc (size);
size = 0;
/* ./peos -r pid resource_name resource_res_value */
strcpy (cmd, exec_path);
strcat (cmd, " -r ");
strcat (cmd, buf);
strcat (cmd, " ");
strcat (cmd, res_name);
strcat (cmd, " ");
strcat (cmd, enter);
strcat (cmd, " ");
tmp = get_current_dir_name();
if(tmp == NULL) {
perror("No current directory found. Aborting. \n");
RTN_ON_OK_CLICKED = EXIT_FAILURE;
exit(1);
} else {
//size = strlen(tmp) + strlen("/") + strlen(enter_tmp) + 1;
size = strlen(tmp) + strlen("/") + 1;
buf2 = (char *) malloc(size*sizeof(char));
size = 0;
strcpy(buf2, tmp);
strcat(buf2,"/");
}
if(enter == NULL) {
perror("Memory alloc error: enter = NULL \n");
RTN_ON_OK_CLICKED = EXIT_FAILURE;
exit(1);
} else enter[strlen(enter)] = '\0';
/* to eliminate the quotes and -2 in alloc to take into acount: '"', '"' */
size = strlen(enter) + 1;
enter_tmp = (char *) malloc(size*sizeof(char));
strcpy(enter_tmp, enter);
int j = 0;
for(i = 1; i < size-3; i++) {
/* integer value for the single quote character */
if(enter[i] != 39) {
enter_tmp[j] = enter[i];
j++;
}
}
enter_tmp[strlen(enter_tmp)-1] = '\0';
/* need more memory */
char *buf2_temp = NULL;
size = 0;
size = strlen(buf2) + strlen(enter_tmp) + 1;
buf2_temp = (char *) malloc(size*sizeof(char));
strcpy(buf2_temp, buf2);
free(buf2);
buf2 = NULL;
strcat(buf2_temp, enter_tmp);
free(enter_tmp);
enter_tmp = NULL;
free(buf2_temp);
buf2_temp = NULL;
runPeos (cmd);
free (cmd);
cmd = NULL;
freeAll_extra();
draw_tree (cur_pid);
/* search through actions and find the current page */
for ( i = 0; i < counting_action; i++) {
if (strcmp (linklist[cur_pid][i].cur->name, "action") == 0) {
if (strcmp (xmlGetProp (linklist[cur_pid][i].cur, "name"), name) == 0) {
table[cur_pid].page.curr = linklist[cur_pid][i].cur;
break;
}
}
}
draw_text(table[cur_pid].page.curr);
/* highlight the current item in the jtree */
if((GTK_IS_WIDGET (table[cur_pid].page.tree1) && GTK_IS_TREE (GTK_TREE (table[cur_pid].page.tree1))))
gtk_tree_select_child ( GTK_TREE (table[cur_pid].page.tree1),
linklist[cur_pid][table[cur_pid].page.index].item);
}
free (enter);
enter = NULL;
/* check to maintain the next and previous states */
check_state();
}
/* return global EXIT_SUCCESS */
RTN_ON_OK_CLICKED = EXIT_SUCCESS;
return EXIT_SUCCESS;
}
int main(void)
{
int init_res;
puts("\nRIOT netdev test");
dev = NETDEV_DEFAULT;
if (dev == NULL) {
puts("Default device was NULL");
return 1;
}
printf("Initialized dev ");
switch (dev->type) {
case NETDEV_TYPE_UNKNOWN:
printf("of unknown type\n");
break;
case NETDEV_TYPE_BASE:
printf("as basic device\n");
break;
default:
printf("of undefined type\n");
break;
}
if (dev->driver == NULL) {
puts("Default driver is defined as NULL!");
return 1;
}
dev->driver->init(dev);
if (!(init_res = init_channel())) {
return 1;
}
if (check_channel() == 0) {
printf("Channel is not as expected. ");
if (init_res == 2) {
printf("But initialization is not supported. Continuing.\n");
}
else {
printf("Aborting\n");
return 1;
}
}
if (!(init_res = init_address())) {
return 1;
}
if (check_address() == 0) {
printf("Address is not as expected. ");
if (init_res == 2) {
printf("But initialization is not supported. Continuing.\n");
}
else {
printf("Aborting\n");
return 1;
}
}
if (!(init_res = init_long_address())) {
return 1;
}
if (check_long_address() == 0) {
printf("Long address is not as expected. ");
if (init_res == 2) {
printf("But initialization is not supported. Continuing.\n");
}
else {
printf("Aborting\n");
return 1;
}
}
if (!(init_res = init_nid())) {
return 1;
}
if (check_nid() == 0) {
printf("Network ID is not as expected. ");
if (init_res == 2) {
printf("But initialization is not supported. Continuing.\n");
}
else {
printf("Aborting\n");
return 1;
}
}
if (check_max_packet_size() == 0) {
return 1;
}
if (check_protocol() == 0) {
return 1;
}
if (!init_state()) {
return 1;
}
if (!check_state()) {
return 1;
}
#ifdef SENDER
if (!send_packet()) {
return 1;
}
#elif RECEIVER
if (!init_receiver_callback()) {
return 1;
}
#endif
return 0;
}
static inline void
brw_upload_pipeline_state(struct brw_context *brw,
enum brw_pipeline pipeline)
{
struct gl_context *ctx = &brw->ctx;
int i;
static int dirty_count = 0;
struct brw_state_flags state = brw->state.pipelines[pipeline];
unsigned int fb_samples = _mesa_geometric_samples(ctx->DrawBuffer);
brw_select_pipeline(brw, pipeline);
if (0) {
/* Always re-emit all state. */
brw->NewGLState = ~0;
ctx->NewDriverState = ~0ull;
}
if (pipeline == BRW_RENDER_PIPELINE) {
if (brw->fragment_program != ctx->FragmentProgram._Current) {
brw->fragment_program = ctx->FragmentProgram._Current;
brw->ctx.NewDriverState |= BRW_NEW_FRAGMENT_PROGRAM;
}
if (brw->tess_eval_program != ctx->TessEvalProgram._Current) {
brw->tess_eval_program = ctx->TessEvalProgram._Current;
brw->ctx.NewDriverState |= BRW_NEW_TESS_PROGRAMS;
}
if (brw->tess_ctrl_program != ctx->TessCtrlProgram._Current) {
brw->tess_ctrl_program = ctx->TessCtrlProgram._Current;
brw->ctx.NewDriverState |= BRW_NEW_TESS_PROGRAMS;
}
if (brw->geometry_program != ctx->GeometryProgram._Current) {
brw->geometry_program = ctx->GeometryProgram._Current;
brw->ctx.NewDriverState |= BRW_NEW_GEOMETRY_PROGRAM;
}
if (brw->vertex_program != ctx->VertexProgram._Current) {
brw->vertex_program = ctx->VertexProgram._Current;
brw->ctx.NewDriverState |= BRW_NEW_VERTEX_PROGRAM;
}
}
if (brw->compute_program != ctx->ComputeProgram._Current) {
brw->compute_program = ctx->ComputeProgram._Current;
brw->ctx.NewDriverState |= BRW_NEW_COMPUTE_PROGRAM;
}
if (brw->meta_in_progress != _mesa_meta_in_progress(ctx)) {
brw->meta_in_progress = _mesa_meta_in_progress(ctx);
brw->ctx.NewDriverState |= BRW_NEW_META_IN_PROGRESS;
}
if (brw->num_samples != fb_samples) {
brw->num_samples = fb_samples;
brw->ctx.NewDriverState |= BRW_NEW_NUM_SAMPLES;
}
/* Exit early if no state is flagged as dirty */
merge_ctx_state(brw, &state);
if ((state.mesa | state.brw) == 0)
return;
/* Emit Sandybridge workaround flushes on every primitive, for safety. */
if (brw->gen == 6)
brw_emit_post_sync_nonzero_flush(brw);
brw_upload_programs(brw, pipeline);
merge_ctx_state(brw, &state);
brw_upload_state_base_address(brw);
const struct brw_tracked_state *atoms =
brw_get_pipeline_atoms(brw, pipeline);
const int num_atoms = brw->num_atoms[pipeline];
if (unlikely(INTEL_DEBUG)) {
/* Debug version which enforces various sanity checks on the
* state flags which are generated and checked to help ensure
* state atoms are ordered correctly in the list.
*/
struct brw_state_flags examined, prev;
memset(&examined, 0, sizeof(examined));
prev = state;
for (i = 0; i < num_atoms; i++) {
const struct brw_tracked_state *atom = &atoms[i];
struct brw_state_flags generated;
check_and_emit_atom(brw, &state, atom);
accumulate_state(&examined, &atom->dirty);
/* generated = (prev ^ state)
* if (examined & generated)
* fail;
*/
xor_states(&generated, &prev, &state);
assert(!check_state(&examined, &generated));
prev = state;
}
}
else {
for (i = 0; i < num_atoms; i++) {
const struct brw_tracked_state *atom = &atoms[i];
check_and_emit_atom(brw, &state, atom);
}
}
if (unlikely(INTEL_DEBUG & DEBUG_STATE)) {
STATIC_ASSERT(ARRAY_SIZE(brw_bits) == BRW_NUM_STATE_BITS + 1);
brw_update_dirty_count(mesa_bits, state.mesa);
brw_update_dirty_count(brw_bits, state.brw);
if (dirty_count++ % 1000 == 0) {
brw_print_dirty_count(mesa_bits);
brw_print_dirty_count(brw_bits);
fprintf(stderr, "\n");
}
}
}
void
task1(intptr_t exinf)
{
ER_UINT ercd;
T_RTEX rtex;
test_start(__FILE__);
check_point(1);
check_state(false, false, TIPM_ENAALL, false, false, true);
ercd = ref_tex(TSK_SELF, &rtex);
check_ercd(ercd, E_OK);
check_assert((rtex.texstat & TTEX_DIS) != 0U);
check_assert(rtex.pndptn == 0U);
ercd = ras_tex(TASK3, 0x0001);
check_ercd(ercd, E_OBJ);
ercd = ras_tex(TASK4, 0x0001);
check_ercd(ercd, E_OBJ);
ercd = ref_tex(TASK3, &rtex);
check_ercd(ercd, E_OBJ);
ercd = ref_tex(TASK4, &rtex);
check_ercd(ercd, E_OBJ);
check_point(2);
ercd = ena_tex();
check_ercd(ercd, E_OK);
check_state(false, false, TIPM_ENAALL, false, false, false);
ercd = ref_tex(TSK_SELF, &rtex);
check_ercd(ercd, E_OK);
check_assert((rtex.texstat & TTEX_ENA) != 0U);
check_assert(rtex.pndptn == 0U);
check_point(3);
ercd = ras_tex(TSK_SELF, 0x0001);
check_ercd(ercd, E_OK);
check_point(6);
check_state(false, false, TIPM_ENAALL, true, true, false);
check_point(7);
ercd = dis_tex();
check_ercd(ercd, E_OK);
check_state(false, false, TIPM_ENAALL, true, true, true);
check_point(8);
ercd = ras_tex(TASK1, 0x0002);
check_ercd(ercd, E_OK);
ercd = ref_tex(TSK_SELF, &rtex);
check_ercd(ercd, E_OK);
check_assert((rtex.texstat & TTEX_DIS) != 0);
check_assert(rtex.pndptn == 0x0002);
check_point(9);
ercd = ena_tex();
check_ercd(ercd, E_OK);
check_point(20);
check_state(false, false, TIPM_ENAALL, true, true, false);
check_point(21);
ercd = ena_dsp();
check_ercd(ercd, E_OK);
ercd = rot_rdq(TPRI_SELF);
check_ercd(ercd, E_OK);
check_point(27);
ercd = ras_tex(TASK2, 0x0001);
check_ercd(ercd, E_OK);
ercd = ref_tex(TASK2, &rtex);
check_ercd(ercd, E_OK);
check_point(28);
ercd = rot_rdq(TPRI_SELF);
check_ercd(ercd, E_OK);
check_point(35);
return;
check_point(0);
}
void
tex_task1(TEXPTN texptn, intptr_t exinf)
{
ER_UINT ercd;
switch (++tex_task1_count) {
case 1:
check_point(4);
check_assert(texptn == 0x0001);
check_state(false, false, TIPM_ENAALL, false, false, true);
check_point(5);
ercd = dis_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = ena_tex();
check_ercd(ercd, E_OK);
ercd = loc_cpu();
check_ercd(ercd, E_OK);
check_state(false, true, TMAX_INTPRI, true, true, false);
return;
check_point(0);
case 2:
check_point(10);
check_assert(texptn == 0x0002);
check_state(false, false, TIPM_ENAALL, true, true, true);
check_point(11);
ercd = ras_tex(TASK1, 0x0001);
check_ercd(ercd, E_OK);
ercd = ras_tex(TASK1, 0x0002);
check_ercd(ercd, E_OK);
check_point(12);
ercd = ena_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = loc_cpu();
check_ercd(ercd, E_OK);
check_state(false, true, TMAX_INTPRI, false, true, true);
return;
check_point(0);
case 3:
check_point(13);
check_assert(texptn == 0x0003);
check_state(false, false, TIPM_ENAALL, false, false, true);
check_point(14);
ercd = ena_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = ena_tex();
check_ercd(ercd, E_OK);
check_state(false, false, TMAX_INTPRI, false, true, false);
ercd = chg_ipm(TIPM_ENAALL);
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
check_point(15);
ercd = ras_tex(TSK_SELF, 0x0004);
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = dis_tex();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TIPM_ENAALL);
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = ena_tex();
check_ercd(ercd, E_OK);
check_point(16);
ercd = chg_ipm(TIPM_ENAALL);
check_ercd(ercd, E_OK);
check_point(19);
check_state(false, false, TIPM_ENAALL, true, true, false);
return;
check_point(0);
case 4:
check_point(17);
check_assert(texptn == 0x0004);
check_state(false, false, TIPM_ENAALL, false, false, true);
check_point(18);
ercd = dis_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = loc_cpu();
check_ercd(ercd, E_OK);
check_state(false, true, TMAX_INTPRI, true, true, true);
return;
check_point(0);
default:
check_point(0);
}
check_point(0);
}
static void
hub_handle_command(char *buf, uint32_t len)
{
char *hub_my_nick; /* XXX */
hub_my_nick = main_to_hub_string(my_nick);
if (len >= 6 && strncmp(buf, "$Lock ", 6) == 0) {
char *key;
if (!check_state(buf, (DCUserState) DC_HUB_LOCK))
goto hub_handle_command_cleanup;
key = (char*) memmem(buf+6, len-6, " Pk=", 4);
if (key == NULL) {
warn(_("Invalid $Lock message: Missing Pk value\n"));
key = buf+len;
}
key = decode_lock(buf+6, key-buf-6, DC_CLIENT_BASE_KEY);
if (strleftcmp("EXTENDEDPROTOCOL", buf+6) == 0) {
if (!hub_putf("$Supports TTHSearch NoGetINFO NoHello|")) {
free(key);
goto hub_handle_command_cleanup;
}
}
if (!hub_putf("$Key %s|", key)) {
free(key);
goto hub_handle_command_cleanup;
}
free(key);
if (!hub_putf("$ValidateNick %s|", hub_my_nick))
goto hub_handle_command_cleanup;
hub_state = DC_HUB_HELLO;
}
else if (len >= 10 && strncmp(buf, "$Supports ", 10) == 0) {
char *p0, *p1;
hub_extensions = 0;
for (p0 = buf+10; (p1 = strchr(p0, ' ')) != NULL; p0 = p1+1) {
*p1 = '\0';
parse_hub_extension(p0);
}
if (*p0 != '\0')
parse_hub_extension(p0);
}
else if (strcmp(buf, "$GetPass") == 0) {
if (my_password == NULL) {
screen_putf(_("Hub requires password.\n"));
hub_disconnect();
goto hub_handle_command_cleanup;
}
screen_putf(_("Sending password to hub.\n"));
if (!hub_putf("$MyPass %s|", my_password))
goto hub_handle_command_cleanup;
}
else if (strcmp(buf, "$BadPass") == 0) {
warn(_("Password not accepted.\n"));
hub_disconnect();
}
else if (strcmp(buf, "$LogedIn") == 0) {
screen_putf(_("You have received operator status.\n"));
}
else if (len >= 9 && strncmp(buf, "$HubName ", 9) == 0) {
free(hub_name);
hub_name = hub_to_main_string(buf + 9);
screen_putf(_("Hub name is %s.\n"), quotearg(hub_name));
}
else if (strcmp(buf, "$GetNetInfo") == 0) {
hub_putf("$NetInfo %d$1$%c|", my_ul_slots, is_active ? 'A' : 'P');
}
else if (strcmp(buf, "$ValidateDenide") == 0) {
if (!check_state(buf, (DCUserState) DC_HUB_HELLO))
goto hub_handle_command_cleanup;
/* DC++ disconnects immediately if this is received.
* But shouldn't we give the client a chance to change the nick?
* Also what happens if we receive this when correctly logged in?
*/
warn(_("Hub did not accept nick. Nick may be in use.\n"));
hub_disconnect();
}
else if (len >= 7 && strncmp(buf, "$Hello ", 7) == 0) {
DCUserInfo *ui;
char *conv_nick;
conv_nick = hub_to_main_string(buf + 7);
if (hub_state == DC_HUB_HELLO) {
if (strcmp(buf+7, hub_my_nick) == 0) {
screen_putf(_("Nick accepted. You are now logged in.\n"));
} else {
/* This probably won't happen, but better safe... */
free(my_nick);
my_nick = xstrdup(conv_nick);
free(hub_my_nick);
hub_my_nick = xstrdup(buf + 7);
screen_putf(_("Nick accepted but modified to %s. You are now logged in.\n"), quotearg(my_nick));
}
ui = user_info_new(conv_nick);
ui->info_quered = true; /* Hub is sending this automaticly */
hmap_put(hub_users, ui->nick, ui);
free (conv_nick);
if (!hub_putf("$Version 1,0091|"))
goto hub_handle_command_cleanup;
if (!hub_putf("$GetNickList|"))
goto hub_handle_command_cleanup;
if (!send_my_info())
goto hub_handle_command_cleanup;
hub_state = DC_HUB_LOGGED_IN;
} else {
flag_putf(DC_DF_JOIN_PART, _("User %s logged in.\n"), quotearg(conv_nick));
ui = user_info_new(conv_nick);
hmap_put(hub_users, ui->nick, ui);
free (conv_nick);
if ((hub_extensions & HUB_EXT_NOGETINFO) == 0) {
if (!hub_putf("$GetINFO %s %s|", buf+7, hub_my_nick))
goto hub_handle_command_cleanup;
ui->info_quered = true;
}
}
}
else if (len >= 8 && strncmp(buf, "$MyINFO ", 8) == 0) {
DCUserInfo *ui;
char *token;
uint32_t len;
char* conv_buf;
char *work_buf;
buf += 8;
work_buf = conv_buf = hub_to_main_string(buf);
token = strsep(&work_buf, " ");
if (strcmp(token, "$ALL") != 0) {
warn(_("Invalid $MyINFO message: Missing $ALL parameter, ignoring\n"));
free(conv_buf);
goto hub_handle_command_cleanup;
}
token = strsep(&work_buf, " ");
if (token == NULL) {
warn(_("Invalid $MyINFO message: Missing nick parameter, ignoring\n"));
free(conv_buf);
goto hub_handle_command_cleanup;
}
ui = (DCUserInfo*) hmap_get(hub_users, token);
if (ui == NULL) {
/*
* if the full buf has not been converted from hub to local charset,
* we should try to convert nick only
*/
/*
char *conv_nick = hub_to_main_string(token);
if ((ui = hmap_get(hub_users, conv_nick)) == NULL) {
*/
ui = user_info_new(token);
ui->info_quered = true;
hmap_put(hub_users, ui->nick, ui);
/*
}
free(conv_nick);
*/
}
token = strsep(&work_buf, "$");
if (token == NULL) {
warn(_("Invalid $MyINFO message: Missing description parameter, ignoring\n"));
free(conv_buf);
goto hub_handle_command_cleanup;
}
free(ui->description);
ui->description = xstrdup(token);
token = strsep(&work_buf, "$");
if (token == NULL) {
warn(_("Invalid $MyINFO message: Missing description separator, ignoring\n"));
free(conv_buf);
goto hub_handle_command_cleanup;
}
token = strsep(&work_buf, "$");
if (token == NULL) {
warn(_("Invalid $MyINFO message: Missing connection speed, ignoring\n"));
free(conv_buf);
goto hub_handle_command_cleanup;
}
len = strlen(token);
free(ui->speed);
if (len == 0) {
ui->speed = xstrdup("");
ui->level = 0; /* XXX: or 1? acceptable level? */
} else {
ui->speed = xstrndup(token, len-1);
ui->level = token[len-1];
}
token = strsep(&work_buf, "$");
if (token == NULL) {
warn(_("Invalid $MyINFO message: Missing e-mail address, ignoring\n"));
free(conv_buf);
goto hub_handle_command_cleanup;
}
free(ui->email);
ui->email = xstrdup(token);
token = strsep(&work_buf, "$");
if (token == NULL) {
warn(_("Invalid $MyINFO message: Missing share size, ignoring\n"));
free(conv_buf);
goto hub_handle_command_cleanup;
}
if (!parse_uint64(token, &ui->share_size)) {
warn(_("Invalid $MyINFO message: Invalid share size, ignoring\n"));
free(conv_buf);
goto hub_handle_command_cleanup;
}
if (ui->active_state == DC_ACTIVE_RECEIVED_PASSIVE
|| ui->active_state == DC_ACTIVE_KNOWN_ACTIVE)
ui->active_state = DC_ACTIVE_UNKNOWN;
/* XXX: Now that user's active_state may have changed, try queue again? */
free(conv_buf);
}
else if (strcmp(buf, "$HubIsFull") == 0) {
warn(_("Hub is full.\n"));
/* DC++ does not disconnect immediately. So I guess we won't either. */
/* Maybe we should be expecting an "hub follow" message? */
/* hub_disconnect(); */
}
else if (len >= 3 && (buf[0] == '<' || strncmp(buf, " * ", 3) == 0)) {
char *head;
char *tail;
char *msg;
bool first = true;
/*
int scrwidth;
size_t firstlen;
size_t otherlen;
screen_get_size(NULL, &scrwidth);
firstlen = scrwidth - strlen(_("Public:"));
otherlen = scrwidth - strlen(_(" | "));
*/
msg = prepare_chat_string_for_display(buf);
for (head = msg; (tail = strchr(head, '\n')) != NULL; head = tail+1) {
/*PtrV *wrapped;*/
if (tail[-1] == '\r') /* end > buf here, buf[0] == '<' or ' ' */
tail[-1] = '\0';
else
tail[0] = '\0';
/*wrapped = wordwrap(quotearg(buf), first ? firstlen : otherlen, otherlen);
for (c = 0; c < wrapped->cur; c++)
flag_putf(DC_DF_PUBLIC_CHAT, first ? _("Public: %s\n") : _(" | %s\n"), );
ptrv_foreach(wrapped, free);
ptrv_free(wrapped);*/
flag_putf(DC_DF_PUBLIC_CHAT, first ? _("Public: %s\n") : _(" | %s\n"), quotearg(head));
first = false;
}
flag_putf(DC_DF_PUBLIC_CHAT, first ? _("Public: %s\n") : _(" | %s\n"), quotearg(head));
free(msg);
}
else if (len >= 5 && strncmp(buf, "$To: ", 5) == 0) {
char *msg;
char *tail;
char *frm;
char *head;
bool first = true;
msg = strchr(buf+5, '$');
if (msg == NULL) {
warn(_("Invalid $To message: Missing text separator, ignoring\n"));
goto hub_handle_command_cleanup;
}
*msg = '\0';
msg++;
/* FIXME: WTF is this? Remove multiple "From: "? Why!? */
frm = buf+5;
while ((tail = strstr(msg, "From: ")) != NULL && tail < msg)
frm = tail+6;
msg = prepare_chat_string_for_display(msg);
frm = prepare_chat_string_for_display(frm);
for (head = msg; (tail = strchr(head, '\n')) != NULL; head = tail+1) {
if (tail[-1] == '\r') /* tail > buf here because head[0] == '<' or ' ' */
tail[-1] = '\0';
else
tail[0] = '\0';
if (first) {
screen_putf(_("Private: [%s] %s\n"), quotearg_n(0, frm), quotearg_n(1, head));
first = false;
} else {
screen_putf(_(" | %s\n"), quotearg(head));
}
}
if (first) {
screen_putf(_("Private: [%s] %s\n"), quotearg_n(0, frm), quotearg_n(1, head));
} else {
screen_putf(_(" | %s\n"), quotearg(head));
}
free(msg);
free(frm);
}
else if (len >= 13 && strncmp(buf, "$ConnectToMe ", 13) == 0) {
struct sockaddr_in addr;
buf += 13;
if (strsep(&buf, " ") == NULL) {
warn(_("Invalid $ConnectToMe message: Missing or invalid nick\n"));
goto hub_handle_command_cleanup;
}
if (!parse_ip_and_port(buf, &addr, 0)) {
warn(_("Invalid $ConnectToMe message: Invalid address specification.\n"));
goto hub_handle_command_cleanup;
}
flag_putf(DC_DF_CONNECTIONS, _("Connecting to user on %s\n"), sockaddr_in_str(&addr));
user_connection_new(&addr, -1);
}
else if (len >= 16 && strncmp(buf, "$RevConnectToMe ", 16) == 0) {
char *nick;
char *local_nick;
DCUserInfo *ui;
nick = strtok(buf+16, " ");
if (nick == NULL) {
warn(_("Invalid $RevConnectToMe message: Missing nick parameter\n"));
goto hub_handle_command_cleanup;
}
if (strcmp(nick, hub_my_nick) == 0) {
warn(_("Invalid $RevConnectToMe message: Remote nick is our nick\n"));
goto hub_handle_command_cleanup;
}
local_nick = hub_to_main_string(nick);
ui = (DCUserInfo*) hmap_get(hub_users, local_nick);
if (ui == NULL) {
warn(_("Invalid $RevConnectToMe message: Unknown user %s, ignoring\n"), quotearg(local_nick));
free(local_nick);
goto hub_handle_command_cleanup;
}
free(local_nick);
if (ui->conn_count >= DC_USER_MAX_CONN) {
warn(_("No more connections to user %s allowed.\n"), quotearg(ui->nick));
goto hub_handle_command_cleanup;
}
if (!is_active) {
if (ui->active_state == DC_ACTIVE_SENT_PASSIVE) {
warn(_("User %s is also passive. Cannot establish connection.\n"), quotearg(ui->nick));
/* We could set this to DC_ACTIVE_UNKNOWN too. This would mean
* we would keep sending RevConnectToMe next time the download
* queue is modified or some timer expired and told us to retry
* download. The remote would then send back RevConnectToMe
* and this would happen again. This way we would try again -
* maybe remote has become active since last time we checked?
* But no - DC++ only replies with RevConnectToMe to our first
* RevConnectToMe. After that it ignores them all.
*/
ui->active_state = DC_ACTIVE_RECEIVED_PASSIVE;
if (hmap_remove(pending_userinfo, ui->nick) != NULL)
ui->refcount--;
goto hub_handle_command_cleanup;
}
if (ui->active_state != DC_ACTIVE_RECEIVED_PASSIVE) {
/* Inform remote that we are also passive. */
if (!hub_putf("$RevConnectToMe %s %s|", hub_my_nick, nick))
goto hub_handle_command_cleanup;
}
}
ui->active_state = DC_ACTIVE_RECEIVED_PASSIVE;
if (!hub_connect_user(ui))
goto hub_handle_command_cleanup;
}
else if ( (len >= 10 && strncmp(buf, "$NickList ", 10) == 0)
|| (len >= 8 && strncmp(buf, "$OpList ", 8) == 0) ) {
char *nick;
char *end;
int oplist;
char *conv_nick;
if ( strncmp(buf, "$NickList ", 10) == 0) {
nick = buf + 10;
oplist = 0;
} else {
nick = buf + 8;
oplist = 1;
}
for (; (end = strstr(nick, "$$")) != NULL; nick = end+2) {
DCUserInfo *ui;
*end = '\0';
conv_nick = hub_to_main_string(nick);
ui = (DCUserInfo*) hmap_get(hub_users, conv_nick);
if (ui == NULL) {
ui = user_info_new(conv_nick);
hmap_put(hub_users, ui->nick, ui);
}
free(conv_nick);
if (!ui->info_quered && (hub_extensions & HUB_EXT_NOGETINFO) == 0) {
if (!hub_putf("$GetINFO %s %s|", nick, hub_my_nick)) {
goto hub_handle_command_cleanup;
}
ui->info_quered = true;
}
if (oplist)
ui->is_operator = true;
}
}
else if (len >= 6 && strncmp(buf, "$Quit ", 6) == 0) {
DCUserInfo *ui;
char *conv_nick = hub_to_main_string(buf+6);
// I don't want these messages.
//flag_putf(DC_DF_JOIN_PART, "User %s quits.\n", quotearg(conv_nick));
ui = (DCUserInfo*) hmap_remove(hub_users, conv_nick);
if (ui == NULL) {
/* Some hubs print quit messages for users that never joined,
* so print this as debug only.
*/
flag_putf(DC_DF_DEBUG, _("Invalid $Quit message: Unknown user %s.\n"), quotearg(conv_nick));
} else
user_info_free(ui);
free(conv_nick);
}
else if (len >= 8 && strncmp(buf, "$Search ", 8) == 0) {
char *source;
int parse_result = 0;
DCSearchSelection sel;
sel.patterns = NULL;
buf += 8;
source = strsep(&buf, " ");
if (source == NULL) {
warn(_("Invalid $Search message: Missing source specification.\n"));
goto hub_handle_command_cleanup;
}
/* charset handling is in parse_search_selection */
parse_result = parse_search_selection(buf, &sel);
if (parse_result != 1) {
if (sel.patterns != NULL) {
int i = 0;
for (i = 0; i < sel.patterncount; i++) {
search_string_free(sel.patterns+i);
}
free(sel.patterns);
}
if (parse_result == 0)
warn(_("Invalid $Search message: %s: Invalid search specification.\n"), buf);
goto hub_handle_command_cleanup;
}
if (strncmp(source, "Hub:", 4) == 0) {
DCUserInfo *ui;
char *conv_nick = hub_to_main_string(source+4);
ui = (DCUserInfo*) hmap_get(hub_users, conv_nick);
if (ui == NULL) {
warn(_("Invalid $Search message: Unknown user %s.\n"), quotearg(conv_nick));
if (sel.patterns != NULL) {
int i = 0;
for (i = 0; i < sel.patterncount; i++) {
search_string_free(sel.patterns+i);
}
free(sel.patterns);
}
free(conv_nick);
goto hub_handle_command_cleanup;
}
free(conv_nick);
if (strcmp(ui->nick, my_nick) == 0) {
if (sel.patterns != NULL) {
int i = 0;
for (i = 0; i < sel.patterncount; i++) {
search_string_free(sel.patterns+i);
}
free(sel.patterns);
}
goto hub_handle_command_cleanup;
}
perform_inbound_search(&sel, ui, NULL);
if (sel.patterns != NULL) {
int i = 0;
for (i = 0; i < sel.patterncount; i++) {
search_string_free(sel.patterns+i);
}
free(sel.patterns);
}
} else {
struct sockaddr_in addr;
if (!parse_ip_and_port(source, &addr, DC_CLIENT_UDP_PORT)) {
warn(_("Invalid $Search message: Invalid address specification.\n"));
if (sel.patterns != NULL) {
int i = 0;
for (i = 0; i < sel.patterncount; i++) {
search_string_free(sel.patterns+i);
}
free(sel.patterns);
}
goto hub_handle_command_cleanup;
}
if (local_addr.sin_addr.s_addr == addr.sin_addr.s_addr && listen_port == ntohs(addr.sin_port)) {
if (sel.patterns != NULL) {
int i = 0;
for (i = 0; i < sel.patterncount; i++) {
search_string_free(sel.patterns+i);
}
free(sel.patterns);
}
goto hub_handle_command_cleanup;
}
perform_inbound_search(&sel, NULL, &addr);
if (sel.patterns != NULL) {
int i = 0;
for (i = 0; i < sel.patterncount; i++) {
search_string_free(sel.patterns+i);
}
free(sel.patterns);
}
}
} else if (len >= 4 && strncmp(buf, "$SR ", 4) == 0) {
handle_search_result(buf, len);
} else if (len == 0) {
/* Ignore empty commands. */
}
hub_handle_command_cleanup:
free(hub_my_nick);
}
int main(int argc, char** argv)
{
sim_param_t params;
if (get_params(argc, argv, ¶ms) != 0)
exit(-1);
// Create global
sim_state_t* globalState = init_particles(¶ms);
#pragma omp parallel shared(globalState, params)
{
int proc = omp_get_thread_num();
int nproc = omp_get_num_threads();
FILE* fp = fopen(params.fname, "w");
int nframes = params.nframes;
int npframe = params.npframe;
float dt = params.dt;
int n = globalState->n;
// Processor information and holder
proc_info* pInfo = malloc(sizeof(proc_info));
pInfo->proc = proc;
pInfo->nproc = nproc;
pInfo->beg = round((proc/(double)nproc)*n);
pInfo->end = round(((proc+1)/(double)nproc)*n);
pInfo->forceAccu = calloc(3*n, sizeof(float)); // Never used this...
if (proc == 0) {
printf("Running in parallel with %d processor\n", nproc);
}
normalize_mass(globalState, pInfo, ¶ms);
double t_start = omp_get_wtime();
if (proc == 0) { // We only write for one processor
write_header(fp, n, nframes, params.h);
write_frame_data(fp, n, globalState, NULL);
}
if (proc == 0) {
hash_particles(globalState, params.h);
}
//hash_particles_parallel(globalState, pInfo, params.h);
#pragma omp barrier // Need the hashing to be done
compute_accel(globalState, pInfo, ¶ms);
#pragma omp barrier
leapfrog_start(globalState, pInfo, dt);
check_state(globalState, pInfo);
for (int frame = 1; frame < nframes; ++frame) {
// We sort according to Z-Morton to ensure locality, need to implement paralle qsort
if (frame % 5 == 0) {
// Dividing into chunks of sorting each chunk
// This alone turned out to better than sorting the entire array
qsort(globalState->part+pInfo->beg, pInfo->end-pInfo->beg ,sizeof(particle_t),compPart);
// Sorting the array consisting of sorted chunks
// This turned out to actually lower the performance. That's why
// I commented it.
// #pragma omp barrier
// if( pInfo->nproc >1 ) arraymerge(globalState->part, globalState->n, pInfo);
//#pragma omp barrier*/
// Serial version
/*#pragma omp single // Implied barrier
qsort(globalState->part, n, sizeof(particle_t), compPart);*/
}
/*else if (frame % 49) {*/
/*if (proc == 0) {*/
/*}*/
/*}*/
#pragma omp barrier // Need sort to finish
for (int i = 0; i < npframe; ++i) {
if (proc == 0 && npframe % 4 == 0) { // Ammortize hashing cost
hash_particles(globalState, params.h);
}
#pragma omp barrier
compute_accel(globalState, pInfo, ¶ms);
leapfrog_step(globalState, pInfo, dt);
check_state(globalState, pInfo);
#pragma omp barrier
}
if (proc == 0) {
printf("Frame: %d of %d - %2.1f%%\n",frame, nframes,
100*(float)frame/nframes);
write_frame_data(fp, n, globalState, NULL);
}
}
double t_end = omp_get_wtime();
if (proc == 0) {
printf("Ran in %g seconds\n", t_end-t_start);
}
free(pInfo);
fclose(fp);
}
free_state(globalState);
}
/***********************************************************************
* Emit all state:
*/
void brw_upload_state(struct brw_context *brw)
{
struct gl_context *ctx = &brw->intel.ctx;
struct intel_context *intel = &brw->intel;
struct brw_state_flags *state = &brw->state.dirty;
int i;
static int dirty_count = 0;
state->mesa |= brw->intel.NewGLState;
brw->intel.NewGLState = 0;
if (brw->emit_state_always) {
state->mesa |= ~0;
state->brw |= ~0;
state->cache |= ~0;
}
if (brw->fragment_program != ctx->FragmentProgram._Current) {
brw->fragment_program = ctx->FragmentProgram._Current;
brw->state.dirty.brw |= BRW_NEW_FRAGMENT_PROGRAM;
}
if (brw->vertex_program != ctx->VertexProgram._Current) {
brw->vertex_program = ctx->VertexProgram._Current;
brw->state.dirty.brw |= BRW_NEW_VERTEX_PROGRAM;
}
if ((state->mesa | state->cache | state->brw) == 0)
return;
brw->intel.Fallback = false; /* boolean, not bitfield */
intel_check_front_buffer_rendering(intel);
if (unlikely(INTEL_DEBUG)) {
/* Debug version which enforces various sanity checks on the
* state flags which are generated and checked to help ensure
* state atoms are ordered correctly in the list.
*/
struct brw_state_flags examined, prev;
memset(&examined, 0, sizeof(examined));
prev = *state;
for (i = 0; i < brw->num_atoms; i++) {
const struct brw_tracked_state *atom = brw->atoms[i];
struct brw_state_flags generated;
if (brw->intel.Fallback)
break;
if (check_state(state, &atom->dirty)) {
atom->emit(brw);
}
accumulate_state(&examined, &atom->dirty);
/* generated = (prev ^ state)
* if (examined & generated)
* fail;
*/
xor_states(&generated, &prev, state);
assert(!check_state(&examined, &generated));
prev = *state;
}
}
else {
for (i = 0; i < brw->num_atoms; i++) {
const struct brw_tracked_state *atom = brw->atoms[i];
if (brw->intel.Fallback)
break;
if (check_state(state, &atom->dirty)) {
atom->emit(brw);
}
}
}
if (unlikely(INTEL_DEBUG & DEBUG_STATE)) {
brw_update_dirty_count(mesa_bits, state->mesa);
brw_update_dirty_count(brw_bits, state->brw);
brw_update_dirty_count(cache_bits, state->cache);
if (dirty_count++ % 1000 == 0) {
brw_print_dirty_count(mesa_bits, state->mesa);
brw_print_dirty_count(brw_bits, state->brw);
brw_print_dirty_count(cache_bits, state->cache);
fprintf(stderr, "\n");
}
}
if (!brw->intel.Fallback)
memset(state, 0, sizeof(*state));
}
void
tex_task1(TEXPTN texptn, intptr_t exinf)
{
ER ercd;
switch (texptn) {
case 0x0001:
check_point(4);
check_state(false, false, TIPM_ENAALL, false, false, true);
/*
* dispatch disabled, ipm changed, task exception enabled
*/
check_point(5);
ercd = dis_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = ena_tex();
check_ercd(ercd, E_OK);
ercd = loc_cpu();
check_ercd(ercd, E_OK);
check_state(false, true, TMAX_INTPRI, true, true, false);
break;
case 0x0002:
check_point(10);
check_state(false, false, TIPM_ENAALL, true, true, true);
/*
* raise task exception request
*/
check_point(11);
ercd = ras_tex(TSK_SELF, 0x0001);
check_ercd(ercd, E_OK);
ercd = ras_tex(TSK_SELF, 0x0002);
check_ercd(ercd, E_OK);
/*
* dispatch enabled, ipm changed, cpu locked
*/
check_point(12);
ercd = ena_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = loc_cpu();
check_ercd(ercd, E_OK);
check_state(false, true, TMAX_INTPRI, false, true, true);
break;
case 0x0003:
check_point(13);
check_state(false, false, TIPM_ENAALL, true, true, true);
/*
* dispatch enabled, ipm changed, task exception enabled
*/
check_point(14);
ercd = ena_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = ena_tex();
check_ercd(ercd, E_OK);
check_state(false, false, TMAX_INTPRI, false, true, false);
ercd = chg_ipm(TIPM_ENAALL);
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
/*
* raise task exception request
*/
check_point(15);
ercd = ras_tex(TSK_SELF, 0x0004);
ercd = dis_tex();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TIPM_ENAALL);
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = ena_tex();
check_ercd(ercd, E_OK);
check_point(16);
ercd = chg_ipm(TIPM_ENAALL);
/* task exception routine runs here */
check_ercd(ercd, E_OK);
/*
* check the state when task exception routine returns
*/
check_point(19);
check_state(false, false, TIPM_ENAALL, false, false, false);
break;
case 0x0004:
check_point(17);
check_state(false, false, TIPM_ENAALL, false, false, true);
/*
* dispatch disabled, ipm changed, cpu locked
*/
check_point(18);
ercd = dis_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = loc_cpu();
check_ercd(ercd, E_OK);
check_state(false, true, TMAX_INTPRI, true, true, true);
break;
default:
check_point(0);
break;
}
}
void
Node::print(FILE* out) const {
fprintf(out, "(%d, %d - %d)\t", pos.x, pos.y, pos.level);
fprintf(out, "%.1lf = %.1lf + %.1lf\t", f, g, h);
fprintf(out, "%d %d %d %d %d\n", check_state(GOAL), check_state(START), check_state(WAITING), check_state(FRINGE), check_state(CLOSED));
}
void
task1(intptr_t exinf)
{
ER ercd;
T_RTEX rtex;
/*
* check init state
*/
check_point(1);
check_state(false, false, TIPM_ENAALL, false, false, true);
ercd = ref_tex(TSK_SELF, &rtex);
check_ercd(ercd, E_OK);
check_assert((rtex.texstat & TTEX_DIS) != 0);
check_assert(rtex.pndptn == 0);
/*
* error check of ras_tex
*/
ercd = ras_tex(TASK3, 0x0001);
check_ercd(ercd, E_OBJ);
ercd = ras_tex(TASK4, 0x0001);
check_ercd(ercd, E_OBJ);
/*
* error check of ref_tex
*/
ercd = ref_tex(TASK3, &rtex);
check_ercd(ercd, E_OBJ);
ercd = ref_tex(TASK4, &rtex);
check_ercd(ercd, E_OBJ);
/*
* enable task exception
*/
check_point(2);
ercd = ena_tex();
check_ercd(ercd, E_OK);
check_state(false, false, TIPM_ENAALL, false, false, false);
ercd = ref_tex(TSK_SELF, &rtex);
check_ercd(ercd, E_OK);
check_assert((rtex.texstat & TTEX_ENA) != 0);
check_assert(rtex.pndptn == 0);
/*
* raise task exception request
*/
check_point(3);
ercd = ras_tex(TSK_SELF, 0x0001);
/* task exception routine runs here */
check_ercd(ercd, E_OK);
/*
* check the state when task exception routine returns
*/
check_point(6);
check_state(false, false, TIPM_ENAALL, false, false, false);
/*
* dispatch disabled, task exception disabled
*/
check_point(7);
ercd = dis_dsp();
check_ercd(ercd, E_OK);
ercd = dis_tex();
check_ercd(ercd, E_OK);
check_state(false, false, TIPM_ENAALL, true, true, true);
/*
* raise task exception request
*/
check_point(8);
ercd = ras_tex(TASK1, 0x0002);
check_ercd(ercd, E_OK);
ercd = ref_tex(TSK_SELF, &rtex);
check_ercd(ercd, E_OK);
check_assert((rtex.texstat & TTEX_DIS) != 0);
check_assert(rtex.pndptn == 0x0002);
/*
* enable task exception
*/
check_point(9);
ercd = ena_tex();
/* task exception routine runs here */
check_ercd(ercd, E_OK);
/*
* check the state when task exception routine returns
*/
check_point(20);
check_state(false, false, TIPM_ENAALL, true, true, false);
/*
* switch task2
*/
check_point(21);
ercd = ena_dsp();
check_ercd(ercd, E_OK);
ercd = rot_rdq(TPRI_SELF);
/* other tasks run here */
check_ercd(ercd, E_OK);
/*
* raise the task exception of task2
*/
check_point(27);
ercd = ras_tex(TASK2, 0x0001);
check_ercd(ercd, E_OK);
ercd = ref_tex(TASK2, &rtex);
check_ercd(ercd, E_OK);
check_assert((rtex.texstat & TTEX_ENA) != 0);
check_assert(rtex.pndptn == 0x0001);
/*
* switch to task2
*/
check_point(28);
ercd = rot_rdq(TPRI_SELF);
/* other tasks run here */
check_ercd(ercd, E_OK);
/*
* task exits
*/
check_point(34);
}
static enum pipe_error
update_state(struct svga_context *svga,
const struct svga_tracked_state *atoms[],
unsigned *state)
{
#ifdef DEBUG
boolean debug = TRUE;
#else
boolean debug = FALSE;
#endif
enum pipe_error ret = PIPE_OK;
unsigned i;
ret = svga_hwtnl_flush( svga->hwtnl );
if (ret != PIPE_OK)
return ret;
if (debug) {
/* Debug version which enforces various sanity checks on the
* state flags which are generated and checked to help ensure
* state atoms are ordered correctly in the list.
*/
unsigned examined, prev;
examined = 0;
prev = *state;
for (i = 0; atoms[i] != NULL; i++) {
unsigned generated;
assert(atoms[i]->dirty);
assert(atoms[i]->update);
if (check_state(*state, atoms[i]->dirty)) {
if (0)
debug_printf("update: %s\n", atoms[i]->name);
ret = atoms[i]->update( svga, *state );
if (ret != PIPE_OK)
return ret;
}
/* generated = (prev ^ state)
* if (examined & generated)
* fail;
*/
xor_states(&generated, prev, *state);
if (check_state(examined, generated)) {
debug_printf("state atom %s generated state already examined\n",
atoms[i]->name);
assert(0);
}
prev = *state;
accumulate_state(&examined, atoms[i]->dirty);
}
}
else {
for (i = 0; atoms[i] != NULL; i++) {
if (check_state(*state, atoms[i]->dirty)) {
ret = atoms[i]->update( svga, *state );
if (ret != PIPE_OK)
return ret;
}
}
}
return PIPE_OK;
}
/***********************************************************************
* Emit all state:
*/
void brw_upload_state(struct brw_context *brw)
{
struct gl_context *ctx = &brw->ctx;
struct brw_state_flags *state = &brw->state.dirty;
int i;
static int dirty_count = 0;
state->mesa |= brw->NewGLState;
brw->NewGLState = 0;
state->brw |= ctx->NewDriverState;
ctx->NewDriverState = 0;
if (0) {
/* Always re-emit all state. */
state->mesa |= ~0;
state->brw |= ~0ull;
}
if (brw->fragment_program != ctx->FragmentProgram._Current) {
brw->fragment_program = ctx->FragmentProgram._Current;
brw->state.dirty.brw |= BRW_NEW_FRAGMENT_PROGRAM;
}
if (brw->geometry_program != ctx->GeometryProgram._Current) {
brw->geometry_program = ctx->GeometryProgram._Current;
brw->state.dirty.brw |= BRW_NEW_GEOMETRY_PROGRAM;
}
if (brw->vertex_program != ctx->VertexProgram._Current) {
brw->vertex_program = ctx->VertexProgram._Current;
brw->state.dirty.brw |= BRW_NEW_VERTEX_PROGRAM;
}
if (brw->meta_in_progress != _mesa_meta_in_progress(ctx)) {
brw->meta_in_progress = _mesa_meta_in_progress(ctx);
brw->state.dirty.brw |= BRW_NEW_META_IN_PROGRESS;
}
if (brw->num_samples != ctx->DrawBuffer->Visual.samples) {
brw->num_samples = ctx->DrawBuffer->Visual.samples;
brw->state.dirty.brw |= BRW_NEW_NUM_SAMPLES;
}
if ((state->mesa | state->brw) == 0)
return;
if (unlikely(INTEL_DEBUG)) {
/* Debug version which enforces various sanity checks on the
* state flags which are generated and checked to help ensure
* state atoms are ordered correctly in the list.
*/
struct brw_state_flags examined, prev;
memset(&examined, 0, sizeof(examined));
prev = *state;
for (i = 0; i < brw->num_atoms; i++) {
const struct brw_tracked_state *atom = brw->atoms[i];
struct brw_state_flags generated;
if (check_state(state, &atom->dirty)) {
atom->emit(brw);
}
accumulate_state(&examined, &atom->dirty);
/* generated = (prev ^ state)
* if (examined & generated)
* fail;
*/
xor_states(&generated, &prev, state);
assert(!check_state(&examined, &generated));
prev = *state;
}
}
else {
for (i = 0; i < brw->num_atoms; i++) {
const struct brw_tracked_state *atom = brw->atoms[i];
if (check_state(state, &atom->dirty)) {
atom->emit(brw);
}
}
}
if (unlikely(INTEL_DEBUG & DEBUG_STATE)) {
STATIC_ASSERT(ARRAY_SIZE(brw_bits) == BRW_NUM_STATE_BITS + 1);
brw_update_dirty_count(mesa_bits, state->mesa);
brw_update_dirty_count(brw_bits, state->brw);
if (dirty_count++ % 1000 == 0) {
brw_print_dirty_count(mesa_bits);
brw_print_dirty_count(brw_bits);
fprintf(stderr, "\n");
}
}
}
/* inputs going to ISP1301 */
static void otg_update_isp(struct isp1301 *isp)
{
u32 otg_ctrl, otg_change;
u8 set = OTG1_DM_PULLDOWN, clr = OTG1_DM_PULLUP;
otg_ctrl = OTG_CTRL_REG;
otg_change = otg_ctrl ^ isp->last_otg_ctrl;
isp->last_otg_ctrl = otg_ctrl;
otg_ctrl = otg_ctrl & OTG_XCEIV_INPUTS;
switch (isp->otg.state) {
case OTG_STATE_B_IDLE:
case OTG_STATE_B_PERIPHERAL:
case OTG_STATE_B_SRP_INIT:
if (!(otg_ctrl & OTG_PULLUP)) {
// if (otg_ctrl & OTG_B_HNPEN) {
if (isp->otg.gadget->b_hnp_enable) {
isp->otg.state = OTG_STATE_B_WAIT_ACON;
pr_debug(" --> b_wait_acon\n");
}
goto pulldown;
}
pullup:
set |= OTG1_DP_PULLUP;
clr |= OTG1_DP_PULLDOWN;
break;
case OTG_STATE_A_SUSPEND:
case OTG_STATE_A_PERIPHERAL:
if (otg_ctrl & OTG_PULLUP)
goto pullup;
/* FALLTHROUGH */
// case OTG_STATE_B_WAIT_ACON:
default:
pulldown:
set |= OTG1_DP_PULLDOWN;
clr |= OTG1_DP_PULLUP;
break;
}
# define toggle(OTG,ISP) do { \
if (otg_ctrl & OTG) set |= ISP; \
else clr |= ISP; \
} while (0)
if (!(isp->otg.host))
otg_ctrl &= ~OTG_DRV_VBUS;
switch (isp->otg.state) {
case OTG_STATE_A_SUSPEND:
if (otg_ctrl & OTG_DRV_VBUS) {
set |= OTG1_VBUS_DRV;
break;
}
/* HNP failed for some reason (A_AIDL_BDIS timeout) */
notresponding(isp);
/* FALLTHROUGH */
case OTG_STATE_A_VBUS_ERR:
isp->otg.state = OTG_STATE_A_WAIT_VFALL;
pr_debug(" --> a_wait_vfall\n");
/* FALLTHROUGH */
case OTG_STATE_A_WAIT_VFALL:
/* FIXME usbcore thinks port power is still on ... */
clr |= OTG1_VBUS_DRV;
break;
case OTG_STATE_A_IDLE:
if (otg_ctrl & OTG_DRV_VBUS) {
isp->otg.state = OTG_STATE_A_WAIT_VRISE;
pr_debug(" --> a_wait_vrise\n");
}
/* FALLTHROUGH */
default:
toggle(OTG_DRV_VBUS, OTG1_VBUS_DRV);
}
toggle(OTG_PU_VBUS, OTG1_VBUS_CHRG);
toggle(OTG_PD_VBUS, OTG1_VBUS_DISCHRG);
# undef toggle
isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, set);
isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, clr);
/* HNP switch to host or peripheral; and SRP */
if (otg_change & OTG_PULLUP) {
switch (isp->otg.state) {
case OTG_STATE_B_IDLE:
if (clr & OTG1_DP_PULLUP)
break;
isp->otg.state = OTG_STATE_B_PERIPHERAL;
pr_debug(" --> b_peripheral\n");
break;
case OTG_STATE_A_SUSPEND:
if (clr & OTG1_DP_PULLUP)
break;
isp->otg.state = OTG_STATE_A_PERIPHERAL;
pr_debug(" --> a_peripheral\n");
break;
default:
break;
}
OTG_CTRL_REG |= OTG_PULLUP;
}
check_state(isp, __func__);
dump_regs(isp, "otg->isp1301");
}
void
on_Finish_clicked(GtkButton *button, gpointer user_data)
{
if ( table[cur_pid].page.curr) {
char *cmd, *name, buf[3];
int i, size;
if (table[cur_pid].process != NULL ) {
sprintf(buf, "%d", cur_pid); /* Put this up here: fix */
name = xmlGetProp(table[cur_pid].page.curr, "name");
size = strlen(exec_path) + strlen(" -n ") + sizeof(cur_pid)
+ strlen(buf) + strlen(" ") + strlen(name) + strlen(" finish ") + 1;
cmd = (char *) malloc (size);
strcpy (cmd, exec_path);
strcat (cmd, " -n ");
strcat (cmd, buf);
strcat (cmd, " ");
strcat (cmd, name);
strcat (cmd, " finish ");
runPeos(cmd);
free(cmd);
cmd = NULL;
}
freeAll_extra();
if (table[cur_pid].process != NULL ) {
draw_tree (cur_pid);
/* search through actions and find the current page */
for ( i = 0; i < counting_action; i++) {
if (strcmp (linklist[cur_pid][i].cur->name, "action") == 0) {
if (strcmp (xmlGetProp (linklist[cur_pid][i].cur, "name"), name) == 0) {
table[cur_pid].page.curr = linklist[cur_pid][i].cur;
break;
}
}
}
draw_text(table[cur_pid].page.curr);
if((GTK_IS_WIDGET (table[cur_pid].page.tree1) && GTK_IS_TREE (GTK_TREE (table[cur_pid].page.tree1))))
gtk_tree_select_child ( GTK_TREE (table[cur_pid].page.tree1),
linklist[cur_pid][table[cur_pid].page.index].item);
check_state();
} else {
table[cur_pid].page.index = 0;
gtk_widget_destroy (notebook);
notebook = create_notebook();
gtk_widget_set_name (notebook, "notebook");
gtk_widget_ref (notebook);
gtk_object_set_data_full (GTK_OBJECT (Peos), "notebook", notebook,
(GtkDestroyNotify) gtk_widget_unref);
set_selection(1); /* with current action selected */
gtk_widget_show (notebook);
gtk_container_add (GTK_CONTAINER (vbox), notebook);
for (i = 0; i < MAX_PID; i++) {
if (table[i].process != NULL)
cur_pid = i;
}
}
redisplay_menu();
}
}
static irqreturn_t omap_otg_irq(int irq, void *_isp)
{
u16 otg_irq = OTG_IRQ_SRC_REG;
u32 otg_ctrl;
int ret = IRQ_NONE;
struct isp1301 *isp = _isp;
/* update ISP1301 transciever from OTG controller */
if (otg_irq & OPRT_CHG) {
OTG_IRQ_SRC_REG = OPRT_CHG;
isp1301_defer_work(isp, WORK_UPDATE_ISP);
ret = IRQ_HANDLED;
/* SRP to become b_peripheral failed */
} else if (otg_irq & B_SRP_TMROUT) {
pr_debug("otg: B_SRP_TIMEOUT, %06x\n", OTG_CTRL_REG);
notresponding(isp);
/* gadget drivers that care should monitor all kinds of
* remote wakeup (SRP, normal) using their own timer
* to give "check cable and A-device" messages.
*/
if (isp->otg.state == OTG_STATE_B_SRP_INIT)
b_idle(isp, "srp_timeout");
OTG_IRQ_SRC_REG = B_SRP_TMROUT;
ret = IRQ_HANDLED;
/* HNP to become b_host failed */
} else if (otg_irq & B_HNP_FAIL) {
pr_debug("otg: %s B_HNP_FAIL, %06x\n",
state_name(isp), OTG_CTRL_REG);
notresponding(isp);
otg_ctrl = OTG_CTRL_REG;
otg_ctrl |= OTG_BUSDROP;
otg_ctrl &= OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
OTG_CTRL_REG = otg_ctrl;
/* subset of b_peripheral()... */
isp->otg.state = OTG_STATE_B_PERIPHERAL;
pr_debug(" --> b_peripheral\n");
OTG_IRQ_SRC_REG = B_HNP_FAIL;
ret = IRQ_HANDLED;
/* detect SRP from B-device ... */
} else if (otg_irq & A_SRP_DETECT) {
pr_debug("otg: %s SRP_DETECT, %06x\n",
state_name(isp), OTG_CTRL_REG);
isp1301_defer_work(isp, WORK_UPDATE_OTG);
switch (isp->otg.state) {
case OTG_STATE_A_IDLE:
if (!isp->otg.host)
break;
isp1301_defer_work(isp, WORK_HOST_RESUME);
otg_ctrl = OTG_CTRL_REG;
otg_ctrl |= OTG_A_BUSREQ;
otg_ctrl &= ~(OTG_BUSDROP|OTG_B_BUSREQ)
& ~OTG_XCEIV_INPUTS
& OTG_CTRL_MASK;
OTG_CTRL_REG = otg_ctrl;
break;
default:
break;
}
OTG_IRQ_SRC_REG = A_SRP_DETECT;
ret = IRQ_HANDLED;
/* timer expired: T(a_wait_bcon) and maybe T(a_wait_vrise)
* we don't track them separately
*/
} else if (otg_irq & A_REQ_TMROUT) {
otg_ctrl = OTG_CTRL_REG;
pr_info("otg: BCON_TMOUT from %s, %06x\n",
state_name(isp), otg_ctrl);
notresponding(isp);
otg_ctrl |= OTG_BUSDROP;
otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
OTG_CTRL_REG = otg_ctrl;
isp->otg.state = OTG_STATE_A_WAIT_VFALL;
OTG_IRQ_SRC_REG = A_REQ_TMROUT;
ret = IRQ_HANDLED;
/* A-supplied voltage fell too low; overcurrent */
} else if (otg_irq & A_VBUS_ERR) {
otg_ctrl = OTG_CTRL_REG;
printk(KERN_ERR "otg: %s, VBUS_ERR %04x ctrl %06x\n",
state_name(isp), otg_irq, otg_ctrl);
otg_ctrl |= OTG_BUSDROP;
otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
OTG_CTRL_REG = otg_ctrl;
isp->otg.state = OTG_STATE_A_VBUS_ERR;
OTG_IRQ_SRC_REG = A_VBUS_ERR;
ret = IRQ_HANDLED;
/* switch driver; the transciever code activates it,
* ungating the udc clock or resuming OHCI.
*/
} else if (otg_irq & DRIVER_SWITCH) {
int kick = 0;
otg_ctrl = OTG_CTRL_REG;
printk(KERN_NOTICE "otg: %s, SWITCH to %s, ctrl %06x\n",
state_name(isp),
(otg_ctrl & OTG_DRIVER_SEL)
? "gadget" : "host",
otg_ctrl);
isp1301_defer_work(isp, WORK_UPDATE_ISP);
/* role is peripheral */
if (otg_ctrl & OTG_DRIVER_SEL) {
switch (isp->otg.state) {
case OTG_STATE_A_IDLE:
b_idle(isp, __func__);
break;
default:
break;
}
isp1301_defer_work(isp, WORK_UPDATE_ISP);
/* role is host */
} else {
if (!(otg_ctrl & OTG_ID)) {
otg_ctrl &= OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
OTG_CTRL_REG = otg_ctrl | OTG_A_BUSREQ;
}
if (isp->otg.host) {
switch (isp->otg.state) {
case OTG_STATE_B_WAIT_ACON:
isp->otg.state = OTG_STATE_B_HOST;
pr_debug(" --> b_host\n");
kick = 1;
break;
case OTG_STATE_A_WAIT_BCON:
isp->otg.state = OTG_STATE_A_HOST;
pr_debug(" --> a_host\n");
break;
case OTG_STATE_A_PERIPHERAL:
isp->otg.state = OTG_STATE_A_WAIT_BCON;
pr_debug(" --> a_wait_bcon\n");
break;
default:
break;
}
isp1301_defer_work(isp, WORK_HOST_RESUME);
}
}
OTG_IRQ_SRC_REG = DRIVER_SWITCH;
ret = IRQ_HANDLED;
if (kick)
usb_bus_start_enum(isp->otg.host,
isp->otg.host->otg_port);
}
check_state(isp, __func__);
return ret;
}
void
on_Start_clicked(GtkButton *menuitem, gpointer user_data)
{
char *cmd = NULL, buf[3], *name = NULL, *res_qual = NULL, *res_val = NULL;
int i, size = 0;
static GtkWidget *input_dialog = NULL;
xmlNode *cur = NULL;
for ( cur = table[cur_pid].page.curr->children; cur;cur = cur->next) {
if (cur->name &&
xmlStrcmp(cur->name, (const xmlChar*) "req_resource" ) == 0 ) {
res_qual = xmlGetProp(cur, "qualifier");
res_val = xmlGetProp(cur, "value");
res_name = NULL;
res_name = xmlGetProp(cur, "name");
if ( strcmp (res_val,"$$") == 0) {
if ( strcmp ( res_qual, "abstract") != 0) {
if (!input_dialog) {
input_dialog = create_inputdialog((gchar *) res_name);
gtk_widget_show (input_dialog);
deactivate();
gtk_signal_connect (GTK_OBJECT(input_dialog), "destroy",
(GtkSignalFunc) dialog_destroy, &input_dialog);
} else {
if (!GTK_WIDGET_MAPPED (input_dialog))
gtk_widget_show(input_dialog);
else
gdk_window_raise(input_dialog->window);
}
}
} else if ( strcmp (res_qual, "new") == 0) {
if (!input_dialog) {
input_dialog = create_inputdialog((gchar *)res_name);
gtk_widget_show (input_dialog);
deactivate();
gtk_signal_connect (GTK_OBJECT(input_dialog), "destroy",
(GtkSignalFunc) dialog_destroy, &input_dialog);
} else {
if (!GTK_WIDGET_MAPPED (input_dialog))
gtk_widget_show(input_dialog);
else
gdk_window_raise(input_dialog->window);
}
} else if (strcmp (res_val,"$$") != 0){
name = xmlGetProp (table[cur_pid].page.curr, "name");
sprintf(buf, "%d", cur_pid);
size = strlen(exec_path) + strlen(" -n ") + strlen(buf) + strlen(" ") + strlen(name)
+ strlen(" start ") + 1;
cmd = (char *) malloc(size*sizeof(char ));
size = 0;
strcpy (cmd, exec_path);
strcat (cmd, " -n ");
strcat (cmd, buf);
strcat (cmd, " ");
strcat (cmd, name);
strcat (cmd, " start ");
runPeos(cmd);
free(cmd);
cmd = NULL;
freeAll_extra();
draw_tree (cur_pid);
for ( i = 0; i < counting_action; i++) {
if (strcmp (linklist[cur_pid][i].cur->name, "action") == 0) {
if (strcmp (xmlGetProp (linklist[cur_pid][i].cur, "name"), name) == 0) {
table[cur_pid].page.curr = linklist[cur_pid][i].cur;
break;
}
}
}
if((GTK_IS_WIDGET (table[cur_pid].page.tree1) && GTK_IS_TREE (GTK_TREE (table[cur_pid].page.tree1))))
gtk_tree_select_child ( GTK_TREE (table[cur_pid].page.tree1), linklist[cur_pid][i].item);
draw_text(table[cur_pid].page.curr);
check_state();
return;
}
}
}
}
static void isp_update_otg(struct isp1301 *isp, u8 stat)
{
u8 isp_stat, isp_bstat;
enum usb_otg_state state = isp->otg.state;
if (stat & INTR_BDIS_ACON)
pr_debug("OTG: BDIS_ACON, %s\n", state_name(isp));
/* start certain state transitions right away */
isp_stat = isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE);
if (isp_stat & INTR_ID_GND) {
if (isp->otg.default_a) {
switch (state) {
case OTG_STATE_B_IDLE:
a_idle(isp, "idle");
/* FALLTHROUGH */
case OTG_STATE_A_IDLE:
enable_vbus_source(isp);
/* FALLTHROUGH */
case OTG_STATE_A_WAIT_VRISE:
/* we skip over OTG_STATE_A_WAIT_BCON, since
* the HC will transition to A_HOST (or
* A_SUSPEND!) without our noticing except
* when HNP is used.
*/
if (isp_stat & INTR_VBUS_VLD)
isp->otg.state = OTG_STATE_A_HOST;
break;
case OTG_STATE_A_WAIT_VFALL:
if (!(isp_stat & INTR_SESS_VLD))
a_idle(isp, "vfell");
break;
default:
if (!(isp_stat & INTR_VBUS_VLD))
isp->otg.state = OTG_STATE_A_VBUS_ERR;
break;
}
isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
} else {
switch (state) {
case OTG_STATE_B_PERIPHERAL:
case OTG_STATE_B_HOST:
case OTG_STATE_B_WAIT_ACON:
usb_gadget_vbus_disconnect(isp->otg.gadget);
break;
default:
break;
}
if (state != OTG_STATE_A_IDLE)
a_idle(isp, "id");
if (isp->otg.host && state == OTG_STATE_A_IDLE)
isp1301_defer_work(isp, WORK_HOST_RESUME);
isp_bstat = 0;
}
} else {
/* if user unplugged mini-A end of cable,
* don't bypass A_WAIT_VFALL.
*/
if (isp->otg.default_a) {
switch (state) {
default:
isp->otg.state = OTG_STATE_A_WAIT_VFALL;
break;
case OTG_STATE_A_WAIT_VFALL:
state = OTG_STATE_A_IDLE;
/* khubd may take a while to notice and
* handle this disconnect, so don't go
* to B_IDLE quite yet.
*/
break;
case OTG_STATE_A_IDLE:
host_suspend(isp);
isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1,
MC1_BDIS_ACON_EN);
isp->otg.state = OTG_STATE_B_IDLE;
OTG_CTRL_REG &= OTG_CTRL_REG & OTG_CTRL_MASK
& ~OTG_CTRL_BITS;
break;
case OTG_STATE_B_IDLE:
break;
}
}
isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
switch (isp->otg.state) {
case OTG_STATE_B_PERIPHERAL:
case OTG_STATE_B_WAIT_ACON:
case OTG_STATE_B_HOST:
if (likely(isp_bstat & OTG_B_SESS_VLD))
break;
enable_vbus_draw(isp, 0);
#ifndef CONFIG_USB_OTG
/* UDC driver will clear OTG_BSESSVLD */
isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1,
OTG1_DP_PULLDOWN);
isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1,
OTG1_DP_PULLUP);
dump_regs(isp, __func__);
#endif
/* FALLTHROUGH */
case OTG_STATE_B_SRP_INIT:
b_idle(isp, __func__);
OTG_CTRL_REG &= OTG_CTRL_REG & OTG_XCEIV_OUTPUTS;
/* FALLTHROUGH */
case OTG_STATE_B_IDLE:
if (isp->otg.gadget && (isp_bstat & OTG_B_SESS_VLD)) {
#ifdef CONFIG_USB_OTG
update_otg1(isp, isp_stat);
update_otg2(isp, isp_bstat);
#endif
b_peripheral(isp);
} else if (!(isp_stat & (INTR_VBUS_VLD|INTR_SESS_VLD)))
isp_bstat |= OTG_B_SESS_END;
break;
case OTG_STATE_A_WAIT_VFALL:
break;
default:
pr_debug("otg: unsupported b-device %s\n",
state_name(isp));
break;
}
}
if (state != isp->otg.state)
pr_debug(" isp, %s -> %s\n",
state_string(state), state_name(isp));
#ifdef CONFIG_USB_OTG
/* update the OTG controller state to match the isp1301; may
* trigger OPRT_CHG irqs for changes going to the isp1301.
*/
update_otg1(isp, isp_stat);
update_otg2(isp, isp_bstat);
check_state(isp, __func__);
#endif
dump_regs(isp, "isp1301->otg");
}
////////////////////////////////////////////////////////////////////////////////
// basic test of the cache's base functionality:
// push, pop, set, canReuse & getters
static void test_cache(skiatest::Reporter* reporter, GrContext* context) {
if (false) { // avoid bit rot, suppress warning
createTexture(context);
}
GrClipMaskCache cache;
cache.setContext(context);
SkClipStack emptyClip;
emptyClip.reset();
GrIRect emptyBound;
emptyBound.setEmpty();
// check initial state
check_state(reporter, cache, emptyClip, NULL, emptyBound);
// set the current state
GrIRect bound1;
bound1.set(0, 0, 100, 100);
SkClipStack clip1(bound1);
GrTextureDesc desc;
desc.fFlags = kRenderTarget_GrTextureFlagBit;
desc.fWidth = X_SIZE;
desc.fHeight = Y_SIZE;
desc.fConfig = kSkia8888_PM_GrPixelConfig;
cache.acquireMask(clip1, desc, bound1);
GrTexture* texture1 = cache.getLastMask();
REPORTER_ASSERT(reporter, texture1);
if (NULL == texture1) {
return;
}
// check that the set took
check_state(reporter, cache, clip1, texture1, bound1);
REPORTER_ASSERT(reporter, 1 == texture1->getRefCnt());
// push the state
cache.push();
// verify that the pushed state is initially empty
check_state(reporter, cache, emptyClip, NULL, emptyBound);
REPORTER_ASSERT(reporter, 1 == texture1->getRefCnt());
// modify the new state
GrIRect bound2;
bound2.set(-10, -10, 10, 10);
SkClipStack clip2(bound2);
cache.acquireMask(clip2, desc, bound2);
GrTexture* texture2 = cache.getLastMask();
REPORTER_ASSERT(reporter, texture2);
if (NULL == texture2) {
return;
}
// check that the changes took
check_state(reporter, cache, clip2, texture2, bound2);
REPORTER_ASSERT(reporter, 1 == texture1->getRefCnt());
REPORTER_ASSERT(reporter, 1 == texture2->getRefCnt());
// check to make sure canReuse works
REPORTER_ASSERT(reporter, cache.canReuse(clip2, bound2));
REPORTER_ASSERT(reporter, !cache.canReuse(clip1, bound1));
// pop the state
cache.pop();
// verify that the old state is restored
check_state(reporter, cache, clip1, texture1, bound1);
REPORTER_ASSERT(reporter, 1 == texture1->getRefCnt());
REPORTER_ASSERT(reporter, 1 == texture2->getRefCnt());
// manually clear the state
cache.reset();
// verify it is now empty
check_state(reporter, cache, emptyClip, NULL, emptyBound);
REPORTER_ASSERT(reporter, 1 == texture1->getRefCnt());
REPORTER_ASSERT(reporter, 1 == texture2->getRefCnt());
// pop again - so there is no state
cache.pop();
#if !defined(SK_DEBUG)
// verify that the getters don't crash
// only do in release since it generates asserts in debug
check_state(reporter, cache, emptyClip, NULL, emptyBound);
#endif
REPORTER_ASSERT(reporter, 1 == texture1->getRefCnt());
REPORTER_ASSERT(reporter, 1 == texture2->getRefCnt());
}
/**
* Apply side effects from a spell attack to the player
*
* \param spell is the attack type
* \param dam is the amount of damage caused by the attack
* \param m_idx is the attacking monster
* \param rlev is its level
* \param seen is whether @ can see it
*/
static void do_side_effects(int spell, int dam, int m_idx, bool seen)
{
monster_type *m_ptr = cave_monster(cave, m_idx);
monster_race *r_ptr = &r_info[m_ptr->r_idx];
const struct spell_effect *re_ptr;
const struct mon_spell *rs_ptr = &mon_spell_table[spell];
int i, choice[99], dur = 0, j = 0, count = 0;
s32b d = 0;
bool sustain = FALSE, perma = FALSE, chosen[RSE_MAX] = { 0 };
/* Extract the monster level */
int rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
/* First we note all the effects we'll be doing. */
for (re_ptr = spell_effect_table; re_ptr->index < RSE_MAX; re_ptr++) {
if ((re_ptr->method && (re_ptr->method == rs_ptr->index)) ||
(re_ptr->gf && (re_ptr->gf == rs_ptr->gf))) {
/* If we have a choice of effects, we create a cum freq table */
if (re_ptr->chance) {
for (i = j; i < (j + re_ptr->chance); i++)
choice[i] = re_ptr->index;
j = i;
}
else
chosen[re_ptr->index] = TRUE;
}
}
/* If we have built a cum freq table, choose an effect from it */
if (j)
chosen[choice[randint0(j)]] = TRUE;
/* Now we cycle through again to activate the chosen effects */
for (re_ptr = spell_effect_table; re_ptr->index < RSE_MAX; re_ptr++) {
if (chosen[re_ptr->index]) {
/*
* Check for resistance - there are three possibilities:
* 1. Immunity to the attack type if side_immune is TRUE
* 2. Resistance to the attack type if it affords no immunity
* 3. Resistance to the specific side-effect
*
* TODO - add interesting messages to the RSE_ and GF_ tables
* to replace the generic ones below. (See #1376)
*/
if (re_ptr->res_flag)
update_smart_learn(m_ptr, p_ptr, re_ptr->res_flag);
if ((rs_ptr->gf && check_side_immune(rs_ptr->gf)) ||
check_state(p_ptr, re_ptr->res_flag, p_ptr->state.flags)) {
msg("You resist the effect!");
continue;
}
/* Allow saving throw if available */
if (re_ptr->save &&
randint0(100) < p_ptr->state.skills[SKILL_SAVE]) {
msg("You avoid the effect!");
continue;
}
/* Implement the effect */
if (re_ptr->timed) {
/* Calculate base duration (m_bonus is not used) */
dur = randcalc(re_ptr->base, 0, RANDOMISE);
/* Calculate the damage-dependent duration (m_bonus is
* used as a cap) */
dur += damcalc(re_ptr->dam.dice, re_ptr->dam.sides *
dam / 100, RANDOMISE);
if (re_ptr->dam.m_bonus && (dur > re_ptr->dam.m_bonus))
dur = re_ptr->dam.m_bonus;
/* Apply the effect - we have already checked for resistance */
(void)player_inc_timed(p_ptr, re_ptr->flag, dur, TRUE, FALSE);
} else {
switch (re_ptr->flag) {
case S_INV_DAM:
if (dam > 0)
inven_damage(p_ptr, re_ptr->gf, MIN(dam *
randcalc(re_ptr->dam, 0, RANDOMISE), 300));
break;
case S_TELEPORT: /* m_bonus is used as a clev filter */
if (!re_ptr->dam.m_bonus ||
randint1(re_ptr->dam.m_bonus) > p_ptr->lev)
teleport_player(randcalc(re_ptr->base, 0,
RANDOMISE));
break;
case S_TELE_TO:
teleport_player_to(m_ptr->fy, m_ptr->fx);
break;
case S_TELE_LEV:
teleport_player_level();
break;
case S_TELE_SELF:
teleport_away(m_ptr, randcalc(re_ptr->base, 0,
RANDOMISE));
break;
case S_DRAIN_LIFE:
d = re_ptr->base.base + (p_ptr->exp *
re_ptr->base.sides / 100) * MON_DRAIN_LIFE;
msg("You feel your life force draining away!");
player_exp_lose(p_ptr, d, FALSE);
break;
case S_DRAIN_STAT: /* m_bonus is used as a flag */
if (re_ptr->dam.m_bonus > 0)
sustain = TRUE;
if (abs(re_ptr->dam.m_bonus) > 1)
perma = TRUE;
drain_stats(randcalc(re_ptr->base, 0, RANDOMISE),
sustain, perma);
break;
case S_SWAP_STAT:
swap_stats();
break;
case S_DRAIN_ALL:
msg("You're not as powerful as you used to be...");
for (i = 0; i < A_MAX; i++)
player_stat_dec(p_ptr, i, FALSE);
break;
case S_DISEN:
(void)apply_disenchant(0);
break;
case S_DRAIN_MANA:
drain_mana(m_idx, rlev, seen);
break;
case S_HEAL:
heal_self(m_idx, rlev, seen);
break;
case S_DARKEN:
(void)unlight_area(0, 3);
break;
case S_TRAPS:
(void)trap_creation();
break;
case S_AGGRAVATE:
aggravate_monsters(m_idx);
break;
case S_KIN:
summon_kin_type = r_ptr->d_char;
case S_MONSTER: case S_MONSTERS:
case S_SPIDER: case S_HOUND: case S_HYDRA: case S_AINU:
case S_ANIMAL:
case S_DEMON: case S_HI_DEMON:
case S_UNDEAD: case S_HI_UNDEAD: case S_WRAITH:
case S_DRAGON: case S_HI_DRAGON:
case S_UNIQUE:
count = summon_monster_aux(re_ptr->flag, m_idx, rlev, re_ptr->base.base);
/* In the special case that uniques or wraiths were summoned but all were dead
S_HI_UNDEAD is used instead */
if ((!count) && ((re_ptr->flag == S_WRAITH) || (re_ptr->flag == S_UNIQUE)))
count = summon_monster_aux(S_HI_UNDEAD, m_idx, rlev, re_ptr->base.base);
if (count && p_ptr->timed[TMD_BLIND])
msgt(rs_ptr->msgt, "You hear %s appear nearby.",
(count > 1 ? "many things" : "something"));
default:
break;
}
}
}
}
return;
}
/*
* Set a timed event (except timed resists, cutting and stunning).
*/
bool player_set_timed(struct player *p, int idx, int v, bool notify)
{
timed_effect *effect;
/* Hack -- Force good values */
v = (v > 10000) ? 10000 : (v < 0) ? 0 : v;
if ((idx < 0) || (idx > TMD_MAX)) return FALSE;
/* No change */
if (p->timed[idx] == v) return FALSE;
/* Hack -- call other functions */
if (idx == TMD_STUN) return set_stun(p, v);
else if (idx == TMD_CUT) return set_cut(p, v);
/* Don't mention effects which already match the player state. */
if (idx == TMD_OPP_ACID && check_state(p, OF_IM_ACID, p->state.flags))
notify = FALSE;
else if (idx == TMD_OPP_ELEC && check_state(p, OF_IM_ELEC, p->state.flags))
notify = FALSE;
else if (idx == TMD_OPP_FIRE && check_state(p, OF_IM_FIRE, p->state.flags))
notify = FALSE;
else if (idx == TMD_OPP_COLD && check_state(p, OF_IM_COLD, p->state.flags))
notify = FALSE;
else if (idx == TMD_OPP_CONF && of_has(p->state.flags, OF_RES_CONFU))
notify = FALSE;
/* Find the effect */
effect = &effects[idx];
/* Turning off, always mention */
if (v == 0)
{
msgt(MSG_RECOVER, "%s", effect->on_end);
notify = TRUE;
}
/* Turning on, always mention */
else if (p->timed[idx] == 0)
{
msgt(effect->msg, "%s", effect->on_begin);
notify = TRUE;
}
else if (notify)
{
/* Decrementing */
if (p->timed[idx] > v && effect->on_decrease)
msgt(effect->msg, "%s", effect->on_decrease);
/* Incrementing */
else if (v > p->timed[idx] && effect->on_increase)
msgt(effect->msg, "%s", effect->on_increase);
}
/* Use the value */
p->timed[idx] = v;
/* Sort out the sprint effect */
if (idx == TMD_SPRINT && v == 0)
player_inc_timed(p, TMD_SLOW, 100, TRUE, FALSE);
/* Nothing to notice */
if (!notify) return FALSE;
/* Disturb */
disturb(p, 0, 0);
/* Update the visuals, as appropriate. */
p->update |= effect->flag_update;
p->redraw |= (PR_STATUS | effect->flag_redraw);
/* Handle stuff */
handle_stuff(p);
/* Result */
return TRUE;
}
void req_quejob(
struct batch_request *preq) /* ptr to the decoded request */
{
char basename[PBS_JOBBASE + 1];
int created_here = 0;
int index;
char *jid;
attribute_def *pdef;
job *pj;
svrattrl *psatl;
int rc;
int sock = preq->rq_conn;
int IsCheckpoint = 0;
/* set basic (user) level access permission */
int resc_access_perm = ATR_DFLAG_USWR | ATR_DFLAG_Creat;
if (PBSNodeCheckProlog)
{
check_state(1);
if (internal_state & INUSE_DOWN)
{
req_reject(PBSE_BADMOMSTATE, 0, preq, NULL, NULL);
return;
}
}
if (reject_job_submit == TRUE)
{
req_reject(-1, 0, preq, NULL, "This mom is configured not to run jobs");
return;
}
if (preq->rq_fromsvr)
{
/* from another server - accept the extra attributes */
resc_access_perm |= ATR_DFLAG_MGWR | ATR_DFLAG_SvWR | ATR_DFLAG_MOM;
jid = preq->rq_ind.rq_queuejob.rq_jid;
}
else
{
/* request must be from server */
log_err(errno, __func__, (char *)"request not from server");
req_reject(PBSE_IVALREQ, 0, preq, NULL, "request not received from server");
return;
}
/* does job already exist, check both old and new jobs */
if ((pj = mom_find_job(jid)) == NULL)
{
pj = (job *)GET_NEXT(svr_newjobs);
while (pj != NULL)
{
if (!strcmp(pj->ji_qs.ji_jobid, jid))
break;
pj = (job *)GET_NEXT(pj->ji_alljobs);
}
}
/*
* New job ...
*
* for MOM - rather than make up a hashname, we use the name sent
* to us by the server as an pbs_attribute.
*/
psatl = (svrattrl *)GET_NEXT(preq->rq_ind.rq_queuejob.rq_attr);
while (psatl != NULL)
{
if (!strcmp(psatl->al_name,ATTR_hashname))
{
snprintf(basename, sizeof(basename), "%s", psatl->al_value);
break;
}
psatl = (svrattrl *)GET_NEXT(psatl->al_link);
}
if (pj != NULL)
{
/* newly queued job already exists */
if (pj->ji_qs.ji_substate == JOB_SUBSTATE_RUNNING)
{
/* FAILURE - job exists and is running */
log_err(errno, __func__, (char *)"cannot queue new job, job exists and is running");
req_reject(PBSE_JOBEXIST, 0, preq, NULL, "job is running");
return;
}
/* if checkpointed, then keep old and skip rest of process */
if (pj->ji_qs.ji_svrflags & JOB_SVFLG_CHECKPOINT_FILE)
{
IsCheckpoint = 1;
} /* END if (pj->ji_qs.ji_svrflags & JOB_SVFLG_CHECKPOINT_FILE) */
else
{
/* unlink job from svr_alljobs since it will be placed on newjobs */
delete_link(&pj->ji_alljobs);
}
} /* END if (pj != NULL) */
else
{
/* if not already here, allocate job struct */
if ((pj = job_alloc()) == NULL)
{
/* FAILURE */
req_reject(PBSE_MEM_MALLOC, 0, preq, NULL, "cannot allocate new job structure");
return;
}
} /* END else (pj != NULL) */
if (IsCheckpoint == 0)
{
strcpy(pj->ji_qs.ji_jobid,jid);
strcpy(pj->ji_qs.ji_fileprefix,basename);
pj->ji_modified = 1;
pj->ji_qs.ji_svrflags = created_here;
pj->ji_qs.ji_un_type = JOB_UNION_TYPE_NEW;
/* changing the union type overwrites the euid for the job, and if
* ji_grpcache is set this potentially allows jobs to run as root. Unsetting
* ji_grpcache fixes this problem --dbeer */
if (pj->ji_grpcache != NULL)
{
free(pj->ji_grpcache);
pj->ji_grpcache = NULL;
}
}
/* decode attributes from request into job structure */
psatl = (svrattrl *)GET_NEXT(preq->rq_ind.rq_queuejob.rq_attr);
while (psatl != NULL)
{
if (IsCheckpoint == 1)
{
if (strcmp(psatl->al_name,ATTR_checkpoint_name) &&
strcmp(psatl->al_name,ATTR_v))
{
psatl = (svrattrl *)GET_NEXT(psatl->al_link);
continue;
}
}
/* identify the pbs_attribute by name */
index = find_attr(job_attr_def,psatl->al_name,JOB_ATR_LAST);
if (index < 0)
{
/* FAILURE */
/* didn`t recognize the name */
mom_job_purge(pj); /* CRI - 12/20/2004 */
reply_badattr(PBSE_NOATTR, 1, psatl, preq);
return;
}
pdef = &job_attr_def[index];
/* Is pbs_attribute not writeable by manager or by a server? */
if ((pdef->at_flags & resc_access_perm) == 0)
{
/* FAILURE */
mom_job_purge(pj);
reply_badattr(PBSE_ATTRRO, 1, psatl, preq);
return;
}
/* decode pbs_attribute */
if (!strcmp(psatl->al_name,ATTR_v))
{
rc = decode_arst_merge(
&pj->ji_wattr[index],
psatl->al_name,
psatl->al_resc,
psatl->al_value);
}
else
{
rc = pdef->at_decode(
&pj->ji_wattr[index],
psatl->al_name,
psatl->al_resc,
psatl->al_value,
resc_access_perm);
}
if (rc != 0)
{
/* FAILURE */
/* all errors are fatal for MOM */
mom_job_purge(pj);
reply_badattr(rc, 1, psatl, preq);
return;
}
if (psatl->al_op == DFLT)
{
if (psatl->al_resc)
{
resource *presc;
resource_def *prdef;
prdef = find_resc_def(svr_resc_def,psatl->al_resc,svr_resc_size);
if (prdef == NULL)
{
mom_job_purge(pj);
reply_badattr(rc, 1, psatl, preq);
return;
}
presc = find_resc_entry(&pj->ji_wattr[index],prdef);
if (presc != NULL)
presc->rs_value.at_flags |= ATR_VFLAG_DEFLT;
}
else
{
pj->ji_wattr[index].at_flags |= ATR_VFLAG_DEFLT;
}
} /* END if (psatl->al_op == DFLT) */
psatl = (svrattrl *)GET_NEXT(psatl->al_link);
} /* END while (psatl != NULL) */
if (IsCheckpoint == 1)
{
pj->ji_qs.ji_substate = JOB_SUBSTATE_TRANSIN;
if (reply_jobid(preq,pj->ji_qs.ji_jobid,BATCH_REPLY_CHOICE_Queue) == 0)
{
delete_link(&pj->ji_alljobs);
append_link(&svr_newjobs,&pj->ji_alljobs,pj);
if (pj->ji_grpcache != NULL)
{
free(pj->ji_grpcache);
pj->ji_grpcache = NULL;
}
pj->ji_qs.ji_un_type = JOB_UNION_TYPE_NEW;
pj->ji_qs.ji_un.ji_newt.ji_fromsock = sock;
pj->ji_qs.ji_un.ji_newt.ji_fromaddr = get_connectaddr(sock,FALSE);
pj->ji_qs.ji_un.ji_newt.ji_scriptsz = 0;
/* Per Eric R., req_mvjobfile was giving error in open_std_file,
showed up as fishy error message */
if (pj->ji_grpcache != NULL)
{
free(pj->ji_grpcache);
pj->ji_grpcache = NULL;
}
}
else
{
close_conn(sock, FALSE);
}
/* SUCCESS */
return;
}
/* set remaining job structure elements */
pj->ji_qs.ji_state = JOB_STATE_TRANSIT;
pj->ji_qs.ji_substate = JOB_SUBSTATE_TRANSIN;
pj->ji_wattr[JOB_ATR_mtime].at_val.at_long = (long)time_now;
pj->ji_wattr[JOB_ATR_mtime].at_flags |= ATR_VFLAG_SET;
if (pj->ji_grpcache != NULL)
{
free(pj->ji_grpcache);
pj->ji_grpcache = NULL;
}
pj->ji_qs.ji_un_type = JOB_UNION_TYPE_NEW;
pj->ji_qs.ji_un.ji_newt.ji_fromsock = sock;
pj->ji_qs.ji_un.ji_newt.ji_fromaddr = get_connectaddr(sock,FALSE);
pj->ji_qs.ji_un.ji_newt.ji_scriptsz = 0;
/* acknowledge the request with the job id */
if (reply_jobid(preq, pj->ji_qs.ji_jobid, BATCH_REPLY_CHOICE_Queue) != 0)
{
/* reply failed, purge the job and close the connection */
close_conn(sock, FALSE);
mom_job_purge(pj);
return;
}
/* link job into server's new jobs list request */
append_link(&svr_newjobs, &pj->ji_alljobs, pj);
return;
} /* END req_quejob() */
/***********************************************************************
* Emit all state:
*/
void brw_validate_state( struct brw_context *brw )
{
struct brw_state_flags *state = &brw->state.dirty;
GLuint i;
state->mesa |= brw->intel.NewGLState;
brw->intel.NewGLState = 0;
if (brw->wrap)
state->brw |= BRW_NEW_CONTEXT;
if (brw->emit_state_always) {
state->mesa |= ~0;
state->brw |= ~0;
}
/* texenv program needs to notify us somehow when this happens:
* Some confusion about which state flag should represent this change.
*/
if (brw->fragment_program != brw->attribs.FragmentProgram->_Current) {
brw->fragment_program = brw->attribs.FragmentProgram->_Current;
brw->state.dirty.mesa |= _NEW_PROGRAM;
brw->state.dirty.brw |= BRW_NEW_FRAGMENT_PROGRAM;
}
if (state->mesa == 0 &&
state->cache == 0 &&
state->brw == 0)
return;
if (brw->state.dirty.brw & BRW_NEW_CONTEXT)
brw_clear_batch_cache_flush(brw);
/* Make an early reference to the state pools, as we don't cope
* well with them being evicted from here down.
*/
(void)bmBufferOffset(&brw->intel, brw->pool[BRW_GS_POOL].buffer);
(void)bmBufferOffset(&brw->intel, brw->pool[BRW_SS_POOL].buffer);
(void)bmBufferOffset(&brw->intel, brw->intel.batch->buffer);
if (INTEL_DEBUG) {
/* Debug version which enforces various sanity checks on the
* state flags which are generated and checked to help ensure
* state atoms are ordered correctly in the list.
*/
struct brw_state_flags examined, prev;
_mesa_memset(&examined, 0, sizeof(examined));
prev = *state;
for (i = 0; i < brw->state.nr_atoms; i++) {
const struct brw_tracked_state *atom = brw->state.atoms[i];
struct brw_state_flags generated;
assert(atom->dirty.mesa ||
atom->dirty.brw ||
atom->dirty.cache);
assert(atom->update);
if (check_state(state, &atom->dirty)) {
brw->state.atoms[i]->update( brw );
/* emit_foo(brw); */
}
accumulate_state(&examined, &atom->dirty);
/* generated = (prev ^ state)
* if (examined & generated)
* fail;
*/
xor_states(&generated, &prev, state);
assert(!check_state(&examined, &generated));
prev = *state;
}
}
else {
for (i = 0; i < Elements(atoms); i++) {
if (check_state(state, &brw->state.atoms[i]->dirty))
brw->state.atoms[i]->update( brw );
}
}
memset(state, 0, sizeof(*state));
}
void
tex_task1(TEXPTN texptn, intptr_t exinf)
{
ER ercd;
switch (texptn) {
case 0x0001:
check_point(4);
check_state(false, false, TIPM_ENAALL, false, false, true);
/*
* ディスパッチ禁止，割込み優先度マスク変更，タスク例外処理許可
*/
check_point(5);
ercd = dis_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = ena_tex();
check_ercd(ercd, E_OK);
ercd = loc_cpu();
check_ercd(ercd, E_OK);
check_state(false, true, TMAX_INTPRI, true, true, false);
break;
case 0x0002:
check_point(10);
check_state(false, false, TMIN_INTPRI, true, true, true);
/*
* タスク例外処理を要求
*/
check_point(11);
ercd = ras_tex(TSK_SELF, 0x0001);
check_ercd(ercd, E_OK);
ercd = ras_tex(TSK_SELF, 0x0002);
check_ercd(ercd, E_OK);
/*
* ディスパッチ許可，割込み優先度マスク変更，CPUロック
*/
check_point(12);
ercd = ena_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = loc_cpu();
check_ercd(ercd, E_OK);
check_state(false, true, TMAX_INTPRI, false, true, true);
break;
case 0x0003:
check_point(13);
check_state(false, false, TMIN_INTPRI, true, true, true);
/*
* ディスパッチ許可，割込み優先度マスク変更，タスク例外許可
*/
check_point(14);
ercd = ena_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TMAX_INTPRI);
check_ercd(ercd, E_OK);
ercd = ena_tex();
check_ercd(ercd, E_OK);
check_state(false, false, TMAX_INTPRI, false, true, false);
/*
* タスク例外処理を要求
*/
check_point(15);
ercd = ras_tex(TSK_SELF, 0x0004);
/* ここでタスク例外処理ルーチンが動作する */
check_ercd(ercd, E_OK);
/*
* タスク例外処理からのリターンにより元の状態に戻っていること
* をチェック
*/
check_point(18);
check_state(false, false, TMAX_INTPRI, false, true, false);
break;
case 0x0004:
check_point(16);
check_state(false, false, TMAX_INTPRI, false, true, true);
/*
* ディスパッチ禁止，割込み優先度マスク変更，CPUロック
*/
check_point(17);
ercd = dis_dsp();
check_ercd(ercd, E_OK);
ercd = chg_ipm(TIPM_ENAALL);
check_ercd(ercd, E_OK);
ercd = loc_cpu();
check_ercd(ercd, E_OK);
check_state(false, true, TIPM_ENAALL, true, true, true);
break;
default:
check_point(0);
break;
}
}