orca.cpp

#include "pbvm.h"
#include <eh.h>

/*
These are the implementations of the n_pb_orca class methods
*/

typedef struct pborca_comperr
{
    INT     iLevel;                         /* Error level */
    wchar_t *   lpszMessageNumber;              /* Pointer to message number */
    wchar_t *   lpszMessageText;                /* Pointer to message text */
    UINT    iColumnNumber;                  /* Column number */
    UINT	iLineNumber;                    /* Line number */
} PBORCA_COMPERR, FAR *PPBORCA_COMPERR;

#define PBCALLBACK(r,n) r ( CALLBACK n )
typedef PBCALLBACK(void, *PBORCA_ERRPROC) ( PPBORCA_COMPERR, LPVOID );

typedef struct{
	vm_state *vm;
	pb_class *obj;
	int refs;
	HMODULE library;
	LPVOID (WINAPI *PBORCA_SessionOpen)			( void );
	VOID  (WINAPI *PBORCA_SessionClose)			( LPVOID hORCASession );
	INT (WINAPI *PBORCA_SessionSetLibraryList)	( LPVOID hORCASession, wchar_t **pLibNames, INT iNumberOfLibs );
	INT (WINAPI *PBORCA_SessionSetCurrentAppl)	( LPVOID hORCASession, wchar_t *lpszApplLibName, wchar_t *lpszApplName );
	VOID (WINAPI *PBORCA_SessionGetError)		( LPVOID hORCASession, wchar_t *buff, int buff_size );
	INT (WINAPI *PBORCA_ApplicationRebuild)		( LPVOID hORCASession, int eRebldType, PBORCA_ERRPROC pCompErrProc, LPVOID pUserData );
	INT (WINAPI *PBORCA_CompileEntryImport)		( LPVOID hORCASession, wchar_t *lpszLibraryName, wchar_t *lpszEntryName, int otEntryType, wchar_t *lpszComments, wchar_t *lpszEntrySyntax, LONG lEntrySyntaxBuffSize, PBORCA_ERRPROC pCompErrProc, LPVOID pUserData );
	INT (WINAPI *PBORCA_CompileEntryRegenerate) ( LPVOID hORCASession, wchar_t *lpszLibraryName, wchar_t *lpszEntryName, int otEntryType, PBORCA_ERRPROC pCompErrProc, LPVOID pUserData );
bool unicode;
}orca_state;

typedef void (*_se_translator_function)(unsigned int, struct _EXCEPTION_POINTERS* );

void SeTrans(unsigned int x, struct _EXCEPTION_POINTERS *p){
	throw p->ExceptionRecord->ExceptionCode;
}

wchar_t* convert_w2a(wchar_t*p){
	size_t bytes=wcstombs(NULL,p,0);
	char *ret=new char[bytes+1];
	wcstombs(ret,p,bytes+1);
	return (wchar_t*)ret;
}

void __stdcall ErrorProc(PPBORCA_COMPERR error, LPVOID *parm){
	orca_state *state=(orca_state *)parm;
	value val;

	if (!state->unicode){
		size_t chars=mbstowcs(NULL,(char*)error->lpszMessageText,0) +1;
		wchar_t*dest = (wchar_t*)pbstg_alc(state->vm, chars *2, GET_HEAP(state->vm));
		mbstowcs(dest,(char*)error->lpszMessageText,chars);
		val.value=(DWORD)dest;
	}else{
		int buff_size=wcslen(error->lpszMessageText)+1;
		wchar_t*dest = (wchar_t*)pbstg_alc(state->vm, buff_size *2, GET_HEAP(state->vm));
		wcscpy(dest,error->lpszMessageText);
		val.value=(DWORD)dest;
	}
	val.type=pbvalue_string;
	val.flags=0x0d00;

	rtRoutineExec(state->vm, 0, state->obj, 0, 0, &val, 1, 21, 1, 0);
	/*TODO
	invoke method? (error->lpszMessageText)
	*/
}

void check_orca_error(vm_state *vm, orca_state *state, LPVOID session, int ret){
	wchar_t buff[256];
	state->PBORCA_SessionGetError(session, buff, 256);
	if (!state->unicode){
		wchar_t buff2[256];
		mbstowcs(buff2,(char*)buff,256);
		Throw_Exception(vm,buff2);
	}else{
		Throw_Exception(vm,buff);
	}
}


