コード例 #1
0
ファイル: plugin.c プロジェクト: AtalAkbari/geany-plugins
/* Called by Geany before unloading the plugin.
 * Here any UI changes should be removed, memory freed and any other finalization done.
 * Be sure to leave Geany as it was before plugin_init(). */
void plugin_cleanup(void)
{
	/* stop debugger if running */
	if (DBS_IDLE != debug_get_state())
	{
		debug_stop();
		while (DBS_IDLE != debug_get_state())
			g_main_context_iteration(NULL,FALSE);
	}

	config_destroy();
	pixbufs_destroy();
	debug_destroy();
	breaks_destroy();
	dpaned_destroy();
	envtree_destroy();
	
	/* release other allocated strings and objects */
	gtk_widget_destroy(hbox);
}
コード例 #2
0
ファイル: oneshot.c プロジェクト: Numeromancer/liquorice
/*
 * oneshot_attach()
 *	Attach a timer to the list.
 */
void oneshot_attach(struct oneshot *timer)
{
	spinlock_lock(&oneshot_lock);

	if (DEBUG) {
		if (timer->os_next) {
			debug_stop();
			while (1) {
				debug_print_pstr("\fAttach timer: ");
				debug_print16((addr_t)timer);
				debug_print_pstr(" - is already");
				debug_wait_button();
				debug_stack_trace();
			}
		}
	}
	
	timer->os_next = oneshot_list;
	oneshot_list = timer;
        oneshot_ref(timer);
					
	spinlock_unlock(&oneshot_lock);
}
コード例 #3
0
ファイル: callbacks.c プロジェクト: BYC/geany-plugins
/*
 * 	Occures when key is pressed.
 * 	Handles debug Run/Stop/... and add/remove breakpoint activities  
 */
