#include <pf/plugin.h>

char *pf_error(pf_error_t e){
#define DOCASE(x) case x: return #x ;
    switch(e){
	DOCASE(e_ok);
	DOCASE(e_generic);
	DOCASE(e_type);
	DOCASE(e_underflow);
	DOCASE(e_undef);
	DOCASE(e_internal);
	DOCASE(e_parse);
	DOCASE(e_unparse);
	DOCASE(e_file);
	DOCASE(e_syntax);
	DOCASE(e_pointer);
	DOCASE(e_access);
	DOCASE(e_list);
	DOCASE(e_eof);
	DOCASE(e_again);
	DOCASE(e_trap);
	DOCASE(e_interrupt);
	DOCASE(e_inval);
	DOCASE(e_exec);
	DOCASE(e_rewind);
	DOCASE(e_nodoc);
	DOCASE(e_index);
	DOCASE(e_badlink);
	DOCASE(e_user);
	DOCASE(e_exit);
	DOCASE(e_idle);
	DOCASE(e_init);
	DOCASE(e_fatal);
	DOCASE(e_abort);
    default:
	//PF_ASSERT(0);
	return "unknown error";
    }
}


#define DOCE(error, string) case error: sinfo = string; break

char *pf_error_info(pf_error_t e){
    char *sinfo;
    switch(e){
	   
	DOCE(e_type,      "invalid argument type");
	DOCE(e_pointer,   "null pointer dereference");
	DOCE(e_underflow, "word expects more arguments");
	DOCE(e_parse,     "parse error");  
	DOCE(e_unparse,   "can't serialize abstract object");  
	DOCE(e_syntax,    "syntax error"); // == e_parse ??
	DOCE(e_access,    "access denied");
	DOCE(e_trap,      "debugger trap");
	DOCE(e_interrupt, "user interrupt");
	DOCE(e_inval,     "invalid argument value");
	DOCE(e_eof,       "end of file");
	DOCE(e_internal,  "internal error (bug)");
	DOCE(e_idle,      "machine idle");
	DOCE(e_fatal,     "machine got fatal error");
	DOCE(e_init,      "subsystem not properly initialized");
	DOCE(e_badlink,   "bad link. (aborted during compilation?)");
	DOCE(e_abort,     "abort execution");
	
	DOCE(e_ok,        "e_ok: probably an error reporting bug");
	
    default:
	sinfo = "no more info"; break;
    }
    return sinfo;
}


/* error atoms */
#define PF_ERRORWORD(x) static PF_PRIMITIVE(err_##x) {pf_list_push(s, a_error, (pf_word_t)x); EXIT;}
PF_ERRORWORD(e_type);
PF_ERRORWORD(e_underflow);
PF_ERRORWORD(e_interrupt);
PF_ERRORWORD(e_undef);
PF_ERRORWORD(e_inval);
PF_ERRORWORD(e_internal);
PF_ERRORWORD(e_parse);
PF_ERRORWORD(e_file);
PF_ERRORWORD(e_syntax);
PF_ERRORWORD(e_pointer);
PF_ERRORWORD(e_access);
PF_ERRORWORD(e_list);
PF_ERRORWORD(e_trap);
PF_ERRORWORD(e_eof);
//PF_ERRORWORD(e_idle); // illegal to throw from inside forth: use throw-idle
PF_ERRORWORD(e_nodoc);
PF_ERRORWORD(e_ok);




/* error object */






PF_FUNCTION(pf_forth_errors){
    /* errors */
    PF_REGISTER_FUNCTION(err_e_type,      "e_type",       "( -- e_type )");
    PF_REGISTER_FUNCTION(err_e_undef,     "e_undef",      "( -- e_undef )");
    PF_REGISTER_FUNCTION(err_e_inval,     "e_inval",      "( -- e_inval )");
    PF_REGISTER_FUNCTION(err_e_syntax,    "e_syntax",     "( -- e_syntax )");
    PF_REGISTER_FUNCTION(err_e_pointer,   "e_pointer",    "( -- e_pointer )");
    PF_REGISTER_FUNCTION(err_e_list,      "e_list",       "( -- e_list )");
    PF_REGISTER_FUNCTION(err_e_internal,  "e_internal",   "( -- e_internal )");
    PF_REGISTER_FUNCTION(err_e_eof,       "e_eof",        "( -- e_eof )");
    PF_REGISTER_FUNCTION(err_e_ok,        "e_ok",         "( -- e_ok )");
    PF_REGISTER_FUNCTION(err_e_file,      "e_file",       "( -- e_file )");
    PF_REGISTER_FUNCTION(err_e_nodoc,     "e_nodoc",      "( -- e_nodoc )");
    PF_REGISTER_FUNCTION(err_e_underflow, "e_underflow",  "( -- e_underflow )");
    PF_REGISTER_FUNCTION(err_e_interrupt, "e_interrupt",  "( -- e_interrupt )");

    EXIT;
}

