/**
* @public
* @brief extract err code from err
* @param[in] e err
* @retval uint32_t code
*/
uint32_t
err_get_code( err_t const *e )
{
trap( e );
trap( e->code != CODE_NONE );
return e->code;
}
/**
* @public
* @brief pop node from the back of the list
* @param[in] fifo list root
* @retval void* popped node
* @note { not threadsafe }
*/
void *
fifo_pop( void *fifo )
{
trap( fifo );
fifo_t *const f = fifo;
fifo_t *n = 0;
if( f->head || f->tail ) /**< 1+ nodes in list */
{
n = f->tail; /**< pop from tail */
trap( n->next == 0 ); /**< last node shouldn't have been */
/* pointing to anything next */
if( f->head != f->tail ) /**< 2+ nodes in list ? */
{
f->tail = n->prev; /**< safe to update tail */
f->tail->next = 0; /**< terminate list properly */
n->prev = 0; /**< not required, but safe */
}
else /**< that was last node in the list */
{
trap( n->prev == 0 ); /**< which means it shouldn't have */
/* been pointing to anything prev */
f->tail = f->head = 0; /**< now empty */
}
}
return n;
}
static BOOL FdmDoSaveAction(HWND hwnd, char *szpath, int act, int sact)
{
switch (act) {
case 0:
check_extension(szpath, ".cfg");
return resources_save(szpath);
case 1:
check_extension(szpath, ".vsf");
return trap(hwnd, save_snapshot, szpath);
case 2:
switch (sact) {
case 0:
check_extension(szpath, ".png");
break;
case 1:
check_extension(szpath, ".bmp");
break;
}
return trap(hwnd, save_screenshot, szpath);
case 3:
check_extension(szpath, ".vfl");
return fliplist_save_list(sact+8, szpath);
case 4:
return machine_romset_file_save(szpath);
}
return -1;
}
/* -------------------------------------------------------------------- */
xhallfunc(int roomslot, int xyn, int fl)
{
int yn;
if (hallBuf->hall[thisHall].hroomflags[roomslot].inhall)
{
yn=getYesNo("Exclude from hall", (char)xyn);
if (yn == 2) return FALSE;
if (yn)
{
hallBuf->hall[thisHall].hroomflags[roomslot].inhall = FALSE;
sprintf(msgBuf->mbtext,
"Room %s excluded from hall %s by %s",
roomTab[roomslot].rtname,
hallBuf->hall[thisHall].hallname,
logBuf.lbname );
trap(msgBuf->mbtext, T_AIDE);
if (!fl)
{
aideMessage();
}else{
amPrintf(" Excluded %s\n",
roomTab[roomslot].rtname,
hallBuf->hall[thisHall].hallname);
changed_room = TRUE;
}
}
}else{
yn=getYesNo("Add to hall", (char)xyn);
if (yn == 2) return FALSE;
if (yn)
{
hallBuf->hall[thisHall].hroomflags[roomslot].inhall = TRUE;
sprintf(msgBuf->mbtext,
"Room %s added to hall %s by %s",
roomTab[roomslot].rtname,
hallBuf->hall[thisHall].hallname,
logBuf.lbname );
trap(msgBuf->mbtext, T_AIDE);
if (!fl)
{
aideMessage();
}else{
amPrintf(" Added %s\n",
roomTab[roomslot].rtname);
changed_room = TRUE;
}
}
}
return TRUE;
}
int main() {
{
int height[] = { 4,2,3 };
printf("%d\n", trap(height, sizeof(height) / sizeof(int)));
}
{
int height[] = { 0,1,0,2,1,0,1,3,2,1,2,1 };
printf("%d\n", trap(height, sizeof(height) / sizeof(int)));
}
system("PAUSE");
return 0;
}
void TERMWINDOWMEMBER purgeuserlog(void)
{
Bool done = FALSE;
for (l_slot i = (l_slot) (cfg.MAXLOGTAB - 1); i >= 0 && !done; i--)
{
if (LTab(i).IsInuse())
{
label UserName;
LTab(i).GetName(UserName, sizeof(UserName));
if (!loggedIn || !CurrentUser->IsSameName(UserName))
{
char prompt[256];
sprintf(prompt, getsysmsg(57), cfg.Luser_nym, UserName);
const int response = getYesNo(prompt, 3);
if (response == 1)
{
LogEntry1 Log1;
Log1.Clear();
if (Log1.Save(LTab(i).GetLogIndex()))
{
if(!read_tr_messages())
{
errorDisp(getmsg(172));
done = TRUE;
return;
}
#ifdef WINCIT
trap(T_SYSOP, WindowCaption, gettrmsg(16), UserName);
#else
trap(T_SYSOP, gettrmsg(16), UserName);
#endif
dump_tr_messages();
}
}
else if (response == 2)
{
done = TRUE;
}
}
}
}
}
static Line_t*
append(char* (*f)(void), Line_t* a, Line_t** r)
{
register char* s;
register Line_t* a1;
register Line_t* a2;
register Line_t* a3;
off_t t;
long added;
added = 0;
ed.dot = a;
while (s = (*f)()) {
trap();
if ((ed.dol - ed.zero) + 1 >= ed.all) {
unsigned long dot_off = ed.dot - ed.zero;
unsigned long dol_off = ed.dol - ed.zero;
unsigned long r_off = r ? *r - ed.zero : 0;
ed.all += BLOCK_LINE;
if (!(ed.zero = newof(ed.zero, Line_t, ed.all, 0))) {
error(ERROR_SYSTEM|1, "no space [zero]");
ed.caught = SIGHUP;
trap();
}
ed.dot = ed.zero + dot_off;
ed.dol = ed.zero + dol_off;
if (r)
*r = ed.zero + r_off;
}
t = lineput(s);
added++;
a1 = ++ed.dol;
a2 = a1 + 1;
a3 = ++ed.dot;
while (a1 > a3) {
(--a2)->event = ed.event;
a2->undo = a2->offset;
a2->offset = (--a1)->offset;
}
a3->event = ed.event;
a3->undo = a3->offset;
a3->offset = t;
}
if (r)
*r += added;
return ed.dot;
}
IOErrorHandler::IOErrorHandler(StateFile *stateFile)
: _stateFile(stateFile),
_trapped(false),
_fired(false)
{
trap();
}
static DWORD
getCSR(Processor *p, int csr) {
switch(csr) {
case r_MHARTID:
return p->csr[i_MHARTID];
case r_MSTATUS:
return p->csr[i_MSTATUS];
case r_MTVEC:
return p->csr[i_MTVEC];
case r_MEPC:
return p->csr[i_MEPC];
case r_MBADADDR:
return p->csr[i_MBADADDR];
case r_MCAUSE:
return p->csr[i_MCAUSE];
case r_MTOHOST:
return p->csr[i_MTOHOST];
case r_MFROMHOST:
return p->csr[i_MFROMHOST];
case r_MIE:
return p->csr[i_MIE];
case r_MIP:
return ipr; /* See address-space.c */
default:
trap(p, 2); // Illegal CSR addresses are now spec'd to trigger illegal instruction traps. (RV64S V1.9)
fprintf(stderr, "Warning: At $%016llX, attempt to read unsupported CSR %d\n", p->pc-4, csr);
return 0xCCCCCCCCCCCCCCCC;
}
}
expr_ptr recursive_apply(expr_ptr& expr, expr_ptr (simplifier)(expr_ptr& expr, bool&), bool& mod)
{
switch(expr->get_type())
{
case MULT : { binary*b=(binary*) expr.release(); expr = Binary{new multiplication{ recursive_apply(b->first, simplifier, mod), recursive_apply(b->second, simplifier, mod) }}; break; }
case DIV : { binary*b=(binary*) expr.release(); expr = Binary{new division { recursive_apply(b->first, simplifier, mod), recursive_apply(b->second, simplifier, mod) }}; break; }
case ADD : { binary*b=(binary*) expr.release(); expr = Binary{new addition { recursive_apply(b->first, simplifier, mod), recursive_apply(b->second, simplifier, mod) }}; break; }
case SUB : { binary*b=(binary*) expr.release(); expr = Binary{new subtraction { recursive_apply(b->first, simplifier, mod), recursive_apply(b->second, simplifier, mod) }}; break; }
case EXPO : { break; }
case LOG : { break; }
case NEGATE : { Negation n{(negation*) expr.release()}; expr = recursive_apply(n->orig, simplifier, mod); break; }
case VARIABLE : { break; }
case INTERVAL : { break; }
case IEEE : { break; }
case REAL : { break; }
case COMPLEX : { break; }
case ZERO : { break; }
case UNITY : { break; }
case ANYTHING : { break; }
case NAN : { break; }
case INFINITY : { break; }
default:
trap("Unable to simplify expression of type: " + expr->get_text());
}
return simplifier(expr, mod);
}
expr_ptr simplify_an_expression(expr_ptr& expr, bool& mod)
{
// expr->append_text(std::cout << "simplifying: ") << std::endl;
switch(expr->get_type())
{
case REAL : /* return simplify (Real {(real *) expr.release()}, mod); */ break;
case COMPLEX : /* return simplify (Complex {(complex *) expr.release()}, mod); */ break;
case MULT : return simplify_mult(Multiplication {(multiplication *) expr.release()}, mod);
case DIV : /* return simplify (Division {(division *) expr.release()}, mod); */ break;
case ADD : return simplify_add (Addition {(addition *) expr.release()}, mod);
case SUB : /* return simplify (Subtraction {(subtraction *) expr.release()}, mod); */ break;
case EXPO : /* return simplify (Exponent {(exponent *) expr.release()}, mod); */ break;
case NEGATE : return simplify_neg (Negation {(negation *) expr.release()}, mod);
case VARIABLE: /* return simplify (Variable {(variable *) expr.release()}, mod); */ break;
case LOG : /* return simplify (expr_ptr {(expression_raw *) expr.release()}, mod); */ break;
case INTERVAL: /* return simplify (expr_ptr {(expression_raw *) expr.release()}, mod); */ break;
case IEEE : /* return simplify (expr_ptr {(expression_raw *) expr.release()}, mod); */ break;
case ZERO : /* return expr_ptr{expr.release()}; */ break;
case UNITY : /* return expr_ptr{expr.release()}; */ break;
case ANYTHING: /* return expr_ptr{expr.release()}; */ break;
case NAN : /* return expr_ptr{expr.release()}; */ break;
case INFINITY: /* return expr_ptr{expr.release()}; */ break;
default:
trap("Unable to simplify expression of type: " + expr->get_text());
}
return expr_ptr{expr.release()};
}
BitField StateConstraints::minimalTrap(const PetriNet& net,
const MarkVal* marking,
const MarkVal* resultMarking) const{
const size_t nPlaces = net.numberOfPlaces();
BitField trap(nPlaces);
trap.set();
trap = maxTrap(net, trap, resultMarking);
if(!isMarked(trap, marking))
return BitField(nPlaces).clear();
//Get the exclusion candidates
BitField EC(trap);
BitField tmp(nPlaces);
while(EC.any()){
int exclude = EC.first();
tmp = trap;
tmp.clear(exclude);
EC.clear(exclude);
tmp = maxTrap(net, tmp, resultMarking);
if(isMarked(tmp, marking)){
trap = tmp;
EC = tmp;
}
}
return trap;
}
/*
* A very short dispatch, to try and maximise assembler code use
* between all exception types. Maybe 'true' interrupts should go
* here, and the trap code can come in separately
*/
void
powerpc_interrupt(struct trapframe *framep)
{
struct thread *td;
struct clockframe ckframe;
td = curthread;
switch (framep->exc) {
case EXC_EXI:
atomic_add_int(&td->td_intr_nesting_level, 1);
(*powerpc_extintr_handler)();
atomic_subtract_int(&td->td_intr_nesting_level, 1);
break;
case EXC_DECR:
atomic_add_int(&td->td_intr_nesting_level, 1);
ckframe.srr0 = framep->srr0;
ckframe.srr1 = framep->srr1;
decr_intr(&ckframe);
atomic_subtract_int(&td->td_intr_nesting_level, 1);
break;
default:
/*
* Re-enable interrupts and call the generic trap code
*/
#if 0
printf("powerpc_interrupt: got trap\n");
#endif
mtmsr(mfmsr() | PSL_EE);
isync();
trap(framep);
}
}
void powerpc_mchk_interrupt(struct trapframe *framep)
{
printf("powerpc_mchk_interrupt: machine check interrupt!\n");
dump_frame(framep);
trap(framep);
}
//the private recursive method
double RecursiveIntegration::rombergRec(MultiVarFunction* f, int dim, double* a, double* b, int n, double* coords)
{
//each level of recursion needs storage space
double* evals = new double[n + 1];
double h = (b[dim] - a[dim])/n;
coords[dim] = a[dim]; //need to reset for each pass
for (int j = 0; j <= n; j++) //loop over the number of points (number of intervals plus one)
{
if (dim == 0) //base case, function evaluation
{
evals[j] = f->evaluate(coords);
}
else
{
evals[j] = rombergRec(f, dim - 1, a, b, n, coords);
}
coords[dim] = coords[dim] + h;
}
double result = trap(evals, n, a[dim], b[dim]);
delete[] evals;
return result;
}
int unlink(const char *path)
{
argstr_t args;
args.as_len = strlen(path);
args.as_str = path;
return trap(SYS_unlink, (uint32_t) &args);
}
/*
* call-seq:
* Signal.trap( signal, command ) -> obj
* Signal.trap( signal ) {| | block } -> obj
*
* Specifies the handling of signals. The first parameter is a signal
* name (a string such as ``SIGALRM'', ``SIGUSR1'', and so on) or a
* signal number. The characters ``SIG'' may be omitted from the
* signal name. The command or block specifies code to be run when the
* signal is raised.
* If the command is the string ``IGNORE'' or ``SIG_IGN'', the signal
* will be ignored.
* If the command is ``DEFAULT'' or ``SIG_DFL'', the Ruby's default handler
* will be invoked.
* If the command is ``EXIT'', the script will be terminated by the signal.
* If the command is ``SYSTEM_DEFAULT'', the operating system's default
* handler will be invoked.
* Otherwise, the given command or block will be run.
* The special signal name ``EXIT'' or signal number zero will be
* invoked just prior to program termination.
* trap returns the previous handler for the given signal.
*
* Signal.trap(0, proc { puts "Terminating: #{$$}" })
* Signal.trap("CLD") { puts "Child died" }
* fork && Process.wait
*
* produces:
* Terminating: 27461
* Child died
* Terminating: 27460
*/
static VALUE
sig_trap(int argc, VALUE *argv)
{
int sig;
sighandler_t func;
VALUE cmd;
rb_secure(2);
rb_check_arity(argc, 1, 2);
sig = trap_signm(argv[0]);
if (reserved_signal_p(sig)) {
const char *name = signo2signm(sig);
if (name)
rb_raise(rb_eArgError, "can't trap reserved signal: SIG%s", name);
else
rb_raise(rb_eArgError, "can't trap reserved signal: %d", sig);
}
if (argc == 1) {
cmd = rb_block_proc();
func = sighandler;
}
else {
cmd = argv[1];
func = trap_handler(&cmd, sig);
}
if (OBJ_TAINTED(cmd)) {
rb_raise(rb_eSecurityError, "Insecure: tainted signal trap");
}
return trap(sig, func, cmd);
}
static int
getchr(void)
{
int n;
if (ed.lastc = ed.peekc) {
ed.peekc = 0;
return ed.lastc;
}
if (ed.global) {
if (ed.lastc = *ed.global++)
return ed.lastc;
ed.global = 0;
return EOF;
}
if (!ed.input) {
if (!(ed.input = sfgetr(sfstdin, '\n', 1))) {
trap();
return EOF;
}
if ((n = sfvalue(sfstdin) - 2) >= 0 && ed.input[n] == '\r')
ed.input[n--] = 0;
ed.spbeg = ed.input;
ed.spend = (n >= 0 && ed.input[n] == '\\') ? (ed.input + n) : (char*)0;
}
if (!(ed.lastc = *ed.input++)) {
ed.input = 0;
ed.lastc = '\n';
}
return ed.lastc;
}
void powerpc_crit_interrupt(struct trapframe *framep)
{
printf("powerpc_crit_interrupt: critical interrupt!\n");
dump_frame(framep);
trap(framep);
}
/* -------------------------------------------------------------------- */
void killhall(void)
{
int empty = TRUE, i;
if (thisHall == 0 || thisHall == 1)
{
mPrintf("\nThe Main and Maintenance hallways cannot be killed.");
return;
}
/* Check hall for any rooms */
for (i = 0; i < MAXROOMS; i++)
{
if ( hallBuf->hall[thisHall].hroomflags[i].inhall
&& roomTab[i].rtflags.INUSE) empty = FALSE;
}
if (!empty)
{
mPrintf("\n Hall still has rooms.");
return;
}
if (getYesNo(confirm, 0))
{
hallBuf->hall[thisHall].h_inuse = FALSE;
hallBuf->hall[thisHall].owned = FALSE;
putHall();
sprintf(msgBuf->mbtext,
"Hallway %s deleted", hallBuf->hall[thisHall].hallname );
trap(msgBuf->mbtext, T_SYSOP);
}
}
void test_trap(void){
I0 = 0;
I0 = 0;
*pcToLoad = 0x012244; //*pcToLoad + 1 = 0x012245
//pcl =0x45
//pch =0x22
//pce =0x01
YL = 0XE4;
YH = 0XD6;
XL = 0XC9;
XH = 0X68;
A = 0XBB;
CC = 0X55;
uint8_t instr[] = {0XBB};
TEST_ASSERT_EQUAL_INT8(1, trap(instr));
TEST_ASSERT_EQUAL_INT16(0x012245, *pcToLoad);
TEST_ASSERT_EQUAL_INT8(0X55, mcu_pop());
TEST_ASSERT_EQUAL_INT8(0XBB, mcu_pop());
TEST_ASSERT_EQUAL_INT8(0X68, mcu_pop());
TEST_ASSERT_EQUAL_INT8(0XC9, mcu_pop());
TEST_ASSERT_EQUAL_INT8(0XD6, mcu_pop());
TEST_ASSERT_EQUAL_INT8(0XE4, mcu_pop());
TEST_ASSERT_EQUAL_INT8(0X01, mcu_pop());
TEST_ASSERT_EQUAL_INT8(0X22, mcu_pop());
TEST_ASSERT_EQUAL_INT8(0X45, mcu_pop());
TEST_ASSERT_EQUAL_INT8(1, I0);
TEST_ASSERT_EQUAL_INT8(1, I1);
}
/*
* call-seq:
* Signal.trap( signal, command ) -> obj
* Signal.trap( signal ) {| | block } -> obj
*
* Specifies the handling of signals. The first parameter is a signal
* name (a string such as ``SIGALRM'', ``SIGUSR1'', and so on) or a
* signal number. The characters ``SIG'' may be omitted from the
* signal name. The command or block specifies code to be run when the
* signal is raised.
* If the command is the string ``IGNORE'' or ``SIG_IGN'', the signal
* will be ignored.
* If the command is ``DEFAULT'' or ``SIG_DFL'', the Ruby's default handler
* will be invoked.
* If the command is ``EXIT'', the script will be terminated by the signal.
* If the command is ``SYSTEM_DEFAULT'', the operating system's default
* handler will be invoked.
* Otherwise, the given command or block will be run.
* The special signal name ``EXIT'' or signal number zero will be
* invoked just prior to program termination.
* trap returns the previous handler for the given signal.
*
* Signal.trap(0, proc { puts "Terminating: #{$$}" })
* Signal.trap("CLD") { puts "Child died" }
* fork && Process.wait
*
* produces:
* Terminating: 27461
* Child died
* Terminating: 27460
*/
static VALUE
sig_trap(int argc, VALUE *argv)
{
struct trap_arg arg;
rb_secure(2);
if (argc < 1 || argc > 2) {
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
}
arg.sig = trap_signm(argv[0]);
if (argc == 1) {
arg.cmd = rb_block_proc();
arg.func = sighandler;
}
else {
arg.cmd = argv[1];
arg.func = trap_handler(&arg.cmd, arg.sig);
}
if (OBJ_TAINTED(arg.cmd)) {
rb_raise(rb_eSecurityError, "Insecure: tainted signal trap");
}
#if USE_TRAP_MASK
/* disable interrupt */
sigfillset(&arg.mask);
pthread_sigmask(SIG_BLOCK, &arg.mask, &arg.mask);
return rb_ensure(trap, (VALUE)&arg, trap_ensure, (VALUE)&arg);
#else
return trap(&arg);
#endif
}
void *sbrk(intptr_t incr)
{
uintptr_t oldbrk;
/* If we don't have a saved break, find it from the kernel */
if (!__curbrk) {
if (0 > (long)(__curbrk = (void *) trap(SYS_brk, (uint32_t) NULL))) {
return (void *) -1;
}
}
oldbrk = (uintptr_t) __curbrk;
/* Increment or decrement the saved break */
if (incr < 0) {
if ((uintptr_t) - incr > oldbrk) {
return (void *) -1;
} else if (brk((void *)(oldbrk - (uintptr_t) - incr)) < 0) {
return (void *) -1;
}
} else if (incr > 0) {
if (brk((void *)(oldbrk + (uintptr_t) incr)) < 0) {
return (void *) -1;
}
}
return (void *) oldbrk;
}
void Assembler::movsd(XMMRegister src, Indirect dest) {
int rex = 0;
int src_idx = src.regnum;
int dest_idx = dest.base.regnum;
if (src_idx >= 8) {
rex |= REX_R;
src_idx -= 8;
}
if (dest_idx >= 8) {
trap();
rex |= REX_B;
dest_idx -= 8;
}
emitByte(0xf2);
if (rex)
emitRex(rex);
emitByte(0x0f);
emitByte(0x11);
bool needssib = (dest_idx == 0b100);
int mode = getModeFromOffset(dest.offset);
emitModRM(mode, src_idx, dest_idx);
if (needssib)
emitSIB(0b00, 0b100, dest_idx);
if (mode == 0b01) {
emitByte(dest.offset);
} else if (mode == 0b10) {
emitInt(dest.offset, 4);
}
}
int chdir(const char *path)
{
argstr_t args;
args.as_len = strlen(path);
args.as_str = path;
return trap(SYS_chdir, (uint32_t) &args);
}
void
trap_tss(struct i386tss *tss, int trapno, int code)
{
struct trapframe tf;
tf.tf_gs = tss->tss_gs;
tf.tf_fs = tss->tss_fs;
tf.tf_es = tss->__tss_es;
tf.tf_ds = tss->__tss_ds;
tf.tf_edi = tss->__tss_edi;
tf.tf_esi = tss->__tss_esi;
tf.tf_ebp = tss->tss_ebp;
tf.tf_ebx = tss->__tss_ebx;
tf.tf_edx = tss->__tss_edx;
tf.tf_ecx = tss->__tss_ecx;
tf.tf_eax = tss->__tss_eax;
tf.tf_trapno = trapno;
tf.tf_err = code | TC_TSS;
tf.tf_eip = tss->__tss_eip;
tf.tf_cs = tss->__tss_cs;
tf.tf_eflags = tss->__tss_eflags;
tf.tf_esp = tss->tss_esp;
tf.tf_ss = tss->__tss_ss;
trap(&tf);
}
/// serial main
int main() {
int n;
float h, a, b, t, total;
LOCK;
proc_id++;
UNLOCK;
LOCK;
if (proc_id == 1){
printf("Digite o numero de subintervalos:\n");
/// interval count
scanf("%d", &n);
printf("Digite o inicio e o final do intervalo:\n");
/// interval start
scanf("%f", &a);
/// interval end
scanf("%f", &b);
/// interval size
h=(b-a)/n;
total = trap(a,b,n,h);
printf("A estimativa foi: %.15e\n",total);
}
proc_id++;
return 0;
}
void
main(void)
{
trap();
for (;;)
;
}
void *galloc(long size) {
void *ret;
while (( ret = malloc(size))==NULL )
trap();
memset(ret,0x3c,size); /* fill with random junk for debugging */
return( ret );
}
static VALUE
sig_trap(VALUE rcv, SEL sel, int argc, VALUE *argv)
{
struct trap_arg arg;
rb_secure(2);
if (argc == 0 || argc > 2) {
rb_raise(rb_eArgError, "wrong number of arguments -- trap(sig, cmd)/trap(sig){...}");
}
arg.sig = trap_signm(argv[0]);
if (argc == 1) {
arg.cmd = rb_block_proc();
arg.func = sighandler;
}
else {
arg.cmd = argv[1];
arg.func = trap_handler(&arg.cmd, arg.sig);
}
if (OBJ_TAINTED(arg.cmd)) {
rb_raise(rb_eSecurityError, "Insecure: tainted signal trap");
}
return trap(&arg);
}