void invokeSelector(EngineState *s, reg_t object, int selectorId,
int k_argc, StackPtr k_argp, int argc, const reg_t *argv) {
int i;
int framesize = 2 + 1 * argc;
int slc_type;
StackPtr stackframe = k_argp + k_argc;
stackframe[0] = make_reg(0, selectorId); // The selector we want to call
stackframe[1] = make_reg(0, argc); // Argument count
slc_type = lookupSelector(s->_segMan, object, selectorId, NULL, NULL);
if (slc_type == kSelectorNone) {
error("Selector '%s' of object at %04x:%04x could not be invoked",
g_sci->getKernel()->getSelectorName(selectorId).c_str(), PRINT_REG(object));
}
if (slc_type == kSelectorVariable) {
error("Attempting to invoke variable selector %s of object %04x:%04x",
g_sci->getKernel()->getSelectorName(selectorId).c_str(), PRINT_REG(object));
}
for (i = 0; i < argc; i++)
stackframe[2 + i] = argv[i]; // Write each argument
ExecStack *xstack;
// Now commit the actual function:
xstack = send_selector(s, object, object, stackframe, framesize, stackframe);
xstack->sp += argc + 2;
xstack->fp += argc + 2;
run_vm(s); // Start a new vm
}
int main(int argc, char **argv)
{
FILE *in = NULL, *out = NULL;
struct vm_state *myvm = NULL ;
int runcycles = 0;
if (argc != 4)
{
fprintf(stderr, "usage: %s input output cycles \n", argv[0]);
exit(1);
}
in = fopen(argv[1], "rb");
out = fopen(argv[2], "wb");
if (in == NULL)
{
perror("opening input file");
exit(1);
}
if (out == NULL)
{
perror("opening output file");
exit(1);
}
runcycles = atoi(argv[3]);
myvm = initialize_vm();
load_vm(myvm, in);
run_vm(myvm, runcycles);
dump_vm(myvm, out);
return 0;
}
int run_paged_32bit_mode(struct vm *vm, struct vcpu *vcpu)
{
struct kvm_sregs sregs;
struct kvm_regs regs;
printf("Testing 32-bit paging\n");
if (ioctl(vcpu->fd, KVM_GET_SREGS, &sregs) < 0) {
perror("KVM_GET_SREGS");
exit(1);
}
setup_protected_mode(&sregs);
setup_paged_32bit_mode(vm, &sregs);
if (ioctl(vcpu->fd, KVM_SET_SREGS, &sregs) < 0) {
perror("KVM_SET_SREGS");
exit(1);
}
memset(®s, 0, sizeof(regs));
/* Clear all FLAGS bits, except bit 1 which is always set. */
regs.rflags = 2;
regs.rip = 0;
if (ioctl(vcpu->fd, KVM_SET_REGS, ®s) < 0) {
perror("KVM_SET_REGS");
exit(1);
}
memcpy(vm->mem, guest32, guest32_end-guest32);
return run_vm(vm, vcpu, 4);
}
int run_long_mode(struct vm *vm, struct vcpu *vcpu)
{
struct kvm_sregs sregs;
struct kvm_regs regs;
printf("Testing 64-bit mode\n");
if (ioctl(vcpu->fd, KVM_GET_SREGS, &sregs) < 0) {
perror("KVM_GET_SREGS");
exit(1);
}
setup_long_mode(vm, &sregs);
if (ioctl(vcpu->fd, KVM_SET_SREGS, &sregs) < 0) {
perror("KVM_SET_SREGS");
exit(1);
}
memset(®s, 0, sizeof(regs));
/* Clear all FLAGS bits, except bit 1 which is always set. */
regs.rflags = 2;
regs.rip = 0;
/* Create stack at top of 2 MB page and grow down. */
regs.rsp = 2 << 20;
if (ioctl(vcpu->fd, KVM_SET_REGS, ®s) < 0) {
perror("KVM_SET_REGS");
exit(1);
}
memcpy(vm->mem, guest64, guest64_end-guest64);
return run_vm(vm, vcpu, 8);
}
int run_real_mode(struct vm *vm, struct vcpu *vcpu)
{
struct kvm_sregs sregs;
struct kvm_regs regs;
printf("Testing real mode\n");
if (ioctl(vcpu->fd, KVM_GET_SREGS, &sregs) < 0) {
perror("KVM_GET_SREGS");
exit(1);
}
sregs.cs.selector = 0;
sregs.cs.base = 0;
if (ioctl(vcpu->fd, KVM_SET_SREGS, &sregs) < 0) {
perror("KVM_SET_SREGS");
exit(1);
}
memset(®s, 0, sizeof(regs));
/* Clear all FLAGS bits, except bit 1 which is always set. */
regs.rflags = 2;
regs.rip = 0;
if (ioctl(vcpu->fd, KVM_SET_REGS, ®s) < 0) {
perror("KVM_SET_REGS");
exit(1);
}
memcpy(vm->mem, guest16, guest16_end-guest16);
return run_vm(vm, vcpu, 2);
}
/**
*
* Kernel entrypoint
* @param multiboot pointer to multiboot header
* @param magic magic value from multiboot bootloader
*
**/
void kmain(multiboot_t* multiboot, uint32_t magic)
{
/* Check magic */
if(magic != 0x2BADB002)
{
printf("Multiboot magic is incorrect.\n");
_Exit(EXIT_FAILURE);
}
/* Check if there are modules */
if(multiboot->mods_count == 0)
{
printf("No modules available. Can't boot.\n");
_Exit(EXIT_FAILURE);
}
/* Get module and info about it */
multiboot_module_t* module = (multiboot_module_t*) multiboot->mods_addr;
uintptr_t start = module->mod_start;
uintptr_t end = module->mod_end;
/* Install heap after module */
heap_install(end);
/* Run VM */
run_vm((void*) start);
}
int main(int argc, char **argv)
{
if(argc == 1) {
fprintf(stderr, "Usage: %s FILE\n", argv[0]);
exit(1);
}
errno = 0;
size_t size;
int32_t *mem = read_file(argv[1], &size);
if(!mem) {
if(errno)
perror(argv[0]);
else
fprintf(stderr, "%s: The file was invalid.\n", argv[0]);
exit(1);
}
init_vm(mem, size);
while(1) {
run_vm();
render_screen();
process_events();
delay();
}
}
void
init_boron(int* argc, char*** argv) {
printf("Boron %s [%s %s]\n", VERSION, __DATE__, __TIME__);
if(*argc > 1) {
} else {
run_vm();
}
}
void SciEngine::runGame() {
setTotalPlayTime(0);
initStackBaseWithSelector(SELECTOR(play)); // Call the play selector
// Attach the debug console on game startup, if requested
if (DebugMan.isDebugChannelEnabled(kDebugLevelOnStartup))
_console->attach();
_gamestate->_syncedAudioOptions = false;
do {
_gamestate->_executionStackPosChanged = false;
run_vm(_gamestate);
exitGame();
_gamestate->_syncedAudioOptions = true;
if (_gamestate->abortScriptProcessing == kAbortRestartGame) {
_gamestate->_segMan->resetSegMan();
initGame();
initStackBaseWithSelector(SELECTOR(play));
patchGameSaveRestore();
setLauncherLanguage();
_gamestate->gameIsRestarting = GAMEISRESTARTING_RESTART;
_gamestate->_throttleLastTime = 0;
if (_gfxMenu)
_gfxMenu->reset();
_gamestate->abortScriptProcessing = kAbortNone;
_gamestate->_syncedAudioOptions = false;
} else if (_gamestate->abortScriptProcessing == kAbortLoadGame) {
_gamestate->abortScriptProcessing = kAbortNone;
_gamestate->_executionStack.clear();
initStackBaseWithSelector(SELECTOR(replay));
patchGameSaveRestore();
setLauncherLanguage();
_gamestate->shrinkStackToBase();
_gamestate->abortScriptProcessing = kAbortNone;
syncSoundSettings();
syncIngameAudioOptions();
// Games do not set their audio settings when loading
} else {
break; // exit loop
}
} while (true);
}
int main(int argc, char** argv)
{
char* filename = "";
if(argc == 2)
filename = argv[1];
virtual_machine* vm = create_vm(filename);
if(vm != NULL) run_vm(vm);
// Print the first memory address
//if(vm) printf("%i\n", vm->pMemory->int32[0]);
destroy_vm(vm);
return 0;
}
int main(int argc, char **argv)
{
t_vm *vm;
int dump;
if (argc > 1)
{
if (!(vm = init_vm()))
exit(write(2, "No memory\n", 10));
dump = -1;
parse_args(argc, argv, vm, &dump);
if (vm->nb_players < 1)
exit(write(2, "No players\n", 11));
vm->last_player = vm->players[vm->nb_players - 1]->number;
load_players_in_memory(vm);
run_vm(vm, dump);
print_winner(vm);
free_vm(vm);
}
return (0);
}
Common::Error SciEngine::run() {
g_eventRec.registerRandomSource(_rng, "sci");
// Assign default values to the config manager, in case settings are missing
ConfMan.registerDefault("sci_originalsaveload", "false");
ConfMan.registerDefault("native_fb01", "false");
ConfMan.registerDefault("windows_cursors", "false"); // Windows cursors for KQ6 Windows
_resMan = new ResourceManager();
assert(_resMan);
_resMan->addAppropriateSources();
_resMan->init();
// TODO: Add error handling. Check return values of addAppropriateSources
// and init. We first have to *add* sensible return values, though ;).
/*
if (!_resMan) {
warning("No resources found, aborting");
return Common::kNoGameDataFoundError;
}
*/
// Reset, so that error()s before SoundCommandParser is initialized wont cause a crash
_soundCmd = NULL;
// Add the after market GM patches for the specified game, if they exist
_resMan->addNewGMPatch(_gameId);
_gameObjectAddress = _resMan->findGameObject();
_gameSuperClassAddress = NULL_REG;
SegManager *segMan = new SegManager(_resMan);
// Initialize the game screen
_gfxScreen = new GfxScreen(_resMan);
_gfxScreen->debugUnditherSetState(ConfMan.getBool("disable_dithering"));
// Create debugger console. It requires GFX to be initialized
_console = new Console(this);
_kernel = new Kernel(_resMan, segMan);
_features = new GameFeatures(segMan, _kernel);
// Only SCI0, SCI01 and SCI1 EGA games used a parser
_vocabulary = (getSciVersion() <= SCI_VERSION_1_EGA) ? new Vocabulary(_resMan, false) : NULL;
// Also, XMAS1990 apparently had a parser too. Refer to http://forums.scummvm.org/viewtopic.php?t=9135
if (getGameId() == GID_CHRISTMAS1990)
_vocabulary = new Vocabulary(_resMan, false);
_audio = new AudioPlayer(_resMan);
_gamestate = new EngineState(segMan);
_eventMan = new EventManager(_resMan->detectFontExtended());
// The game needs to be initialized before the graphics system is initialized, as
// the graphics code checks parts of the seg manager upon initialization (e.g. for
// the presence of the fastCast object)
if (!initGame()) { /* Initialize */
warning("Game initialization failed: Aborting...");
// TODO: Add an "init failed" error?
return Common::kUnknownError;
}
// we try to find the super class address of the game object, we can't do that earlier
const Object *gameObject = segMan->getObject(_gameObjectAddress);
if (!gameObject) {
warning("Could not get game object, aborting...");
return Common::kUnknownError;
}
_gameSuperClassAddress = gameObject->getSuperClassSelector();
script_adjust_opcode_formats();
// Must be called after game_init(), as they use _features
_kernel->loadKernelNames(_features);
_soundCmd = new SoundCommandParser(_resMan, segMan, _kernel, _audio, _features->detectDoSoundType());
syncSoundSettings();
syncIngameAudioOptions();
// Initialize all graphics related subsystems
initGraphics();
debug("Emulating SCI version %s\n", getSciVersionDesc(getSciVersion()));
// Patch in our save/restore code, so that dialogs are replaced
patchGameSaveRestore();
setLauncherLanguage();
// Check whether loading a savestate was requested
int directSaveSlotLoading = ConfMan.getInt("save_slot");
if (directSaveSlotLoading >= 0) {
// call GameObject::play (like normally)
initStackBaseWithSelector(SELECTOR(play));
// We set this, so that the game automatically quit right after init
_gamestate->variables[VAR_GLOBAL][4] = TRUE_REG;
_gamestate->_executionStackPosChanged = false;
run_vm(_gamestate);
// As soon as we get control again, actually restore the game
reg_t restoreArgv[2] = { NULL_REG, make_reg(0, directSaveSlotLoading) }; // special call (argv[0] is NULL)
kRestoreGame(_gamestate, 2, restoreArgv);
// this indirectly calls GameObject::init, which will setup menu, text font/color codes etc.
// without this games would be pretty badly broken
}
// Show any special warnings for buggy scripts with severe game bugs,
// which have been patched by Sierra
if (getGameId() == GID_LONGBOW) {
// Longbow 1.0 has a buggy script which prevents the game
// from progressing during the Green Man riddle sequence.
// A patch for this buggy script has been released by Sierra,
// and is necessary to complete the game without issues.
// The patched script is included in Longbow 1.1.
// Refer to bug #3036609.
Resource *buggyScript = _resMan->findResource(ResourceId(kResourceTypeScript, 180), 0);
if (buggyScript && (buggyScript->size == 12354 || buggyScript->size == 12362)) {
showScummVMDialog("A known buggy game script has been detected, which could "
"prevent you from progressing later on in the game, during "
"the sequence with the Green Man's riddles. Please, apply "
"the latest patch for this game by Sierra to avoid possible "
"problems");
}
}
// Show a warning if the user has selected a General MIDI device, no GM patch exists
// (i.e. patch 4) and the game is one of the known 8 SCI1 games that Sierra has provided
// after market patches for in their "General MIDI Utility".
if (_soundCmd->getMusicType() == MT_GM && !ConfMan.getBool("native_mt32")) {
if (!_resMan->findResource(ResourceId(kResourceTypePatch, 4), 0)) {
switch (getGameId()) {
case GID_ECOQUEST:
case GID_HOYLE3:
case GID_LSL1:
case GID_LSL5:
case GID_LONGBOW:
case GID_SQ1:
case GID_SQ4:
case GID_FAIRYTALES:
showScummVMDialog("You have selected General MIDI as a sound device. Sierra "
"has provided after-market support for General MIDI for this "
"game in their \"General MIDI Utility\". Please, apply this "
"patch in order to enjoy MIDI music with this game. Once you "
"have obtained it, you can unpack all of the included *.PAT "
"files in your ScummVM extras folder and ScummVM will add the "
"appropriate patch automatically. Alternatively, you can follow "
"the instructions in the READ.ME file included in the patch and "
"rename the associated *.PAT file to 4.PAT and place it in the "
"game folder. Without this patch, General MIDI music for this "
"game will sound badly distorted.");
break;
default:
break;
}
}
}
if (gameHasFanMadePatch()) {
showScummVMDialog("Your game is patched with a fan made script patch. Such patches have "
"been reported to cause issues, as they modify game scripts extensively. "
"The issues that these patches fix do not occur in ScummVM, so you are "
"advised to remove this patch from your game folder in order to avoid "
"having unexpected errors and/or issues later on.");
}
runGame();
ConfMan.flushToDisk();
return Common::kNoError;
}
static void setup_protected_mode(struct kvm_sregs *sregs)
{
struct kvm_segment seg = {
.base = 0,
.limit = 0xffffffff,
.selector = 1 << 3,
.present = 1,
.type = 11, /* Code: execute, read, accessed */
.dpl = 0,
.db = 1,
.s = 1, /* Code/data */
.l = 0,
.g = 1, /* 4KB granularity */
};
sregs->cr0 |= CR0_PE; /* enter protected mode */
sregs->cs = seg;
seg.type = 3; /* Data: read/write, accessed */
seg.selector = 2 << 3;
sregs->ds = sregs->es = sregs->fs = sregs->gs = sregs->ss = seg;
}
extern const unsigned char guest32[], guest32_end[];
int run_protected_mode(struct vm *vm, struct vcpu *vcpu)
{
struct kvm_sregs sregs;
struct kvm_regs regs;
printf("Testing protected mode\n");
if (ioctl(vcpu->fd, KVM_GET_SREGS, &sregs) < 0) {
perror("KVM_GET_SREGS");
exit(1);
}
setup_protected_mode(&sregs);
if (ioctl(vcpu->fd, KVM_SET_SREGS, &sregs) < 0) {
perror("KVM_SET_SREGS");
exit(1);
}
memset(®s, 0, sizeof(regs));
/* Clear all FLAGS bits, except bit 1 which is always set. */
regs.rflags = 2;
regs.rip = 0;
if (ioctl(vcpu->fd, KVM_SET_REGS, ®s) < 0) {
perror("KVM_SET_REGS");
exit(1);
}
memcpy(vm->mem, guest32, guest32_end-guest32);
return run_vm(vm, vcpu, 4);
}
static void setup_paged_32bit_mode(struct vm *vm, struct kvm_sregs *sregs)
{
uint32_t pd_addr = 0x2000;
uint32_t *pd = (void *)(vm->mem + pd_addr);
/* A single 4MB page to cover the memory region */
pd[0] = PDE32_PRESENT | PDE32_RW | PDE32_USER | PDE32_PS;
/* Other PDEs are left zeroed, meaning not present. */
sregs->cr3 = pd_addr;
sregs->cr4 = CR4_PSE;
sregs->cr0
= CR0_PE | CR0_MP | CR0_ET | CR0_NE | CR0_WP | CR0_AM | CR0_PG;
sregs->efer = 0;
}
int main() {
run_vm();
return 0;
}
int main(void) {
return run_vm();
}
PRIVATE void compile_main(FILE *conni, FILE *conno) {
REPL_DATA rd = allocmem(sizeof(repl_data));
VMstate vms;
rd->h1 = rd->h2 = NULL;
protect(&rd->h1);
protect(&rd->h2);
rd->vmregs = (VMREGS) newvector(NUM_VMREGS); /* dodgy casting :-) */
vms.r = rd->vmregs;
protect((OBJ *)(&rd->vmregs));
init_vm(&vms);
vms.c.vm_state = VM_STATE_NOQUOTA;
while (vms.c.vm_state != VM_STATE_DYING) {
ScanInst si;
char buf[16384];
rd->h1 = (OBJ) newbvector(0);
while (1) {
char *result;
result = fgets(buf, 256, conni);
if (result == NULL)
break;
while (1) {
int l = strlen(buf);
if (buf[l-1] == '\r' || buf[l-1] == '\n')
buf[l-1] = '\0';
else
break;
}
strcat(buf, "\n");
if (!strcmp(buf, ".\n"))
break;
rd->h2 = (OBJ) newstring(buf);
rd->h1 = (OBJ) bvector_concat((BVECTOR) rd->h1, (BVECTOR) rd->h2);
}
gc_reach_safepoint();
rd->h2 = (OBJ) newstringconn((BVECTOR) rd->h1);
fill_scaninst(&si, (OVECTOR) rd->h2);
while (!conn_closed((OVECTOR) rd->h2)) {
rd->h1 = (OBJ) parse(&vms, &si);
gc_reach_safepoint();
if (rd->h1 == NULL) {
sprintf(buf, "-->! the compiler returned NULL.\n");
} else {
vms.c.vm_state = VM_STATE_NOQUOTA;
ATPUT((OVECTOR) rd->h1, ME_OWNER, (OBJ) vms.r->vm_uid);
vms.r->vm_effuid = vms.r->vm_uid;
{
OVECTOR c = newovector_noinit(CL_MAXSLOTINDEX, T_CLOSURE);
ATPUT(c, CL_SELF, NULL);
ATPUT(c, CL_METHOD, rd->h1);
rd->h1 = (OBJ) c;
}
apply_closure(&vms, (OVECTOR) rd->h1, newvector_noinit(1));
while (!run_vm(&vms)) ;
rd->h1 = (OBJ) newvector(2);
ATPUT((VECTOR) rd->h1, 0, NULL);
ATPUT((VECTOR) rd->h1, 1, vms.r->vm_acc);
rd->h1 = lookup_prim(0x00001, NULL)(&vms, (VECTOR) rd->h1);
rd->h1 = (OBJ) bvector_concat((BVECTOR) rd->h1, newbvector(1));
/* terminates C-string */
gc_reach_safepoint();
sprintf(buf, "--> %s\n", ((BVECTOR) rd->h1)->vec);
}
fputs(buf, conno);
}
}
unprotect((OBJ *)(&rd->vmregs));
unprotect(&rd->h2);
unprotect(&rd->h1);
freemem(rd);
}
static int
do_code(ClipMachine * mp, struct ClipBlock *cp, int argc, int isProc, int rest, ClipVarFrame * uplocals)
{
int ret, _argc = mp->argc;
ClipFrame *fp = mp->fp;
ClipVar *bp = mp->bp;
ClipVarFrame *s_up = mp->fp->localvars;
mp->argc = argc;
mp->bp = fp->sp;
mp->fp->localvars = uplocals;
if (_clip_profiler)
{
_clip_stop_profiler(mp);
}
_clip_logg(6, "PCODE call from: proc '%s' file '%s' line %d", fp->procname ? fp->procname : "unknown", fp->filename, fp->line);
for (;;)
{
int dnext = 0;
if (_clip_debuglevel)
{
dnext = _clip_debugnext;
_clip_debug(mp);
}
#ifdef USE_TASKS
Task_yield();
#endif
ret = run_vm(mp, cp);
if (_clip_sig_flag)
_clip_signal_real(_clip_sig_flag);
if (_clip_debuglevel)
{
if (!dnext && _clip_debugnext)
{
_clip_debugnext = 0;
}
}
_clip_logg(4, "PCODE return=%d to: proc '%s' file '%s' line %d", ret, fp->procname ? fp->procname : "unknown", fp->filename, fp->line);
if (!ret)
break;
if (!mp->trapVar)
_clip_generr(mp, ret);
if (ret < 0)
break;
if (!_clip_errorblock(mp, mp->trapVar, ret))
{
ret = -ret;
break;
}
mp->argc = _argc;
mp->fp = fp;
mp->bp = bp;
mp->fp->localvars = s_up;
}
mp->argc = _argc;
mp->fp = fp;
mp->bp = bp;
mp->fp->localvars = s_up;
if (isProc)
++argc;
for (; argc; --argc)
{
--(fp->sp);
_clip_destroy(mp, fp->sp);
}
if (_clip_profiler)
{
_clip_start_profiler(mp);
mp->pbucket->callno--;
}
return ret;
}
