/*
* Class: com_Revsoft_Wabbitemu_CalcInterface
* Method: CreateRom
* Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
*/
JNIEXPORT jint JNICALL Java_com_Revsoft_Wabbitemu_calc_CalcInterface_CreateRom
(JNIEnv *env, jclass classObj, jstring jOsPath, jstring jBootPath,
jstring jRomPath, jint model) {
checkThread();
const char *osPath = env->GetStringUTFChars(jOsPath, JNI_FALSE);
const char *bootPath = env->GetStringUTFChars(jBootPath, JNI_FALSE);
const char *romPath = env->GetStringUTFChars(jRomPath, JNI_FALSE);
//Do not allow more than one calc currently
if (lpCalc) {
calc_slot_free(lpCalc);
}
lpCalc = calc_slot_new();
calc_init_model(lpCalc, model, NULL);
//slot stuff
strcpy(lpCalc->rom_path, romPath);
lpCalc->active = TRUE;
lpCalc->model = (CalcModel) model;
lpCalc->cpu.pio.model = model;
FILE *file = fopen(bootPath, "rb");
if (file == NULL) {
calc_slot_free(lpCalc);
lpCalc = NULL;
return -1;
}
writeboot(file, &lpCalc->mem_c, -1);
fclose(file);
remove(bootPath);
TIFILE_t *tifile = importvar(osPath, FALSE);
if (tifile == NULL) {
calc_slot_free(lpCalc);
lpCalc = NULL;
return -2;
}
int link_error = forceload_os(&lpCalc->cpu, tifile);
if (link_error != LERR_SUCCESS) {
calc_slot_free(lpCalc);
lpCalc = NULL;
return -2;
}
calc_erase_certificate(lpCalc->mem_c.flash,lpCalc->mem_c.flash_size);
calc_reset(lpCalc);
//write the output from file
MFILE *romfile = ExportRom((char *) romPath, lpCalc);
if (romfile != NULL) {
mclose(romfile);
calc_slot_free(lpCalc);
lpCalc = NULL;
return 0;
}
calc_slot_free(lpCalc);
lpCalc = NULL;
return -3;
}
JNIEXPORT void JNICALL Java_com_Revsoft_Wabbitemu_calc_CalcInterface_ResetCalc
(JNIEnv *env, jclass classObj) {
checkThread();
if (!lpCalc) {
return;
}
lpCalc->fake_running = TRUE;
calc_reset(lpCalc);
lpCalc->fake_running = FALSE;
}
static LINK_ERR SendFile(const LPCALC lpCalc, LPCTSTR lpszFileName, SEND_FLAG Destination)
{
TIFILE_t *var = importvar(lpszFileName, FALSE);
BOOL exec_vio_backup = break_on_exe_violation;
break_on_exe_violation = false;
LINK_ERR result;
if (var != NULL) {
switch(var->type)
{
case GROUP_TYPE:
case VAR_TYPE:
case FLASH_TYPE:
{
if (lpCalc->cpu.pio.link == NULL) {
result = LERR_MODEL;
//81 for now
break;
}
lpCalc->cpu.pio.link->vlink_size = var->length;
lpCalc->cpu.pio.link->vlink_send = 0;
BOOL running_backup = lpCalc->running;
// if we just started running, calc_turn_on may be running
while (lpCalc->fake_running) { }
lpCalc->fake_running = TRUE;
result = link_send_var(&lpCalc->cpu, var, (SEND_FLAG) Destination);
if (var->type == FLASH_TYPE)
{
if (var->flash->type == FLASH_TYPE_OS) {
calc_reset(lpCalc);
//calc_turn_on(lpCalc);
} else {
// Rebuild the app list
applist_t applist;
state_build_applist(&lpCalc->cpu, &applist);
u_int i;
for (i = 0; i < applist.count; i++) {
if (_tcsncmp((TCHAR *) var->flash->name, applist.apps[i].name, 8) == 0) {
lpCalc->last_transferred_app = applist.apps[i];
break;
}
}
}
}
lpCalc->fake_running = FALSE;
lpCalc->running = running_backup;
break;
}
case BACKUP_TYPE:
lpCalc->cpu.pio.link->vlink_size = var->length;
lpCalc->cpu.pio.link->vlink_send = 0;
result = link_send_backup(&lpCalc->cpu, var);
break;
case ZIP_TYPE: {
WIN32_FIND_DATA FindFileData;
HANDLE hFind;
TCHAR path[MAX_PATH];
TCHAR search[MAX_PATH];
GetStorageString(path, sizeof(path));
StringCbCat(path, sizeof(path), _T("Zip\\"));
StringCbCopy(search, sizeof(search), path);
StringCbCat(search, sizeof(search), _T("*"));
hFind = FindFirstFile(search, &FindFileData);
if (hFind == INVALID_HANDLE_VALUE) {
result = LERR_FILE;
break;
} else if (!(FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
TCHAR filename[MAX_PATH];
StringCbCopy(filename, sizeof(filename), path);
StringCbCat(filename, sizeof(filename), FindFileData.cFileName);
SendFileToCalc(NULL, lpCalc, filename, FALSE, Destination);
SendFileToCalc(NULL, lpCalc, filename, FALSE, Destination);
}
while (FindNextFile(hFind, &FindFileData)) {
if (!(FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
TCHAR filename[MAX_PATH];
StringCbCopy(filename, sizeof(filename), path);
StringCbCat(filename, sizeof(filename), FindFileData.cFileName);
SendFileToCalc(NULL, lpCalc, filename, FALSE, Destination);
DeleteFile(filename);
}
}
FindClose(hFind);
DeleteFile(path);
result = LERR_SUCCESS;
break;
}
case ROM_TYPE:
case SAV_TYPE: {
if (rom_load(lpCalc, lpszFileName) == TRUE) {
result = LERR_SUCCESS;
} else {
result = LERR_LINK;
}
FreeTiFile(var);
var = NULL;
break;
}
case LABEL_TYPE: {
VoidLabels(lpCalc);
labels_app_load(lpCalc, lpszFileName);
result = LERR_SUCCESS;
break;
}
case BREAKPOINT_TYPE:
break;
}
if (var) {
FreeTiFile(var);
}
break_on_exe_violation = exec_vio_backup;
return result;
}
else
{
break_on_exe_violation = exec_vio_backup;
return LERR_FILE;
}
}
BOOL rom_load(LPCALC lpCalc, LPCTSTR FileName) {
if (lpCalc == NULL) {
return FALSE;
}
TIFILE_t* tifile = newimportvar(FileName, FALSE);
if (tifile == NULL) {
return FALSE;
}
lpCalc->speed = 100;
if (lpCalc->active) {
calc_slot_free(lpCalc);
}
lpCalc->model = tifile->model;
if (tifile->type == SAV_TYPE) {
lpCalc->active = TRUE;
switch (tifile->model) {
case TI_82:
case TI_83: {
int size;
char *rom = GetRomOnly(tifile->save, &size);
char VerString[64];
FindRomVersion( tifile->model, VerString, (unsigned char *) rom, size);
calc_init_83(lpCalc, VerString);
break;
}
case TI_73:
case TI_83P:
calc_init_83p(lpCalc);
break;
case TI_84PSE:
case TI_83PSE:
calc_init_83pse(lpCalc);
break;
case TI_84P:
calc_init_84p(lpCalc);
break;
case TI_85:
case TI_86:
calc_init_86(lpCalc);
break;
default:
FreeTiFile(tifile);
return FALSE;
}
LoadSlot(tifile->save, lpCalc);
#ifdef WINVER
StringCbCopy(lpCalc->rom_path, sizeof(lpCalc->rom_path), FileName);
#else
_tcscpy_s(lpCalc->rom_path, FileName);
#endif
FindRomVersion(tifile->model, lpCalc->rom_version, lpCalc->mem_c.flash, lpCalc->mem_c.flash_size);
} else if (tifile->type == ROM_TYPE) {
switch (tifile->model) {
case TI_81:
calc_init_81(lpCalc, tifile->rom->version);
memcpy( lpCalc->cpu.mem_c->flash,
tifile->rom->data,
(lpCalc->cpu.mem_c->flash_size<=tifile->rom->size)?lpCalc->cpu.mem_c->flash_size:tifile->rom->size);
break;
case TI_82:
case TI_83:
calc_init_83(lpCalc, tifile->rom->version);
memcpy( lpCalc->cpu.mem_c->flash,
tifile->rom->data,
(lpCalc->cpu.mem_c->flash_size<=tifile->rom->size)?lpCalc->cpu.mem_c->flash_size:tifile->rom->size);
break;
case TI_85:
case TI_86:
calc_init_86(lpCalc);
memcpy( lpCalc->cpu.mem_c->flash,
tifile->rom->data,
(lpCalc->cpu.mem_c->flash_size<=tifile->rom->size)?lpCalc->cpu.mem_c->flash_size:tifile->rom->size);
break;
case TI_73:
case TI_83P:
calc_init_83p(lpCalc);
memcpy( lpCalc->cpu.mem_c->flash,
tifile->rom->data,
(lpCalc->cpu.mem_c->flash_size<=tifile->rom->size)?lpCalc->cpu.mem_c->flash_size:tifile->rom->size);
calc_erase_certificate(lpCalc->cpu.mem_c->flash,lpCalc->cpu.mem_c->flash_size);
break;
case TI_84P:
calc_init_84p(lpCalc);
memcpy( lpCalc->cpu.mem_c->flash,
tifile->rom->data,
(lpCalc->cpu.mem_c->flash_size<=tifile->rom->size)?lpCalc->cpu.mem_c->flash_size:tifile->rom->size);
calc_erase_certificate(lpCalc->cpu.mem_c->flash,lpCalc->cpu.mem_c->flash_size);
break;
case TI_84PSE:
case TI_83PSE:
calc_init_83pse(lpCalc);
memcpy( lpCalc->cpu.mem_c->flash,
tifile->rom->data,
(lpCalc->cpu.mem_c->flash_size<=tifile->rom->size)?lpCalc->cpu.mem_c->flash_size:tifile->rom->size);
calc_erase_certificate(lpCalc->cpu.mem_c->flash,lpCalc->cpu.mem_c->flash_size);
break;
default:
FreeTiFile(tifile);
return FALSE;
}
lpCalc->active = TRUE;
memcpy(lpCalc->rom_version, tifile->rom->version, sizeof(lpCalc->rom_version));
#ifdef WINVER
StringCbCopy(lpCalc->rom_path, sizeof(lpCalc->rom_path), FileName);
#else
_tcscpy_s(lpCalc->rom_path, FileName);
#endif
} else {
lpCalc = NULL;
return FALSE;
}
if (lpCalc != NULL) {
lpCalc->cpu.pio.model = lpCalc->model;
#ifdef WINVER
extern keyprog_t keygrps[256];
extern keyprog_t defaultkeys[256];
extern keyprog_t keysti86[256];
if (lpCalc->model == TI_86 || lpCalc->model == TI_85) {
memcpy(keygrps, keysti86, sizeof(keyprog_t) * 256);
} else {
memcpy(keygrps, defaultkeys, sizeof(keyprog_t) * 256);
}
#endif
if (lpCalc->model >= TI_73) {
check_bootfree_and_update(lpCalc);
}
if (tifile->save == NULL) {
calc_reset(lpCalc);
if (lpCalc->auto_turn_on) {
calc_turn_on(lpCalc);
}
}
}
FreeTiFile(tifile);
return TRUE;
}