gboolean keys_callback(guint key_id)
{
	switch (key_id)
	{
		case KEY_RUN:
			debug_run();
			break;
		case KEY_STOP:
			debug_stop();
			break;
		case KEY_RESTART:
			debug_restart();
			break;
		case KEY_STEP_OVER:
			debug_step_over();
			break;
		case KEY_STEP_INTO:
			debug_step_into();
			break;
		case KEY_STEP_OUT:
			debug_step_out();
			break;
		case KEY_EXECUTE_UNTIL:
		{
			GeanyDocument *doc = document_get_current();
			if (doc)
			{
				int line = sci_get_current_line(doc->editor->sci) + 1;
				debug_execute_until(DOC_FILENAME(doc), line);
			}
			break;
		}
		case KEY_BREAKPOINT:
		{
			GeanyDocument *doc = document_get_current();
			if (doc)
			{
				int line = sci_get_current_line(doc->editor->sci) + 1;
				break_state	bs = breaks_get_state(DOC_FILENAME(doc), line);
				if (BS_NOT_SET == bs)
					breaks_add(DOC_FILENAME(doc), line, NULL, TRUE, 0);
				else if (BS_ENABLED == bs)
					breaks_remove(DOC_FILENAME(doc), line);
				else if (BS_DISABLED == bs)
					breaks_switch(DOC_FILENAME(doc), line);
				
				scintilla_send_message(doc->editor->sci, SCI_SETFOCUS, TRUE, 0);
			}
			break;
		}
		case KEY_CURRENT_INSTRUCTION:
		{
			if (DBS_STOPPED == debug_get_state() && debug_current_instruction_have_sources())
			{
				debug_jump_to_current_instruction();
				gtk_widget_set_sensitive(tab_call_stack, FALSE);
				stree_select_first_frame(FALSE);
				gtk_widget_set_sensitive(tab_call_stack, TRUE);
			}
		}
	}
	
	return TRUE;
} 
コード例 #4
0
ファイル: kerext_debug.c プロジェクト: vocho/openqnx
static void
kerext_debug_process(void *args) {
	PROCESS							*prp;
	THREAD							*thp, *act = actives[KERNCPU];
	DEBUG							*dep;
	struct kerargs_debug_process	*kap = args;
	int								status;
	int								stopped;
	int								tid;

	if(!(prp = lookup_pid(kap->pid))) {
		kererr(act, ESRCH);
		return;
	}

	dep = prp->debugger;

	if(kap->request == NTO_DEBUG_PROCESS_INFO || (prp->flags & _NTO_PF_TERMING)) {
		tid = 0;
	} else if(dep && kap->tid == 0) {
		tid = dep->tid + 1;
	} else {
		tid = kap->tid;
	}

	thp = 0;
	if(tid > 0 && !(thp = vector_search(&prp->threads, tid - 1,
			(kap->request == NTO_DEBUG_THREAD_INFO ||
			kap->request == NTO_DEBUG_STOP) ? (unsigned *)&tid : 0))) {
		kererr(act, ESRCH);
		return;
	}

	stopped = 0;
	if(thp && ((thp->flags & _NTO_TF_TO_BE_STOPPED) ||
			(thp->state != STATE_RUNNING && thp->state != STATE_READY))) {
		stopped = 1;
	}

	status = EINVAL;
	switch(kap->request) {
	case NTO_DEBUG_PROCESS_INFO:		// pid:na:debug_process_t
		status =  debug_process(prp, &kap->data->process);
		break;

	case NTO_DEBUG_THREAD_INFO:			// pid:tid:debug_thread_t
		status = debug_thread(prp, thp, &kap->data->thread);
		break;

	case NTO_DEBUG_GET_GREG:			// pid:tid:debug_greg_t
		if(thp) {
			memcpy(&kap->data->greg, &thp->reg, sizeof thp->reg);
			status = EOK;
		}
		break;

	case NTO_DEBUG_SET_GREG:			// pid:tid:debug_greg_t
		if(stopped) {
			lock_kernel();
			cpu_greg_load(thp, (CPU_REGISTERS *)&kap->data->greg);
			status = EOK;
		}
		break;

	case NTO_DEBUG_GET_FPREG:			// pid:tid:debug_fpreg_t
		if(thp) {
			FPU_REGISTERS	*fpudata = FPUDATA_PTR(thp->fpudata);
			int				cpu = FPUDATA_CPU(thp->fpudata);

			status = ENXIO;
			if(fpudata) {
				if(FPUDATA_INUSE(thp->fpudata) && cpu != KERNCPU) {
					// In use on another CPU; send ipi, restart kernel call
					SENDIPI(cpu, IPI_CONTEXT_SAVE);
					KERCALL_RESTART(act);
					return;
				}
				if(actives_fpu[thp->runcpu] == thp) {
					if(KERNCPU == thp->runcpu) {
						cpu_force_fpu_save(thp);
						actives_fpu[KERNCPU] = NULL;
					} else {
						// We should not get here
						crash();
					}
				}
				memcpy(&kap->data->fpreg, fpudata, sizeof *fpudata);
				status = EOK;
			} else if(thp->un.lcl.tls && thp->un.lcl.tls->__fpuemu_data) {
// @@@ NEED TO FIND PROPER SIZE OF EMULATOR DATA
				memcpy(&kap->data->fpreg, thp->un.lcl.tls->__fpuemu_data, sizeof(*fpudata) + 256);
				status = EOK;
			}
		}
		break;
			
	case NTO_DEBUG_SET_FPREG:			// pid:tid:debug_fpreg_t
		if(thp && stopped) {
			FPU_REGISTERS	*fpudata = FPUDATA_PTR(thp->fpudata);
			int				cpu = FPUDATA_CPU(thp->fpudata);

			status = ENXIO;
			if(thp->fpudata) {
				if(FPUDATA_INUSE(thp->fpudata) && cpu != KERNCPU) {
					// In use on another CPU; send ipi, restart kernel call
					SENDIPI(cpu, IPI_CONTEXT_SAVE);
					KERCALL_RESTART(act);
					return;
				}
				if(actives_fpu[thp->runcpu] == thp) {
					if(KERNCPU == thp->runcpu) {
						cpu_force_fpu_save(thp);
						actives_fpu[KERNCPU] = NULL;
					} else {
						// We should not get here
						crash();
					}
				}
				memcpy(fpudata, &kap->data->fpreg, sizeof *fpudata);
				status = EOK;
			} else if(thp->un.lcl.tls && thp->un.lcl.tls->__fpuemu_data) {
// @@@ NEED TO FIND PROPER SIZE OF EMULATOR DATA
				memcpy(thp->un.lcl.tls->__fpuemu_data, &kap->data->fpreg, sizeof(*fpudata) + 256);
				status = EOK;
			}
		}
		break;

	case NTO_DEBUG_STOP:				// pid:na:na
		if(dep) {
			status =  debug_stop(prp);
		}
		break;

	case NTO_DEBUG_RUN:					// pid:tid:debug_run_t
		if(dep && stopped) {
			status = debug_run(prp, &kap->data->run);
		}
		break;

	case NTO_DEBUG_CURTHREAD:			// pid:tid:NULL
		if(dep) {
			lock_kernel();
			SETKSTATUS(act, dep->tid + 1);
			if(thp) {
				dep->tid = thp->tid;
			}
			return;
		}
		break;

	case NTO_DEBUG_FREEZE:				// pid:tid:NULL
		if(thp == NULL){
			status = EINVAL;
			break;
		}
		if(stopped) {
			lock_kernel();
			thp->flags |= _NTO_TF_FROZEN;
		}
		break;

	case NTO_DEBUG_THAW:				// pid:tid:NULL
		if(thp == NULL){
			status = EINVAL;
			break;
		}
		if(stopped) {
			lock_kernel();
			thp->flags &= ~_NTO_TF_FROZEN;
		}
		break;

	case NTO_DEBUG_BREAK:				// pid:na:debug_break_t
		if(dep && stopped) {
			status = debug_break(prp, &kap->data->brk);
		}
		break;

	case NTO_DEBUG_GET_BREAKLIST:		// pid:na:debug_breaklist_t
		status = debug_break_list(prp, &kap->data->brklist);
		break;

	case NTO_DEBUG_SET_FLAG:			// pid:na:uint32_t
		if(dep && !(kap->data->flags & ~_DEBUG_FLAG_MASK)) {
			lock_kernel();
			dep->flags |= kap->data->flags;
		}
		break;

	case NTO_DEBUG_CLEAR_FLAG:			// pid:na:uint32_t
		if(dep && !(kap->data->flags & ~_DEBUG_FLAG_MASK)) {
			lock_kernel();
			dep->flags &= ~kap->data->flags;
		}
		break;

	case NTO_DEBUG_GET_ALTREG:			// pid:tid:debug_altreg_t
		if(thp) {
			status = cpu_debug_get_altregs(thp, &kap->data->altreg);
		}
		break;

	case NTO_DEBUG_SET_ALTREG:			// pid:tid:debug_altreg_t
		if(thp) {
			status = cpu_debug_set_altregs(thp, &kap->data->altreg);
		}
		break;

	case NTO_DEBUG_GET_PERFREG:
		if ( thp ) {
			status = cpu_debug_get_perfregs(thp, &kap->data->perfreg);
		}
		break;

	case NTO_DEBUG_SET_PERFREG:
		if ( thp && !stopped )
			status = EINVAL;
		else {
			if ( (kap->data->flags & ~PERFREGS_ENABLED_FLAG) == cpu_perfreg_id() ) {
				status = cpu_debug_set_perfregs(thp, &kap->data->perfreg);
			}
			else
				status = ENODEV;
		}
		break;
	}

	if(status != EOK) {
		kererr(act, status);
	} else {
		lock_kernel();
		SETKSTATUS(act, 0);
	}
}
コード例 #5
0
ファイル: main.c プロジェクト: erossi/opengarden
/*! main */
int main(void)
{
	struct debug_t *debug;
	struct programs_t *progs;
	struct cmdli_t *cmdli;
	/* convenient pre-allocated structure */
	struct tm *tm_clock;
	char c;

	/* anti warning for non initialized variables */
	debug = NULL;
	progs = NULL;
	cmdli = NULL;
	tm_clock = NULL;

	/* Init sequence, turn on both led */
	led_init();
	led_set(BOTH, ON);

	io_init();
	usb_init();
	debug = debug_init(debug);
	progs = prog_init(progs);
	cmdli = cmdli_init(cmdli);
	tm_clock = date_init(tm_clock, debug);
        set_sleep_mode(SLEEP_MODE_PWR_SAVE);
	sei();
	date_hwclock_start();
	led_set(BOTH, OFF);

	while (1) {
		/* PC is connected but debug is off. */
		if (usb_connected && (!debug->active))
			debug_start(debug);

		if (debug->active && (!usb_connected))
			debug_stop(debug);

		/* If PC is connected
		 * then check for a command sent from the user
		 * and execute it.
		 * Anyway do NOT go to sleep.
		 */
		if (debug->active) {
			c = uart_getchar(0, 0);

			if (c) {
				/* echo */
				uart_putchar(0, c);
				cmdli_exec(c, cmdli, progs, debug);
			}
		} else {
			go_to_sleep(progs->valve, debug);

			if (prog_alarm(progs) && flag_get(progs, FL_LED))
				led_set(RED, BLINK);
		}

		/* if there is a job to do (open, close valves).
		 */
		if (date_timetorun(tm_clock, debug))
			job_on_the_field(progs, debug, tm_clock);
	}

	/* This part should never be reached */
	date_hwclock_stop();
	cli();
	date_free(tm_clock);
	cmdli_free(cmdli);
	prog_free(progs);
	debug_free(debug);

	return(0);
}