DWORD __declspec(dllexport) __stdcall Orca_Destroy (vm_state *vm, DWORD arg_count){
	value field;
	DWORD isvalid;
	pb_class *obj;

	ot_get_curr_obinst_expr(vm, &obj, &isvalid);
	ob_get_field(vm, obj, 1, &field);
	if (field.value){
		orca_state *state=(orca_state*)field.value;
		state->refs --;
		if (state->refs==0){
			if (state->library)
				FreeLibrary(state->library);
			delete state;
		}
	}
	ot_no_return_val(vm);
	return 1;
}

DWORD __declspec(dllexport) __stdcall Orca_Init (vm_state *vm, DWORD arg_count){
	value field;
	DWORD isvalid, isnull;
	orca_state *state;
	pb_class *obj;

	last_vm = vm;

	ot_get_curr_obinst_expr(vm, &obj, &isvalid);
	ob_get_field(vm, obj, 1, &field);
	if (field.value){
		Throw_Exception(vm, L"Orca object already initialised");
		return 1;
	}
	state=new orca_state;
	state->refs=1;
	field.value=(DWORD)state;
	ob_set_field(vm,obj,1,&field);

	wchar_t *dll=(wchar_t *)ot_get_valptr_arg(vm, &isnull);
	if (isnull){
		Throw_Exception(vm, L"Dll name expected");
		return 1;
	}
	state->unicode=(bool)ot_get_simple_intarg(vm, &isnull);
	
	state->library=LoadLibrary(dll);
	if (!state->library){
		Throw_Exception(vm, L"Unable to load orca dll \"%s\"",dll);
		return 1;
	}

	state->PBORCA_SessionOpen				=(LPVOID(WINAPI *)(void))GetProcAddress(state->library,"PBORCA_SessionOpen");
	state->PBORCA_SessionClose				=(void (WINAPI *)(LPVOID))GetProcAddress(state->library,"PBORCA_SessionClose");
	state->PBORCA_SessionSetLibraryList		=(INT (WINAPI *) (LPVOID, wchar_t **, INT))GetProcAddress(state->library,"PBORCA_SessionSetLibraryList");
	state->PBORCA_SessionSetCurrentAppl		=(INT (WINAPI *) (LPVOID, wchar_t *, wchar_t *))GetProcAddress(state->library,"PBORCA_SessionSetCurrentAppl");
	state->PBORCA_SessionGetError			=(void (WINAPI *) (LPVOID, wchar_t *, int))GetProcAddress(state->library,"PBORCA_SessionGetError");
	state->PBORCA_ApplicationRebuild		=(INT (WINAPI *) (LPVOID, int, PBORCA_ERRPROC, LPVOID))GetProcAddress(state->library,"PBORCA_ApplicationRebuild");
	state->PBORCA_CompileEntryImport		=(INT (WINAPI *) (LPVOID, wchar_t *, wchar_t *, int, wchar_t *, wchar_t *, LONG, PBORCA_ERRPROC, LPVOID))GetProcAddress(state->library,"PBORCA_CompileEntryImport");
	state->PBORCA_CompileEntryRegenerate	=(INT (WINAPI *) (LPVOID, wchar_t *, wchar_t *, int, PBORCA_ERRPROC, LPVOID))GetProcAddress(state->library,"PBORCA_CompileEntryRegenerate");
	
	ot_no_return_val(vm);
	return 1;
}

DWORD __declspec(dllexport) __stdcall Orca_Session_Open (vm_state *vm, DWORD arg_count){
	value field, ret;
	DWORD isvalid;
	orca_state *state;
	pb_class *obj, *session;
	
	_se_translator_function old=_set_se_translator(SeTrans);

	try{

		ot_get_curr_obinst_expr(vm, &obj, &isvalid);
		ob_get_field(vm, obj, 1, &field);
		state=(orca_state*)field.value;
		
		lvalue_ref *session_arg = ot_get_next_lvalue_arg(vm, &isvalid);
		ot_create_obinst_at_lval(vm, session_arg, 0, 0);
		session = (pb_class *)get_lvalue(vm, session_arg)->value;
		
		state->refs++;
		ob_set_field(vm, session, 1, &field);

		ob_get_field(vm, session, 2, &field);
		field.value=(DWORD)state->PBORCA_SessionOpen();
		if (!field.value){
			Throw_Exception(vm,L"Session open failed");
			return 1;
		}
		ob_set_field(vm, session, 2, &field);

		ret.value=(DWORD)session;

		ret.type=0x8000u;
		ret.flags=0xD00u;
		ot_set_return_val(vm, &ret);
	}catch(DWORD code){
		Throw_Exception(vm,L"Error %x during of_create_orca_session",code);
	}catch(...){
		Throw_Exception(vm,L"Unknown error during of_create_orca_session");
	}
	_set_se_translator(old);
	return 1;
}

