inline static void display_stack_main(int LineNo = 0) { get_log_stream() << "Begin Stack -------------------- (" << LineNo << ")" << std::endl; for(std::vector<std::string>::iterator i = get_stack().begin(); i != get_stack().end();++i) { get_log_stream() << *i << std::endl; } get_log_stream() << "End Stack --------------------" << std::endl; }
static int native_thread_init_stack(rb_thread_t *th) { rb_nativethread_id_t curr = pthread_self(); if (pthread_equal(curr, native_main_thread.id)) { th->machine.stack_start = native_main_thread.stack_start; th->machine.stack_maxsize = native_main_thread.stack_maxsize; } else { #ifdef STACKADDR_AVAILABLE void *start; size_t size; if (get_stack(&start, &size) == 0) { th->machine.stack_start = start; th->machine.stack_maxsize = size; } #elif defined get_stack_of if (!th->machine.stack_maxsize) { native_mutex_lock(&th->interrupt_lock); native_mutex_unlock(&th->interrupt_lock); } #else rb_raise(rb_eNotImpError, "ruby engine can initialize only in the main thread"); #endif } #ifdef __ia64 th->machine.register_stack_start = native_main_thread.register_stack_start; th->machine.stack_maxsize /= 2; th->machine.register_stack_maxsize = th->machine.stack_maxsize; #endif return 0; }
int main() { int a1; void *stack_addr; size_t stack_size; pthread_t tid; pthread_t tid_1; pthread_t tid_2; printf("The pthread id is:%d\n", getpid()); printf("address of a1: %p\n", &a1); get_stack(&stack_addr, &stack_size); printf("stack start: %p, size: %zu\n", stack_addr, stack_size); int a2; printf("address of a2: %p\n", &a2); pthread_create(&tid, NULL, func, NULL); pthread_create(&tid_1, NULL, func_1, NULL); pthread_create(&tid_2, NULL, func_2, NULL); puts("\n==============================================\n"); char buf[4096]; FILE *fp = fopen("/proc/self/maps", "r"); while (fgets(buf, sizeof(buf), fp)) printf("%s", buf); fclose(fp); sleep(2); return 0; }
/* rtos_init can be a macro in case that USE_DEFAULT_IDLE == 1 * so we undef it here. */ void rtos_init(void (*idle)(void*),uint16_t stack_len,uint16_t system ){ set_sleep_mode(SLEEP_MODE_IDLE); #if USE_DYNAMIC_MEMORY uint8_t interrupt = GET_INTERRUPTS; cli(); kernel.system_stack = ( uint8_t * )malloc( sizeof(uint8_t)*system ) + system - 1; RESTORE_INTERRUPTS(interrupt); #else kernel.system_stack = get_stack( sizeof(uint8_t)*system ) + system - 1; #endif if ( kernel.system_stack == NULL ){ /** * If we don't have enough stack for the system, * we try to warn the user */ #if TEST_STACK_OVERFLOW cli(); ACTION_IN_STACK_OVERFLOW; while (1); #endif return; } add_task(idle,NULL, NULL,0,0,0,stack_len); __asm__ volatile ("rjmp switch_task\n" ::); };
void ndc::pop() { context_stack_t& stack = get_stack(); if(!stack.empty()) { stack.pop(); } }
void ndc::clear() { context_stack_t& stack = get_stack(); while(!stack.empty()) { stack.pop(); } }
const ndc::context_type & ndc::get() { context_stack_t& stack = get_stack(); if(!stack.empty()) { return stack.top(); } throw std::logic_error("ndc is empty"); }
/* * Initialize LWP by spinning of a schedular */ int ldap_int_thread_initialize( void ) { thread_t tid; stkalign_t *stack; int stackno; if (( stack = get_stack( &stackno )) == NULL ) { return -1; } lwp_create( &tid, lwp_scheduler, MINPRIO, 0, stack, 1, stackno ); return 0; }
static inline int setup_thread_stack(stack_t *s,pthread_attr_t *attr){ if(pthread_attr_init(attr)){ return -1; } if((s->ss_sp = get_stack(&s->ss_size)) == NULL){ pthread_attr_destroy(attr); return -1; } if(pthread_attr_setstack(attr,s->ss_sp,s->ss_size)){ dealloc(s->ss_sp,s->ss_size); pthread_attr_destroy(attr); return -1; } s->ss_flags = 0; return 0; }
/** * Verifies is a position is drawn by * a) lack of material * b) fifty quiet moves * c) repetition * @return true if it's an official draw */ bool search_t::is_draw() { if (brd.is_draw()) { //draw by no mating material return true; } else if (brd.stack->fifty_count > 3) { if (brd.stack->fifty_count >= (100 + stack->in_check)) { return true; //50 reversible moves } int stop_ply = brd.ply - brd.stack->fifty_count; for (int ply = brd.ply - 4; ply >= stop_ply; ply -= 2) { //draw by repetition if (ply >= 0 && get_stack(ply)->tt_key == brd.stack->tt_key) { return true; } else if (ply < 0 && rep_table::retrieve(root.fifty_count + ply) == brd.stack->tt_key) { return true; } } } return false; }
struct DEBRUIJN * eval_debruijn (struct DEBRUIJN * debruijn, struct STACK * stack) { switch (debruijn->type) { case TYPE_DEBRUIJN_INTEGER : { TRACE("integer"); return debruijn; break; } case TYPE_DEBRUIJN_VARIABLE : { TRACE("variable"); return get_stack (stack, debruijn->variable.value)->debruijn; break; } case TYPE_DEBRUIJN_QUOTE : { TRACE("quote"); return debruijn->quote.value; break ; } case TYPE_DEBRUIJN_ABSTRACTION : { TRACE("abstraction"); return make_debruijn_closure (debruijn->abstraction.body, stack); break ; } case TYPE_DEBRUIJN_CLOSURE : { TRACE("closure"); return debruijn; break ; } case TYPE_DEBRUIJN_APPLICATION : { TRACE("application"); struct DEBRUIJN * v = eval_debruijn (debruijn->application.left, stack); switch (v->type) { case TYPE_DEBRUIJN_CLOSURE : { return eval_debruijn (v->closure.body, set_stack (v->closure.stack, gen_ident(), eval_debruijn (debruijn->application.right, stack))); } default : { fprintf(stderr, "Not a debruijn closure\n"); exit(1); }} }} }
struct TERM * debruijn_to_term (struct DEBRUIJN * debruijn, struct STACK * stack) { switch (debruijn->type) { case TYPE_DEBRUIJN_INTEGER : { TRACE("integer"); return make_term_integer(debruijn->integer.value); break; } case TYPE_DEBRUIJN_VARIABLE : { TRACE("variable"); struct STACK * v = get_stack (stack, debruijn->variable.value); return make_term_variable (v->ident); break; } case TYPE_DEBRUIJN_QUOTE : { TRACE("quote"); return make_term_quote (debruijn_to_term (debruijn->quote.value, make_stack())); break ; } case TYPE_DEBRUIJN_ABSTRACTION : { TRACE("abstraction"); char * var = gen_ident(); struct STACK * s = set_stack(stack, var, NULL); // We just want to get ident return make_term_abstraction (var,debruijn_to_term(debruijn->abstraction.body, s)); break ; } case TYPE_DEBRUIJN_CLOSURE : { TRACE("closure"); char * var = gen_ident(); struct STACK * s = set_stack(stack, var, NULL); // We just want to get ident return make_term_closure (var,debruijn_to_term(debruijn->abstraction.body, s), NULL); // Shouldn't be NULL. Should be stack->env transformation break ; } case TYPE_DEBRUIJN_APPLICATION : { TRACE("application"); return make_term_application(debruijn_to_term(debruijn->application.left, stack), debruijn_to_term(debruijn->application.right, stack)); break; } default:{ fprintf(stderr, "Unknown debruijn term type\n"); exit(1); } } }
void ruby_init_stack(volatile VALUE *addr #ifdef __ia64 , void *bsp #endif ) { native_main_thread.id = pthread_self(); #ifdef STACK_END_ADDRESS native_main_thread.stack_start = STACK_END_ADDRESS; #else if (!native_main_thread.stack_start || STACK_UPPER((VALUE *)(void *)&addr, native_main_thread.stack_start > addr, native_main_thread.stack_start < addr)) { native_main_thread.stack_start = (VALUE *)addr; } #endif #ifdef __ia64 if (!native_main_thread.register_stack_start || (VALUE*)bsp < native_main_thread.register_stack_start) { native_main_thread.register_stack_start = (VALUE*)bsp; } #endif { size_t size = 0; size_t space = 0; #if defined(STACKADDR_AVAILABLE) void* stackaddr; STACK_GROW_DIR_DETECTION; get_stack(&stackaddr, &size); space = STACK_DIR_UPPER((char *)addr - (char *)stackaddr, (char *)stackaddr - (char *)addr); #elif defined(HAVE_GETRLIMIT) struct rlimit rlim; if (getrlimit(RLIMIT_STACK, &rlim) == 0) { size = (size_t)rlim.rlim_cur; } space = size > 5 * 1024 * 1024 ? 1024 * 1024 : size / 5; #endif native_main_thread.stack_maxsize = size - space; } }
Object* native_file_read_into_offset_length(Object *cxt, Object *frame, Object *self) { Object *stack = get_stack(cxt, frame); FileBuffer *file_buf = get_file_buffer(self); Object *length_obj = pop(cxt, stack); Object *offset_obj = pop(cxt, stack); Object *char_array = pop(cxt, stack); if ( file_buf == 0 ) { return new_exception(cxt, frame, "Expected a file as self argument"); } CharArrayBuffer *char_array_buf = get_char_array_buffer(char_array); if ( char_array_buf == 0 ) { return new_exception(cxt, frame, "Expected a char_array as first argument"); } if ( ! is_boxed_int(cxt, offset_obj) ) { return new_exception(cxt, frame, "Expected a boxed int as second argument"); } Fixnum offset = boxed_int_to_fixnum(cxt, offset_obj); if ( ! is_boxed_int(cxt, length_obj) ) { return new_exception(cxt, frame, "Expected a fixnum as third argument"); } Fixnum length = boxed_int_to_fixnum(cxt, length_obj); if ( offset + length > char_array_buf->reserved ) { return new_exception(cxt, frame, "Offset + length exceeds char_array length"); } int num_read = fread(char_array_buf->data + offset, 1, length, file_buf->file); if ( num_read >= 0 ) { char_array_truncate_buffer(cxt, char_array, offset + num_read); return frame; } else { return new_errno_exception(cxt, frame, "Unable to read from file"); } }
void ruby_init_stack(volatile VALUE *addr #ifdef __ia64 , void *bsp #endif ) { native_main_thread.id = pthread_self(); #ifdef STACK_END_ADDRESS native_main_thread.stack_start = STACK_END_ADDRESS; #else if (!native_main_thread.stack_start || STACK_UPPER((VALUE *)(void *)&addr, native_main_thread.stack_start > addr, native_main_thread.stack_start < addr)) { native_main_thread.stack_start = (VALUE *)addr; } #endif #ifdef __ia64 if (!native_main_thread.register_stack_start || (VALUE*)bsp < native_main_thread.register_stack_start) { native_main_thread.register_stack_start = (VALUE*)bsp; } #endif { size_t size = 0; size_t space = 0; #if defined(HAVE_PTHREAD_ATTR_GET_NP) void* addr; get_stack(&addr, &size); #elif defined(HAVE_GETRLIMIT) struct rlimit rlim; if (getrlimit(RLIMIT_STACK, &rlim) == 0) { size = (size_t)rlim.rlim_cur; } #endif space = size > 5 * 1024 * 1024 ? 1024 * 1024 : size / 5; native_main_thread.stack_maxsize = size - space; } }
size_t ndc::get_depth() { context_stack_t& stack = get_stack(); return stack.size(); }
int add_task(void (*f)(void*),void (*finisher)(void), void * init_data,uint16_t period,uint16_t delay, uint8_t priority, uint16_t stack_len ){ task_t * new_task = NULL,* current, *previous; uint16_t min_stack_len = 0xFFFF; uint8_t interrupt; current = previous = kernel.stopped_tasks; while ( current != NULL ) { /* Finding an task already created but stopped and which stack we can use*/ if ( current->stack_len >= stack_len && current->stack_len <= min_stack_len ) { if ( previous == current ) kernel.stopped_tasks = current->next_task; else previous->next_task = current->next_task; new_task = current; min_stack_len = current->stack_len; break; } previous = current; current = current->next_task; } if ( new_task == NULL ) { interrupt = GET_INTERRUPTS; cli(); #if USE_DYNAMIC_MEMORY new_task = ( task_t * ) malloc(sizeof(task_t)); if ( new_task == NULL ) { RESTORE_INTERRUPTS(interrupt); return NO_MEMORY; } new_task->bottom_stack = ( uint8_t * )malloc( sizeof(uint8_t)*stack_len ); if ( new_task->bottom_stack == NULL) { free(new_task); RESTORE_INTERRUPTS(interrupt); return NO_MEMORY; } #else if ( __current_position_tasks >= NUMBER_OF_TASKS ) { RESTORE_INTERRUPTS(interrupt); return NO_MEMORY; } new_task = &__all_taks[__current_position_tasks++]; new_task->bottom_stack = get_stack( sizeof(uint8_t)*stack_len ); if ( new_task->bottom_stack == NULL) { RESTORE_INTERRUPTS(interrupt); return NO_MEMORY; } #endif RESTORE_INTERRUPTS(interrupt); new_task->stack_len = stack_len; } // This can be used to detect stack overflows. new_task->stack = new_task->bottom_stack + sizeof(uint8_t)*new_task->stack_len-1; // To jump start the task. // we use another function with no arguments. *((new_task->stack)--) = ((uint16_t)task_starter) & 0xFF; *((new_task->stack)--) = (((uint16_t)task_starter) >> 8) & 0xFF; new_task->priority = priority; new_task->period = period; new_task->delay = delay; new_task->init_data = init_data; #if USE_MUTEX new_task->holding_mutex = NULL; #endif //placing arguments in the stack for further use *((new_task->stack)--) = ((uint16_t)init_data) & 0xFF; *((new_task->stack)--) = (((uint16_t)init_data) >> 8) & 0xFF; new_task->func = f; new_task->finisher = finisher; interrupt = GET_INTERRUPTS; if ( delay == 0 ){ new_task->state = TASK_STARTING; add_task_to_priority_list(new_task, &kernel.ready_tasks); } else{ new_task->state = TASK_DELAYED; add_task_to_blocked(new_task, &kernel.spleeping_tasks); } RESTORE_INTERRUPTS(interrupt); return 0; }
void validate(){ if(!this_player() || !environment() || !(this_player() == environment())){ error("Pingy violation. Stack: "+get_stack()); } }
int main() { printf("The address of the stack is: %x.\n", get_stack()); }
static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, sigset_t *set, struct pt_regs * regs) { struct rt_sigframe __user *frame; struct _fpstate __user *fp = NULL; int err = 0; struct task_struct *me = current; if (used_math()) { fp = get_stack(ka, regs, sizeof(struct _fpstate)); frame = (void __user *)round_down( (unsigned long)fp - sizeof(struct rt_sigframe), 16) - 8; if (!access_ok(VERIFY_WRITE, fp, sizeof(struct _fpstate))) goto give_sigsegv; if (save_i387(fp) < 0) err |= -1; } else frame = get_stack(ka, regs, sizeof(struct rt_sigframe)) - 8; if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) goto give_sigsegv; if (ka->sa.sa_flags & SA_SIGINFO) { err |= copy_siginfo_to_user(&frame->info, info); if (err) goto give_sigsegv; } /* Create the ucontext. */ err |= __put_user(0, &frame->uc.uc_flags); err |= __put_user(0, &frame->uc.uc_link); err |= __put_user(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp); err |= __put_user(sas_ss_flags(regs->rsp), &frame->uc.uc_stack.ss_flags); err |= __put_user(me->sas_ss_size, &frame->uc.uc_stack.ss_size); err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0], me); err |= __put_user(fp, &frame->uc.uc_mcontext.fpstate); if (sizeof(*set) == 16) { __put_user(set->sig[0], &frame->uc.uc_sigmask.sig[0]); __put_user(set->sig[1], &frame->uc.uc_sigmask.sig[1]); } else err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); /* Set up to return from userspace. If provided, use a stub already in userspace. */ /* x86-64 should always use SA_RESTORER. */ if (ka->sa.sa_flags & SA_RESTORER) { err |= __put_user(ka->sa.sa_restorer, &frame->pretcode); } else { /* could use a vstub here */ goto give_sigsegv; } if (err) goto give_sigsegv; #ifdef DEBUG_SIG printk("%d old rip %lx old rsp %lx old rax %lx\n", current->pid,regs->rip,regs->rsp,regs->rax); #endif /* Set up registers for signal handler */ regs->rdi = sig; /* In case the signal handler was declared without prototypes */ regs->rax = 0; /* This also works for non SA_SIGINFO handlers because they expect the next argument after the signal number on the stack. */ regs->rsi = (unsigned long)&frame->info; regs->rdx = (unsigned long)&frame->uc; regs->rip = (unsigned long) ka->sa.sa_handler; regs->rsp = (unsigned long)frame; /* Set up the CS register to run signal handlers in 64-bit mode, even if the handler happens to be interrupting 32-bit code. */ regs->cs = __USER_CS; /* This, by contrast, has nothing to do with segment registers - see include/asm-x86_64/uaccess.h for details. */ set_fs(USER_DS); regs->eflags &= ~TF_MASK; if (test_thread_flag(TIF_SINGLESTEP)) ptrace_notify(SIGTRAP); #ifdef DEBUG_SIG printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n", current->comm, current->pid, frame, regs->rip, frame->pretcode); #endif return 0; give_sigsegv: force_sigsegv(sig, current); return -EFAULT; }
Object* native_file_open(Object *cxt, Object *frame, Object *self) { Object *stack = get_stack(cxt, frame); push(cxt, stack, new_char_array(cxt, "r")); return native_file_open_mode(cxt, frame, self); }
30:165, 32:192, 34:221, 36:252, 38:285, 40:450, ]); void validate(){ if(!master()->valid_apply(({ "SECURE", "ASSIST", "LIB_CONNECT" })) && base_name(previous_object()) != CGI_LOGIN && !override && base_name(previous_object()) != CMD_RID && base_name(previous_object()) != CMD_SUICIDE){ string offender = identify(previous_object(-1)); debug("PLAYERS_D SECURITY VIOLATION: "+offender+" ",get_stack(),"red"); log_file("security", "\n"+timestamp()+" PLAYERS_D breach: "+offender+" "+get_stack()); error("PLAYERS_D SECURITY VIOLATION: "+offender+" "+get_stack()); } override = 0; } // This function generates a table of required xp per level. // The xp required for lower levels is high, approximately // half-again the xp required for the previous level. As the // player progresses, this ratio decreases. mapping CompileLevelList(){ int i=1; mixed title; int seed=300; float mod;
if(memory_info() > MEMUSE_HARD_LIMIT){ if(!EVENTS_D->GetRebooting()){ EVENTS_D->eventReboot(MINUTES_REBOOT_WARNING); } } } } static void create() { daemon::create(); SetNoClean(1); call_out((: eventReap :), 300); call_out((: CheckMem :), 60); set_heart_beat(5); } static void heart_beat(){ #ifdef __FLUFFOS__ if(sizeof(get_garbage()) > 20000){ reap_other(); } #endif } int eventDestruct(){ if( !(master()->valid_apply(({ "SECURE" }))) ) error("Illegal attempt to destruct reaper: "+get_stack()+" "+identify(previous_object(-1))); return ::eventDestruct(); }
inline static void add_to_stack(const std::string& function_name) { get_stack().push_back(function_name); }
bool ndc::empty() { return get_stack().empty(); }
inline static void pop_stack() { get_stack().pop_back(); }
int add_pack(struct linked_list *item, int print_message) { struct object *obj, *op; int from_floor; if (item == NULL) { from_floor = TRUE; if ((item = find_obj(hero.y, hero.x)) == NULL) { msg("Nothing to pick up."); return(FALSE); } } else from_floor = FALSE; if (from_floor) { item = get_stack(item); if (!item) return(FALSE); } obj = OBJPTR(item); /* If it is gold, just add its value to rogue's purse and get rid of */ if (obj->o_type == GOLD) { struct linked_list *mitem; struct thing *tp; if (print_message) { if (!terse) addmsg("You found "); msg("%d gold pieces.", obj->o_count); } /* * First make sure no greedy monster is after this gold. If * so, make the monster run after the rogue instead. */ for (mitem = mlist; mitem != NULL; mitem = next(mitem)) { tp = THINGPTR(mitem); if (tp->t_horde==obj) { tp->t_ischasing = TRUE; tp->t_chasee = &player; tp->t_horde = NULL; } } /* * This will cause problems if people are able to drop and * pick up gold, or when GOLDSTEAL monsters are killed. */ /* Thieves get EXP for gold they pick up */ if (player.t_ctype == C_THIEF) { pstats.s_exp += obj->o_count / 4; check_level(); } purse += obj->o_count; if (from_floor) rem_obj(item, TRUE); /* Remove object from the level */ return (TRUE); } /* see if he can carry any more weight */ if (itemweight(obj) + pstats.s_pack > pstats.s_carry) { msg("Too much for you to carry."); if (print_message) { msg("%s onto %s", terse ? "Moved" : "You moved", inv_name(obj, LOWERCASE)); } return(FALSE); } /* * Link it into the pack. If the item can be grouped, try to find its * neighbors and bump the count. A special case is food, which can't * be grouped, but an exact match allows the count to get * incremented. */ if ((op = apply_to_bag(pack, obj->o_type, bff_group, NULL, obj)) != NULL) { op->o_count += obj->o_count; /* add it to the rest */ if (from_floor) rem_obj(item, FALSE); pack_report(op, print_message, "You now have "); return(TRUE); } /* Check for and deal with scare monster scrolls */ if (obj->o_type == SCROLL && obj->o_which == S_SCARE) if (obj->o_flags & ISCURSED) { msg("The scroll turns to dust as you pick it up."); rem_obj(item, TRUE); return(TRUE); } /* Check if there is room */ if (count_bag(pack, obj->o_type, NULL) == max_print()) { msg("You have no room for more %s.", name_type(obj->o_type)); if (print_message) { obj = OBJPTR(item); msg("%s onto %s.", terse ? "Moved" : "You moved", inv_name(obj, LOWERCASE)); } return(FALSE); } /* * finally, add the new item to the bag, and free up the linked list * on top of it. */ if (from_floor) rem_obj(item, FALSE); push_bag(&pack, obj); pack_report(obj, print_message, "You now have "); ur_free(item); return(TRUE); /* signal success */ }
/* Set stack bottom of Ruby implementation. * * You must call this function before any heap allocation by Ruby implementation. * Or GC will break living objects */ void ruby_init_stack(volatile VALUE *addr #ifdef __ia64 , void *bsp #endif ) { native_main_thread.id = pthread_self(); #ifdef STACK_END_ADDRESS native_main_thread.stack_start = STACK_END_ADDRESS; #else if (!native_main_thread.stack_start || STACK_UPPER((VALUE *)(void *)&addr, native_main_thread.stack_start > addr, native_main_thread.stack_start < addr)) { native_main_thread.stack_start = (VALUE *)addr; } #endif #ifdef __ia64 if (!native_main_thread.register_stack_start || (VALUE*)bsp < native_main_thread.register_stack_start) { native_main_thread.register_stack_start = (VALUE*)bsp; } #endif { size_t size = 0; size_t space = 0; #if MAINSTACKADDR_AVAILABLE void* stackaddr; STACK_GROW_DIR_DETECTION; get_stack(&stackaddr, &size); space = STACK_DIR_UPPER((char *)addr - (char *)stackaddr, (char *)stackaddr - (char *)addr); native_main_thread.stack_maxsize = size - space; #elif defined(HAVE_GETRLIMIT) int pagesize = getpagesize(); struct rlimit rlim; if (getrlimit(RLIMIT_STACK, &rlim) == 0) { size = (size_t)rlim.rlim_cur; } addr = native_main_thread.stack_start; if (IS_STACK_DIR_UPPER()) { space = ((size_t)((char *)addr + size) / pagesize) * pagesize - (size_t)addr; } else { space = (size_t)addr - ((size_t)((char *)addr - size) / pagesize + 1) * pagesize; } native_main_thread.stack_maxsize = space; #endif } /* If addr is out of range of main-thread stack range estimation, */ /* it should be on co-routine (alternative stack). [Feature #2294] */ { void *start, *end; if (IS_STACK_DIR_UPPER()) { start = native_main_thread.stack_start; end = (char *)native_main_thread.stack_start + native_main_thread.stack_maxsize; } else { start = (char *)native_main_thread.stack_start - native_main_thread.stack_maxsize; end = native_main_thread.stack_start; } if ((void *)addr < start || (void *)addr > end) { /* out of range */ native_main_thread.stack_start = (VALUE *)addr; native_main_thread.stack_maxsize = 0; /* unknown */ } } }
void ndc::push( const context_type& _context ) { get_stack().push( _context ); }
#include <daemons.h> #include <message_class.h> inherit LIB_DAEMON; static void MainMenu(); static void EditErrorMessage(string emote); static void ShowEmote(string emote); static void AddEmote(string emote); static void AddRule(string rule, string emote); static private void validate() { if(!this_player()) return 0; if( !((int)master()->valid_apply(({ "ASSIST" }))) && !member_group(this_player(), "EMOTES") ) error("Illegal attempt to access addemote: "+get_stack()+" "+identify(previous_object(-1))); } static void EnterEmote(string emote, string array emotes) { int x = to_int(emote); validate(); if( x < 1 || x > sizeof(emotes) ) { if( member_array(emote, emotes) == -1 ) { if( emote[0] == 'q' ) { return; } MainMenu(); return; } } else {