int main(int argc, char *argv[])
{
FILE *fp;
char local[200];
if (argc > 1) {
fp=fopen(argv[1], "r");
if (fp == NULL) {
printf("Erro ao abrir arquivo: %s\n", argv[1]);
system("PAUSE");
return 1;
}
} else {
fp = NULL;
printf("Informe o caminho do codigo a ser compilado: ");
fgets_wrapper(local, sizeof(local), stdin);
fp=fopen(local,"r");
while(fp == NULL){
printf("Erro ao abrir arquivo: %s\n", local);
printf("Caminho nao encotrado, digite o caminho novamente: ");
fgets_wrapper(local, sizeof(local), stdin);
fp=fopen(local,"r");
system("cls");
}
}
compila(fp);
if (variaveis) {
printf ("Variaveis encontradas: \n");
Lista *p = variaveis;
while (p != NULL) {
if (p->utilizada > 0)
printf ("%s, utilizada %d vezes.\n", p->variavel, p->utilizada);
else
printf ("AVISO: a variavel \"%s\" foi declarada mas nao utilizada.\n", p->variavel);
p = p->proxima;
}
} else {
printf ("Nenhuma variavel utilizada");
}
if (palavras_usadas) {
printf ("Palavras reservadas encontradas: \n");
Lista *p = palavras_usadas;
while (p != NULL) {
printf ("Palavra: %s, Quantidade: %d\n", p->variavel, p->qtde);
p = p->proxima;
}
}
system("PAUSE");
}
reg_t kFGets(EngineState *s, int funct_nr, int argc, reg_t *argv) {
char *dest = kernel_dereference_char_pointer(s, argv[0], 0);
int maxsize = argv[1].toUint16();
int handle = argv[2].toUint16();
debug(3, "kFGets(%d,%d)", handle, maxsize);
fgets_wrapper(s, dest, maxsize, handle);
return argv[0];
}
reg_t kFileIOReadString(EngineState *s, int argc, reg_t *argv) {
uint16 maxsize = argv[1].toUint16();
char *buf = new char[maxsize];
uint16 handle = argv[2].toUint16();
debugC(kDebugLevelFile, "kFileIO(readString): %d, %d", handle, maxsize);
uint32 bytesRead;
#ifdef ENABLE_SCI32
if (handle == VIRTUALFILE_HANDLE)
bytesRead = s->_virtualIndexFile->readLine(buf, maxsize);
else
#endif
bytesRead = fgets_wrapper(s, buf, maxsize, handle);
s->_segMan->memcpy(argv[0], (const byte*)buf, maxsize);
delete[] buf;
return bytesRead ? argv[0] : NULL_REG;
}
reg_t kFileIO(EngineState *s, int funct_nr, int argc, reg_t *argv) {
int func_nr = argv[0].toUint16();
switch (func_nr) {
case K_FILEIO_OPEN : {
char *name = kernel_dereference_char_pointer(s, argv[1], 0);
int mode = argv[2].toUint16();
file_open(s, name, mode);
debug(3, "K_FILEIO_OPEN(%s,0x%x)", name, mode);
break;
}
case K_FILEIO_CLOSE : {
int handle = argv[1].toUint16();
debug(3, "K_FILEIO_CLOSE(%d)", handle);
file_close(s, handle);
break;
}
case K_FILEIO_READ_RAW : {
int handle = argv[1].toUint16();
char *dest = kernel_dereference_char_pointer(s, argv[2], 0);
int size = argv[3].toUint16();
debug(3, "K_FILEIO_READ_RAW(%d,%d)", handle, size);
fread_wrapper(s, dest, size, handle);
break;
}
case K_FILEIO_WRITE_RAW : {
int handle = argv[1].toUint16();
char *buf = kernel_dereference_char_pointer(s, argv[2], 0);
int size = argv[3].toUint16();
debug(3, "K_FILEIO_WRITE_RAW(%d,%d)", handle, size);
fwrite_wrapper(s, handle, buf, size);
break;
}
case K_FILEIO_UNLINK : {
char *name = kernel_dereference_char_pointer(s, argv[1], 0);
debug(3, "K_FILEIO_UNLINK(%s)", name);
Common::SaveFileManager *saveFileMan = g_engine->getSaveFileManager();
const Common::String wrappedName = ((Sci::SciEngine*)g_engine)->wrapFilename(name);
saveFileMan->removeSavefile(wrappedName);
// TODO/FIXME: Should we return something (like, a bool indicating
// whether deleting the save succeeded or failed)?
break;
}
case K_FILEIO_READ_STRING : {
char *dest = kernel_dereference_char_pointer(s, argv[1], 0);
int size = argv[2].toUint16();
int handle = argv[3].toUint16();
debug(3, "K_FILEIO_READ_STRING(%d,%d)", handle, size);
fgets_wrapper(s, dest, size, handle);
return argv[1];
}
case K_FILEIO_WRITE_STRING : {
int handle = argv[1].toUint16();
int size = argv[3].toUint16();
char *buf = kernel_dereference_char_pointer(s, argv[2], size);
debug(3, "K_FILEIO_WRITE_STRING(%d,%d)", handle, size);
// FIXME: What is the difference between K_FILEIO_WRITE_STRING and
// K_FILEIO_WRITE_RAW? Normally, I would expect the difference to
// be that the former doesn't receive a 'size' parameter. But here
// it does. Are we missing something?
if (buf)
fwrite_wrapper(s, handle, buf, size);
break;
}
case K_FILEIO_SEEK : {
int handle = argv[1].toUint16();
int offset = argv[2].toUint16();
int whence = argv[3].toUint16();
debug(3, "K_FILEIO_SEEK(%d,%d,%d)", handle, offset, whence);
fseek_wrapper(s, handle, offset, whence);
break;
}
case K_FILEIO_FIND_FIRST : {
char *mask = kernel_dereference_char_pointer(s, argv[1], 0);
reg_t buf = argv[2];
int attr = argv[3].toUint16(); // We won't use this, Win32 might, though...
debug(3, "K_FILEIO_FIND_FIRST(%s,0x%x)", mask, attr);
#ifndef WIN32
if (strcmp(mask, "*.*") == 0)
strcpy(mask, "*"); // For UNIX
#endif
s->_dirseeker.firstFile(mask, buf);
break;
}
case K_FILEIO_FIND_NEXT : {
debug(3, "K_FILEIO_FIND_NEXT()");
s->_dirseeker.nextFile();
break;
}
case K_FILEIO_FILE_EXISTS : {
char *name = kernel_dereference_char_pointer(s, argv[1], 0);
// Check for regular file
bool exists = Common::File::exists(name);
if (!exists) {
// TODO: Transform the name given by the scripts to us, e.g. by
// prepending TARGET-
Common::SaveFileManager *saveFileMan = g_engine->getSaveFileManager();
exists = !saveFileMan->listSavefiles(name).empty();
}
debug(3, "K_FILEIO_FILE_EXISTS(%s) -> %d", name, exists);
return make_reg(0, exists);
}
default :
error("Unknown FileIO() sub-command: %d", func_nr);
}
return s->r_acc;
}