DWORD __declspec(dllexport) __stdcall Orca_Session_Close (vm_state *vm, DWORD arg_count){
	value field;
	DWORD isvalid;
	pb_class *session;
	
	ot_get_curr_obinst_expr(vm, &session, &isvalid);
	ob_get_field(vm, session, 1, &field);
	orca_state *state=(orca_state*)field.value;
	state->refs --;
	ob_get_field(vm, session, 2, &field);
	state->PBORCA_SessionClose((LPVOID)field.value);

	if (state->refs==0){
		if (state->library)
			FreeLibrary(state->library);
		delete state;
	}

	ot_no_return_val(vm);
	return 1;
}

DWORD __declspec(dllexport) __stdcall Orca_Set_Target (vm_state *vm, DWORD arg_count){
	value field;
	DWORD isvalid;
	pb_class *session;

	_se_translator_function old=_set_se_translator(SeTrans);

	try{

		ot_get_curr_obinst_expr(vm, &session, &isvalid);
		ob_get_field(vm, session, 1, &field);
		orca_state *state=(orca_state*)field.value;

		ob_get_field(vm, session, 2, &field);
		
		value *v_value = ot_get_next_evaled_arg_no_convert(vm);
		pb_array *libs=(pb_array *)v_value->value;
		
		int count = ot_array_num_items(vm, libs);
		wchar_t **lib_list = new wchar_t*[count];

		for (long i=0;i<count;i++){
			value *v=ot_array_index(vm, libs, i);
			if (!state->unicode){
				lib_list[i]=convert_w2a((wchar_t*)v->value);
			}else{
				lib_list[i]=(wchar_t*)v->value;
			}
		}

		int ret=state->PBORCA_SessionSetLibraryList((LPVOID)field.value,lib_list,count);
		if (!state->unicode){
			for (long i=0;i<count;i++){
				delete lib_list[i];
			}
		}
		delete lib_list;
		if (ret!=0){
			check_orca_error(vm, state, (LPVOID)field.value, ret);
			return 1;
		}

		wchar_t *appl_lib=(wchar_t *)ot_get_valptr_arg(vm, &isvalid);
		wchar_t *appl=(wchar_t *)ot_get_valptr_arg(vm, &isvalid);
		
		if (!state->unicode){
			appl_lib=convert_w2a(appl_lib);
			appl=convert_w2a(appl);
		}

		ret = state->PBORCA_SessionSetCurrentAppl((LPVOID)field.value,appl_lib,appl);
		if (!state->unicode){
			delete appl_lib;
			delete appl;
		}
		if (ret!=0){
			check_orca_error(vm, state, (LPVOID)field.value, ret);
			return 1;
		}

		ot_no_return_val(vm);
	}catch(DWORD code){
		Throw_Exception(vm,L"Error %x during of_set_target",code);
	}catch(...){
		Throw_Exception(vm,L"Unknown error during of_set_target");
	}
	_set_se_translator(old);
	return 1;
}

