#include <proto/exec.h>
#include <exec/interrupts.h>
 
uint32 trapCode(struct ExceptionContext *ctx, struct ExecBase *SysBase, 
	APTR userData)
{
	struct ExecIFace *IExec = (struct ExecIFace *)SysBase->MainInterface;
 
	IExec->DebugPrintF("Exception at instruction pointer %p\n",
	ctx->ip);
	/* To recover from this, we need to skip the offending instruction,
	 * otherwise, it will re-try the instruciton.
	 * Note: This depends on the type of instruction. Refer to the
	 * "PowerPC Programming Environments for 32 bit Microprocessors"
	 * book for more information.
	 */
	ctx->ip += 4;
 
	return 1;
}
 
int main(int argc, char **argv)
{
	/* This functions sets an exception handler for catching "trap" 
	 * instructions. See <exec/interrupts> for a list of possible
	 * exceptions
	 */
	IExec->SetTaskTrap(TRAPNUM_TRAP, &trapCode, 0);
 
	/* Generate an exception */
	__asm volatile ("trap");
 
	return 0;
}

#include <dos.h>
#include <stdio.h>
#include <proto/exec.h>
#include <exec/types.h>
#include <exec/nodes.h>
#include <exec/interrupts.h>
#include <exec/tasks.h>
#include <dos/dos.h>
 
struct TrapData
{
	struct Task *MasterTask;
	ULONG 	 MasterSignal;
	struct Task *TrappedTask;
	APTR 	 TrapCode;
	ULONG	Address;
};
 
uint32 TrapCode(struct ExceptionContext *ctx, struct ExecBase *SysBase, struct TrapData *TrapData)
{
	struct ExecIFace *IExec = (struct ExecIFace *)SysBase->MainInterface;
	struct Task *Task;
 
	Task=IExec->FindTask(0);
	TrapData->TrappedTask=Task;
	TrapData->TrapCode=Task->tc_TrapCode;
	TrapData->Address=ctx->dar;
 
	IExec->Signal(TrapData->MasterTask, TrapData->MasterSignal);
	ctx->ip += 4;
 
	return 0;
}
 
int main(int argc, char **argv)
{
    __check_abort_enabled=FALSE;
 
	struct Interrupt *TrapInt, *TrapVector;
	struct TrapData TrapData;
	ULONG signal, mask, except, action=1,received;
 
	signal=IExec->AllocSignal(-1);
	if (signal==-1)
	{
	printf("Unable to allocate signal.\n");
	return(0);
	}
	mask=1<<signal;
	TrapData.MasterTask=IExec->FindTask(0);
	TrapData.MasterSignal=mask;
 
	TrapInt=IExec->AllocSysObjectTags(ASOT_INTERRUPT, ASOINTR_Code, TrapCode, ASOINTR_Data, TrapData, TAG_END);
	if (!TrapInt)
	{
	printf("Unable to allocate interrupt.\n");
	IExec->FreeSignal(signal);
	return(0);
	}
 
	TrapInt->is_Node.ln_Succ=0;
	TrapInt->is_Node.ln_Pred=0;
	TrapInt->is_Node.ln_Type=NT_EXTINTERRUPT;
	TrapInt->is_Node.ln_Pri=0;
	TrapInt->is_Node.ln_Name="TrapIntServer";
	TrapInt->is_Data=&TrapData;
	TrapInt->is_Code=(APTR)&TrapCode;
 
	TrapVector=IExec->SetIntVector(TRAPNUM_DATA_SEGMENT_VIOLATION, TrapInt);
 
	while (action)
	{
	received=IExec->Wait(mask|SIGBREAKF_CTRL_C);
 
	if (received & mask) printf("Exception caught! Task: $%lx TrapCode: $%lx Address: $%lx\\n",TrapData.TrappedTask,TrapData.TrapCode,TrapData.Address);
	if (received & SIGBREAKF_CTRL_C) action=0;
	}
 
	printf("Teminated.\n");
 
	IExec->SetIntVector(TRAPNUM_TRAP,TrapVector);
	IExec->FreeSysObject(ASOT_INTERRUPT,TrapInt);
	IExec->FreeSignal(signal);
 
	return (0);
}

-> CIA hardware access test
 
PROC main()
  DEF ciaa=$bfe001:PTR TO CHAR, ciab=$bfd000:PTR TO CHAR, custom=$dff000, i
 
  FOR i:=0 TO 15
    ciaa[i*16*16]:=i*16+i
    ciab[i*16*16]:=i*16+i
  ENDFOR
 
  Delay(5)
ENDPROC

#include <proto/exec.h>
#include <exec/types.h>
#include <exec/nodes.h>
#include <exec/interrupts.h>
#include <exec/tasks.h>
#include <hardware/intbits.h>
#include <dos/dos.h>
 
struct IntData
{
	ULONG Task;
	ULONG Data;
};
 
uint32 TrapCode(struct ExceptionContext *ctx, struct ExecBase *SysBase, struct IntData *Data)
{
	struct ExecIFace *IExec = (struct ExecIFace *)SysBase->MainInterface;
 
	Data->Data++;
	if (Data->Data==100) IExec->Signal((struct Task *)Data->Task, SIGF_SINGLE);
 
	return 0;
}
 
int main(int argc, char **argv)
{
	struct Interrupt TrapIs;
	struct IntData Data;
	ULONG flags;
	ULONG running=1;
 
	Data.Task=(ULONG) IExec->FindTask(0);
	Data.Data=0;
 
	TrapIs.is_Node.ln_Succ=0;
	TrapIs.is_Node.ln_Pred=0;
	TrapIs.is_Node.ln_Type=NT_EXTINTERRUPT;
	TrapIs.is_Node.ln_Pri=11;
	TrapIs.is_Node.ln_Name="TrapInt";
	TrapIs.is_Code=(APTR)&TrapCode;
	TrapIs.is_Data=&Data;
 
	IExec->AddIntServer(INTB_VERTB, &TrapIs);
 
	do
	{
	flags=IExec->Wait(SIGF_SINGLE|SIGBREAKF_CTRL_C);
	if (flags==SIGF_SINGLE) printf("Exception caught!\n");
	if (flags==SIGBREAKF_CTRL_C) running=0;
	}
	while (running);
	IExec->RemIntServer(INTB_VERTB, &TrapIs);
 
	return 0;
}