DWORD __declspec(dllexport) __stdcall Orca_Import (vm_state *vm, DWORD arg_count){
	value field;
	DWORD isvalid;
	pb_class *session;

	_se_translator_function old=_set_se_translator(SeTrans);

	try{

		ot_get_curr_obinst_expr(vm, &session, &isvalid);
		ob_get_field(vm, session, 1, &field);
		orca_state *state=(orca_state*)field.value;

		ob_get_field(vm, session, 2, &field);
		
		wchar_t *lib=(wchar_t *)ot_get_valptr_arg(vm, &isvalid);
		wchar_t *entry=(wchar_t *)ot_get_valptr_arg(vm, &isvalid);
		short ent_type = ot_get_simple_intarg(vm, &isvalid);
		wchar_t *comment=(wchar_t *)ot_get_valptr_arg(vm, &isvalid);
		wchar_t *syntax=(wchar_t *)ot_get_valptr_arg(vm, &isvalid);
		if (!state->unicode){
			lib=convert_w2a(lib);
			entry=convert_w2a(entry);
			comment=convert_w2a(comment);
			syntax=convert_w2a(syntax);
		}
		int syntax_len=wcslen(syntax)*2;
		
		state->vm=vm;
		state->obj=session;
		int ret = state->PBORCA_CompileEntryImport((LPVOID)field.value,lib,entry,ent_type,comment,syntax,syntax_len,(PBORCA_ERRPROC)ErrorProc,(LPVOID)state);
		if (!state->unicode){
			delete lib;
			delete entry;
			delete comment;
			delete syntax;
		}
		if (ret!=0){
			check_orca_error(vm, state, (LPVOID)field.value, ret);
			return 1;
		}

		ot_no_return_val(vm);
	}catch(DWORD code){
		Throw_Exception(vm,L"Error %x during of_import",code);
	}catch(...){
		Throw_Exception(vm,L"Unknown error during of_import");
	}
	_set_se_translator(old);
	return 1;
}

DWORD __declspec(dllexport) __stdcall Orca_Regenerate (vm_state *vm, DWORD arg_count){
	value field;
	DWORD isvalid;
	pb_class *session;

	ot_get_curr_obinst_expr(vm, &session, &isvalid);
	ob_get_field(vm, session, 1, &field);
	orca_state *state=(orca_state*)field.value;

	ob_get_field(vm, session, 2, &field);
	
	wchar_t *lib=(wchar_t *)ot_get_valptr_arg(vm, &isvalid);
	wchar_t *entry=(wchar_t *)ot_get_valptr_arg(vm, &isvalid);
	short ent_type = ot_get_simple_intarg(vm, &isvalid);
	
	if (!state->unicode){
		lib=convert_w2a(lib);
		entry=convert_w2a(entry);
	}

	state->vm=vm;
	state->obj=session;
	int ret = state->PBORCA_CompileEntryRegenerate((LPVOID)field.value,lib,entry,ent_type,(PBORCA_ERRPROC)ErrorProc,(LPVOID)state);
	if (!state->unicode){
		delete lib;
		delete entry;
	}
	if (ret!=0){
		check_orca_error(vm, state, (LPVOID)field.value, ret);
		return 1;
	}

	ot_no_return_val(vm);
	return 1;
}

DWORD __declspec(dllexport) __stdcall Orca_Rebuild (vm_state *vm, DWORD arg_count){
	value field;
	DWORD isvalid;
	pb_class *session;

	ot_get_curr_obinst_expr(vm, &session, &isvalid);
	ob_get_field(vm, session, 1, &field);
	orca_state *state=(orca_state*)field.value;

	ob_get_field(vm, session, 2, &field);

	short rebuild_type = ot_get_simple_intarg(vm, &isvalid);

	state->vm=vm;
	state->obj=session;
	int ret = state->PBORCA_ApplicationRebuild((LPVOID)field.value, rebuild_type, (PBORCA_ERRPROC)ErrorProc, (LPVOID)state);
	if (ret!=0){
		check_orca_error(vm, state, (LPVOID)field.value, ret);
		return 1;
	}

	ot_no_return_val(vm);
	return 1;
}
/*
DWORD __declspec(dllexport) __stdcall Orca_Create_Exe (vm_state *vm, DWORD arg_count){
	value field;
	DWORD isvalid;
	pb_class *session;

	ot_get_curr_obinst_expr(vm, &session, &isvalid);
	ob_get_field(vm, session, 1, &field);
	orca_state *state=(orca_state*)field.value;

	ob_get_field(vm, session, 2, &field);
	

	int ret = state->PBORCA_SetExeInfo((LPVOID)field.value,);
	if (ret!=0){
		check_orca_error(vm, state, (LPVOID)field.value, ret);
		return 1;
	}
	int ret = state->PBORCA_ExecutableCreate((LPVOID)field.value,);
	if (ret!=0){
		check_orca_error(vm, state, (LPVOID)field.value, ret);
		return 1;
	}

	ot_no_return_val(vm);
	return 1;
}*/