/*
* Try loading a resource from a resource library
*/
osfildef *CResLoader::open_lib_res(const char *libfile,
const char *respath)
{
osfildef *fp;
/* try opening the file */
fp = osfoprb(libfile, OSFTT3IMG);
/* if we couldn't open the file, we can't load the resource */
if (fp == 0)
return 0;
/* set up a resource finder for our resource */
CVmImageLoaderMres_resload res_ifc(respath);
/* load the file, so that we can try finding the resource */
CVmImageLoader::load_resources_from_fp(fp, libfile, &res_ifc);
/* check to see if we found it */
if (res_ifc.found_resource())
{
/* we got it - check the type */
if (res_ifc.get_link_fname() != 0)
{
/*
* linked local file - close the library file and open the
* local file instead
*/
osfcls(fp);
fp = osfoprb(res_ifc.get_link_fname(), OSFOPRB);
}
else
{
/* embedded resource - seek to the first byte */
osfseek(fp, res_ifc.get_resource_seek(), OSFSK_SET);
}
/* return the library file handle */
return fp;
}
else
{
/* didn't find the resource - close the library */
osfcls(fp);
/* tell the caller we didn't find the resource */
return 0;
}
}
/*
* open for reading
*/
void CVmFile::open_read(const char *fname, os_filetype_t typ)
{
/* try opening the underlying OS file for binary reading */
fp_ = osfoprb(fname, typ);
/* if that failed, throw an error */
if (fp_ == 0)
err_throw(VMERR_FILE_NOT_FOUND);
}
/*
* Open a resource file given the resource path.
*/
osfildef *CResLoader::open_res_file(const char *respath,
const char *deflib,
const char *exerestype)
{
char filepath[OSFNMAX];
osfildef *fp;
/*
* Look for the resource as an external file. If we have a root
* directory, look for the file under that directory; otherwise,
* look for it in the current directory.
*/
if (root_dir_ != 0)
{
char fname[OSFNMAX];
/* get the resource name as a file path */
os_cvt_url_dir(fname, sizeof(fname), respath, FALSE);
/* build a full path from the root directory and the resource path */
os_build_full_path(filepath, sizeof(filepath), root_dir_, fname);
}
else
{
/* get the resource name as a file path */
os_cvt_url_dir(filepath, sizeof(filepath), respath, FALSE);
}
/* try opening the file */
fp = osfoprb(filepath, OSFTBIN);
/* if we didn't find it, try looking in the default library */
if (fp == 0 && deflib != 0)
{
char fname[OSFNMAX];
/* convert from URL notation to local path conventions */
os_cvt_url_dir(fname, sizeof(fname), deflib, FALSE);
/* build the full path, starting in the root resource directory */
os_build_full_path(filepath, sizeof(filepath), root_dir_, fname);
/* add the default resource library extension */
os_defext(filepath, "t3r");
/* try opening the file */
fp = open_lib_res(filepath, respath);
}
/* if we still didn't find it, try looking in the executable */
if (fp == 0 && exerestype != 0)
fp = open_exe_res(respath, exerestype);
/* return the result */
return fp;
}
/*
* Try loading a resource from the executable file
*/
osfildef *CResLoader::open_exe_res(const char *respath,
const char *restype)
{
osfildef *exe_fp;
/*
* if we don't have an executable filename stored, or we don't have an
* executable resource type ID, we can't load the resource
*/
if (exe_filename_ == 0 || restype == 0)
return 0;
/* find the executable file's resources */
exe_fp = os_exeseek(exe_filename_, restype);
/* if we found something, try loading from that file */
if (exe_fp != 0)
{
CVmImageLoaderMres_resload res_ifc(respath);
/* try loading the resources */
CVmImageLoader::
load_resources_from_fp(exe_fp, exe_filename_, &res_ifc);
/* check to see if we found it */
if (res_ifc.found_resource())
{
/* check the type */
if (res_ifc.get_link_fname() != 0)
{
/*
* it's a linked local file - close the exe file and open
* the local file instead
*/
osfcls(exe_fp);
exe_fp = osfoprb(res_ifc.get_link_fname(), OSFOPRB);
}
else
{
/* we got an exe resource - seek to the starting byte */
osfseek(exe_fp, res_ifc.get_resource_seek(), OSFSK_SET);
}
}
else
{
/* didn't find it - close and forget the executable file */
osfcls(exe_fp);
exe_fp = 0;
}
}
/* return the executable file pointer, if we found the resource */
return exe_fp;
}
/*
* Parse a game file and retrieve game information
*/
int CTadsGameInfo::read_from_file(const char *fname)
{
/* open the file */
osfildef *fp;
if ((fp = osfoprb(fname, OSFTGAME)) == 0
&& (fp = osfoprb(fname, OSFTT3IMG)) == 0)
{
/*
* we can't open the file, so we obviously can't parse it to find
* game information
*/
return 0;
}
/* parse the file and find the game information */
int ret = read_from_fp(fp);
/* we're done with the file - close it */
osfcls(fp);
/* return the results from the parser */
return ret;
}
/*
* Open a plain ASCII source file.
*/
CTcSrcFile *CTcSrcFile::open_ascii(const char *filename)
{
osfildef *fp;
/*
* open the file in binary mode, since we do all of the newline
* interpretation explicitly
*/
if ((fp = osfoprb(filename, OSFTTEXT)) == 0)
return 0;
/* return a source reader with a plain ASCII mapper */
return new CTcSrcFile(fp, new CCharmapToUniASCII());
}
/*
* Find a resource in a file, given the filename.
*
* Fills in the resource information structure with the seek offset and
* size of the resource in the file and returns true if the resource is
* found; returns false if a resource with the given name doesn't exist in
* the file.
*/
int tads_find_resource(const char *fname, const char *resname,
tads_resinfo *info)
{
osfildef *fp;
int found;
/* open the file */
if ((fp = osfoprb(fname, OSFTGAME)) == 0
&& (fp = osfoprb(fname, OSFTT3IMG)) == 0)
{
/* we couldn't open the file, so there's no resource to be found */
return FALSE;
}
/* find the resource in the file */
found = tads_find_resource_fp(fp, resname, info);
/* we're done with the file - close it */
osfcls(fp);
/* return our found or not-found indication */
return found;
}
/*
* Given the name of a file, determine the engine (TADS 2 or TADS 3) for
* which the file was compiled, based on the file's signature. Returns
* one of the VM_GGT_xxx codes.
*/
static int vm_get_game_type_for_file(const char *filename)
{
osfildef *fp;
char buf[16];
int ret;
/* try opening the filename exactly as given */
fp = osfoprb(filename, OSFTBIN);
/* if the file doesn't exist, tell the caller */
if (fp == 0)
return VM_GGT_NOT_FOUND;
/* read the first few bytes of the file, where the signature resides */
if (osfrb(fp, buf, 16))
{
/*
* error reading the file - any valid game file is going to be at
* least long enough to hold the number of bytes we asked for, so
* it must not be a valid file
*/
ret = VM_GGT_INVALID;
}
else
{
/* check the signature we read against the known signatures */
if (memcmp(buf, "TADS2 bin\012\015\032", 12) == 0)
ret = VM_GGT_TADS2;
else if (memcmp(buf, "T3-image\015\012\032", 11) == 0)
ret = VM_GGT_TADS3;
else
ret = VM_GGT_INVALID;
}
/* close the file */
osfcls(fp);
/* return the version identifier */
return ret;
}
/*
* Given a saved game file, try to identify the game file that created the
* saved game.
*/
static int vm_get_game_file_from_savefile(const char *savefile,
char *fname, size_t fnamelen)
{
osfildef *fp;
char buf[128];
int ret;
size_t len;
/* open the saved game file */
fp = osfoprb(savefile, OSFTBIN);
/* if that failed, there's no way to read the game file name */
if (fp == 0)
return FALSE;
/* read the first few bytes */
if (osfrb(fp, buf, 16))
{
/*
* we couldn't even read that much, so it must not really be a
* saved game file
*/
ret = FALSE;
}
else
{
/* check for a saved game signature we recognize */
if (memcmp(buf, "TADS2 save/g\012\015\032\000", 16) == 0)
{
/*
* It's a TADS 2 saved game with embedded .GAM file
* information. The filename immediately follows the signature
* (the 15 bytes we just matched), with a two-byte length
* prefix. Seek to the length prefix and read it.
*/
osfseek(fp, 16, OSFSK_SET);
osfrb(fp, buf, 2);
len = osrp2(buf);
/* limit the read length to our caller's available buffer */
if (len > fnamelen - 1)
len = fnamelen - 1;
/* read the filename and null-terminate it */
osfrb(fp, fname, len);
fname[len] = '\0';
/* success */
ret = TRUE;
}
else if (memcmp(buf, "T3-state-v", 10) == 0)
{
/*
* It's a T3 saved state file. The image filename is always
* embedded in this type of file, so seek back to the start of
* the file and read the filename.
*
* Note that restore_get_image() returns zero on success, so we
* want to return true if and only if that routine returns
* zero.
*/
osfseek(fp, 0, OSFSK_SET);
ret = (CVmSaveFile::restore_get_image(fp, fname, fnamelen) == 0);
}
else
{
/*
* it's not a signature we know, so it must not be a saved
* state file (at least not one we can deal with)
*/
ret = FALSE;
}
}
/* we're done with the file now, so close it */
osfcls(fp);
/* return the result */
return ret;
}
/*
* Main Entrypoint for command-line invocations. For simplicity, a
* normal C main() or equivalent entrypoint can invoke this routine
* directly, using the usual argc/argv conventions.
*
* Returns a status code suitable for use with exit(): OSEXSUCC if we
* successfully loaded and ran an executable, OSEXFAIL on failure. If
* an error occurs, we'll fill in 'errbuf' with a message describing the
* problem.
*/
int vm_run_image_main(CVmMainClientIfc *clientifc,
const char *executable_name,
int argc, char **argv, int defext, int test_mode,
CVmHostIfc *hostifc)
{
int curarg;
char image_file_name[OSFNMAX];
int stat;
const char *script_file;
int script_quiet = TRUE;
const char *log_file;
const char *cmd_log_file;
const char *res_dir;
int load_from_exe;
int show_banner;
int found_image;
int hide_usage;
int usage_err;
const char *charset;
const char *log_charset;
char *saved_state;
/* we haven't found an image file yet */
found_image = FALSE;
/* presume we'll show usage on error */
hide_usage = FALSE;
/* presume there will be no usage error */
usage_err = FALSE;
/* presume we won't have any console input/output files */
script_file = 0;
log_file = 0;
cmd_log_file = 0;
/* presume we'll use the default OS character sets */
charset = 0;
log_charset = 0;
/* presume we won't show the banner */
show_banner = FALSE;
/* presume we won't load from the .exe file */
load_from_exe = FALSE;
/* check to see if we can load from the .exe file */
{
osfildef *fp;
/* look for an image file attached to the executable */
fp = os_exeseek(argv[0], "TGAM");
if (fp != 0)
{
/* close the file */
osfcls(fp);
/* note that we want to load from the executable */
load_from_exe = TRUE;
}
}
/* presume we won't restore a saved state file */
saved_state = 0;
/* presume we won't have a resource directory specified */
res_dir = 0;
/* scan options */
for (curarg = 1 ; curarg < argc && argv[curarg][0] == '-' ; ++curarg)
{
/*
* if the argument is just '-', it means we're explicitly leaving
* the image filename blank and skipping to the arguments to the VM
* program itself
*/
if (argv[curarg][1] == '\0')
break;
/* check the argument */
switch(argv[curarg][1])
{
case 'b':
if (strcmp(argv[curarg], "-banner") == 0)
{
/* make a note to show the banner */
show_banner = TRUE;
}
else
goto opt_error;
break;
case 'c':
if (strcmp(argv[curarg], "-cs") == 0)
{
++curarg;
if (curarg < argc)
charset = argv[curarg];
else
goto opt_error;
}
else if (strcmp(argv[curarg], "-csl") == 0)
{
++curarg;
if (curarg < argc)
log_charset = argv[curarg];
else
goto opt_error;
}
else
goto opt_error;
break;
case 'n':
if (strcmp(argv[curarg], "-nobanner") == 0)
{
/* make a note not to show the banner */
show_banner = FALSE;
}
else
goto opt_error;
break;
case 's':
/* file safety level - check the range */
if (argv[curarg][2] < '0' || argv[curarg][2] > '4'
|| argv[curarg][3] != '\0')
{
/* invalid level */
goto opt_error;
}
else
{
/* set the level in the host application */
hostifc->set_io_safety(argv[curarg][2] - '0');
}
break;
case 'i':
case 'I':
/*
* read from a script file (little 'i' reads silently, big 'I'
* echoes the log as it goes) - the next argument, or the
* remainder of this argument, is the filename
*/
script_quiet = (argv[curarg][1] == 'i');
script_file = get_opt_arg(argc, argv, &curarg, 2);
if (script_file == 0)
goto opt_error;
break;
case 'l':
/* log output to file */
log_file = get_opt_arg(argc, argv, &curarg, 2);
if (log_file == 0)
goto opt_error;
break;
case 'o':
/* log commands to file */
cmd_log_file = get_opt_arg(argc, argv, &curarg, 2);
if (cmd_log_file == 0)
goto opt_error;
break;
case 'p':
/* check what follows */
if (strcmp(argv[curarg], "-plain") == 0)
{
/* tell the client to set plain ASCII mode */
clientifc->set_plain_mode();
break;
}
else
goto opt_error;
break;
case 'r':
/* get the name of the saved state file to restore */
saved_state = get_opt_arg(argc, argv, &curarg, 2);
if (saved_state == 0)
goto opt_error;
break;
case 'R':
/* note the resource root directory */
res_dir = get_opt_arg(argc, argv, &curarg, 2);
if (res_dir == 0)
goto opt_error;
break;
default:
opt_error:
/* discard remaining arguments */
curarg = argc;
/* note the error */
usage_err = TRUE;
break;
}
}
/*
* If there was no usage error so far, but we don't have an image
* filename argument, try to find the image file some other way. If we
* found an image file embedded in the executable, don't even bother
* looking for an image-file argument - we can only run the embedded
* image in this case.
*/
if (usage_err)
{
/* there was a usage error - don't bother looking for an image file */
}
else if (!load_from_exe
&& curarg + 1 <= argc
&& strcmp(argv[curarg], "-") != 0)
{
/* the last argument is the image file name */
strcpy(image_file_name, argv[curarg]);
found_image = TRUE;
/*
* If the given filename exists, use it as-is; otherwise, if
* we're allowed to add an extension, try applying a default
* extension of "t3" (formerly "t3x") to the given name.
*/
if (defext && osfacc(image_file_name))
{
/* the given name doesn't exist - try a default extension */
os_defext(image_file_name, "t3"); /* formerly "t3x" */
}
}
else
{
/*
* if we're loading from the executable, try using the executable
* filename as the image file
*/
if (load_from_exe
&& os_get_exe_filename(image_file_name, sizeof(image_file_name),
argv[0]))
found_image = TRUE;
/*
* If we still haven't found an image file, try to get the image
* file from the saved state file, if one was specified. Don't
* attempt this if we're loading the image from the executable, as
* we don't want to allow running a different image file in that
* case.
*/
if (!load_from_exe && !found_image && saved_state != 0)
{
osfildef *save_fp;
/* open the saved state file */
save_fp = osfoprb(saved_state, OSFTT3SAV);
if (save_fp != 0)
{
/* get the name of the image file */
if (CVmSaveFile::restore_get_image(
save_fp, image_file_name, sizeof(image_file_name)) == 0)
{
/* we successfully obtained the filename */
found_image = TRUE;
}
/* close the file */
osfcls(save_fp);
}
}
/*
* if we haven't found the image, and the host system provides a
* way of asking the user for a filename, try that
*/
if (!load_from_exe && !found_image)
{
/* ask the host system for a game name */
switch (hostifc->get_image_name(image_file_name,
sizeof(image_file_name)))
{
case VMHOST_GIN_IGNORED:
/* no effect - we have no new information */
break;
case VMHOST_GIN_CANCEL:
/*
* the user cancelled the dialog - we don't have a
* filename, but we also don't want to show usage, since
* the user chose not to proceed
*/
hide_usage = TRUE;
break;
case VMHOST_GIN_ERROR:
/*
* an error occurred showing the dialog - there's not
* much we can do except show the usage message
*/
break;
case VMHOST_GIN_SUCCESS:
/* that was successful - we have an image file now */
found_image = TRUE;
break;
}
}
}
/*
* if we don't have an image file name by this point, we can't
* proceed - show the usage message and terminate
*/
if (usage_err || !found_image)
{
char buf[OSFNMAX + 1024];
/* show the usage message if allowed */
if (load_from_exe && !usage_err)
{
sprintf(buf, "An error occurred loading the T3 VM program from "
"the embedded data file. This application executable "
"file might be corrupted.\n");
/* display the message */
clientifc->display_error(0, buf, FALSE);
}
else if (!hide_usage)
{
/* build the usage message */
sprintf(buf,
"%s\n"
"usage: %s [options] %sarguments]\n"
"options:\n"
" -banner - show the version/copyright banner\n"
" -cs xxx - use character set 'xxx' for keyboard "
"and display\n"
" -csl xxx - use character set 'xxx' for log files\n"
" -i file - read command input from file (quiet mode)\n"
" -I file - read command input from file (echo mode)\n"
" -l file - log all console input/output to file\n"
" -o file - log console input to file\n"
" -plain - run in plain mode (no cursor positioning, "
"colors, etc.)\n"
" -r file - restore saved state from file\n"
" -R dir - set directory for external resources\n"
" -s# - set I/O safety level (# in range 0 to 4 - 0 "
"is the least\n"
" restrictive, 4 allows no file I/O at all)\n"
"\n"
"If provided, the optional extra arguments are passed "
"to the program's\n"
"main entrypoint.\n",
T3VM_BANNER_STRING, executable_name,
load_from_exe ? "[- " : "<image-file-name> [");
/* display the message */
clientifc->display_error(0, buf, FALSE);
}
/* return failure */
return OSEXFAIL;
}
/*
* if we're in test mode, replace the first argument to the program
* with its root name, so that we don't include any path information
* in the argument list
*/
if (test_mode && curarg <= argc && argv[curarg] != 0)
argv[curarg] = os_get_root_name(argv[curarg]);
/* run the program */
stat = vm_run_image(clientifc, image_file_name, hostifc,
argv + curarg, argc - curarg,
script_file, script_quiet, log_file, cmd_log_file,
load_from_exe, show_banner,
charset, log_charset,
saved_state, res_dir);
/* return the status code */
return stat;
}
/*
* Process an HTML resource list. If 'old_htmlres' is true, it
* indicates that the input file is pointing to an old resource map;
* otherwise, we need to construct a brand new one.
*/
static opdef *prochtmlres(osfildef *fp, osfildef *fpout, opdef *oplist,
int *copyrsc, int *showed_heading, int old_htmlres)
{
opdef *op;
opdef *add_list = 0;
opdef *prev_op;
opdef *next_op;
int found;
char buf[512];
ulong in_entry_cnt;
ulong in_table_siz;
ulong out_hdr_siz;
ulong out_hdr_pos;
ulong i;
ulong out_res_cnt;
ulong out_total_name_len;
ulong rem;
struct idx_t **in_list = 0, *out_list = 0, **p, *cur;
ulong in_res_base, out_res_base;
ulong out_endpos;
/*
* Scan the oplist for an HTML resource. If there aren't any, we
* don't need to modify the HTMLRES list, so tell the caller to copy
* this resource unchanged.
*/
for (op = oplist, found = FALSE ; op != 0 ; op = op->opnxt)
{
/* if this is an HTML resource, note it and stop looking */
if (op->oprestype == RESTYPE_HTML)
{
found = TRUE;
break;
}
}
/*
* If we didn't find any operations on this resource, and we're not
* simply listing resources or we don't have an old resource to
* list, tell the caller to copy it unchanged.
*/
if (!found && (fpout != 0 || !old_htmlres))
{
*copyrsc = TRUE;
return oplist;
}
/* we'll be handling the resource - tell the caller not to copy it */
*copyrsc = FALSE;
/* if there's an old HTMLRES resource, read it */
if (old_htmlres)
{
/* read the index entry count and size */
if (osfrb(fp, buf, 8))
listexit(fp, "unable to read HTMLRES header");
in_entry_cnt = osrp4(buf);
in_table_siz = osrp4(buf + 4);
/* allocate space for pointers to all of the entries */
if (in_entry_cnt != 0)
{
in_list = (struct idx_t **)
malloc(in_entry_cnt * sizeof(struct idx_t *));
if (in_list == 0)
listexit(fp, "unable to allocate space for HTMLRES entries");
}
/* read the index table entries */
for (i = 0, p = in_list ; i < in_entry_cnt ; ++i, ++p)
{
ushort name_siz;
ulong res_siz;
ulong res_ofs;
/* read the entry information */
if (osfrb(fp, buf, 10))
listexit(fp,
"unable to read HTMLRES index table entry (prefix)");
/* get the resource size */
res_ofs = osrp4(buf);
res_siz = osrp4(buf + 4);
/* read the name */
name_siz = osrp2(buf + 8);
if (name_siz > sizeof(buf))
listexit(fp, "name too large in HTMLRES index table entry");
if (osfrb(fp, buf, name_siz))
listexit(fp,
"unable to read HTMLRES index table entry (name)");
/* build this entry */
*p = alloc_idx_entry(res_ofs, res_siz, buf, name_siz, 0, 0);
}
/* if we don't have an output file, list the HTMLRES contents */
if (fpout == 0)
{
/* display all of the entries */
for (i = 0, p = in_list ; i < in_entry_cnt ; ++i, ++p)
show_list_item(showed_heading, "HTML",
(*p)->siz, (*p)->nam, (*p)->namlen);
/* there's no more processing to do */
goto done;
}
/*
* The resources start at the end of the index table - note the
* location of the end of the input table, since it's the base
* address relative to which the resource offsets are stated.
*/
in_res_base = osfpos(fp);
/*
* Go through the resource table in the input file. Find each
* one in the op list. If it's not in the op list, we'll copy
* it to the output file.
*/
for (i = 0, p = in_list ; i < in_entry_cnt ; ++i, ++p)
{
int remove_res = FALSE;
int add_res = FALSE;
/* see if we can find this entry in the op list */
for (prev_op = 0, op = oplist ; op != 0 ;
prev_op = op, op = op->opnxt)
{
/* if this one matches, note it */
if (op->oprestype == RESTYPE_HTML
&& strlen(op->opres) == (*p)->namlen
&& !memicmp(op->opres, (*p)->nam, (*p)->namlen))
{
/*
* if we're adding this resource (not replacing it),
* warn that it's already in the file, and ignore
* this op; if we're removing it or replacing it,
* simply delete this entry from the input list so
* it doesn't get copied to the output.
*/
if (!(op->opflag & OPFDEL))
{
/* warn that the old one will stay */
rscptf("warning: HTML resource \"%s\" already "
"present\n"
" -- old version will be kept (use -replace "
"to replace it)\n", op->opres);
/* remove it from the processing list */
remove_res = TRUE;
}
else
{
/* we are deleting it; see if we're also adding it */
if (op->opflag & OPFADD)
{
/*
* we're replacing this resource - take this
* op out of the main list and put it into
* the add list
*/
remove_res = TRUE;
add_res = TRUE;
/* note the addition */
show_op("replacing", op->opres, strlen(op->opres),
op->oprestype);
}
else
{
/* note the deletion */
show_op("deleting", op->opres, strlen(op->opres),
op->oprestype);
/* just remove it */
remove_res = TRUE;
}
/* get rid of this item from the input list */
free(*p);
*p = 0;
}
/* no need to look further in the operations list */
break;
}
}
/*
* If desired, remove this resource from the main list, and
* add it into the list of resources to add.
*/
if (remove_res)
{
/* unlink it from the main list */
if (prev_op == 0)
oplist = op->opnxt;
else
prev_op->opnxt = op->opnxt;
/* if desired, add it to the additions list */
if (add_res)
{
/* we're adding it - put it in the additions list */
op->opnxt = add_list;
add_list = op;
}
else
{
/* this item has been processed - delete it */
free(op);
}
}
}
}
else
{
/* there are no entries in the input file */
in_entry_cnt = 0;
in_table_siz = 0;
}
/*
* Move all of the HTML resources marked as additions in the main
* operations list into the additions list.
*/
for (prev_op = 0, op = oplist ; op != 0 ; op = next_op)
{
/* note the next op, in case we move this one to the other list */
next_op = op->opnxt;
/*
* if it's an HTML resource to be added, move it to the
* additions list
*/
if (op->oprestype == RESTYPE_HTML && (op->opflag & OPFADD) != 0)
{
/* show what we're doing */
show_op("adding", op->opres, strlen(op->opres), op->oprestype);
/* unlink it from the main list */
if (prev_op == 0)
oplist = op->opnxt;
else
prev_op->opnxt = op->opnxt;
/* add it to the additions list */
op->opnxt = add_list;
add_list = op;
/*
* note that we don't want to advance the 'prev_op' pointer,
* since we just removed this item - the previous item is
* still the same as it was on the last iteration
*/
}
else
{
/*
* we're leaving this op in the original list - it's now the
* previous op in the main list
*/
prev_op = op;
}
}
/*
* Figure out what we'll be putting in the HTMLRES list: we'll add
* each surviving entry from the input file, plus all of the items
* in the add list, plus all of the HTML items in the main list that
* are marked for addition.
*/
out_res_cnt = 0;
out_total_name_len = 0;
/* count input file entries that we're going to copy */
for (i = 0, p = in_list ; i < in_entry_cnt ; ++i, ++p)
{
if (*p != 0)
add_idx_entry(&out_list, &out_res_cnt, &out_total_name_len,
0, 0, (*p)->nam, (*p)->namlen, 0, *p);
}
/*
* Count items in the additions list. Note that every HTML resource
* marked for addition is in the additions list, since we moved all
* such resources out of the main list and into the additions list
* earlier.
*/
for (op = add_list ; op != 0 ; op = op->opnxt)
add_idx_entry(&out_list, &out_res_cnt, &out_total_name_len,
0, 0, op->opres, (ushort)strlen(op->opres), op, 0);
/* write the resource header */
if (osfwb(fpout, "\007HTMLRES\0\0\0\0", 12))
listexit(fp, "unable to write HTMLRES type header");
out_hdr_pos = osfpos(fpout);
/*
* Reserve space in the output file for the index table. We need
* eight bytes for the index table prefix, then ten bytes per entry
* plus the name sizes.
*/
out_hdr_siz = 8 + (10 * out_res_cnt) + out_total_name_len;
/* write the index table prefix */
oswp4(buf, out_res_cnt);
oswp4(buf + 4, out_hdr_siz);
if (osfwb(fpout, buf, 8))
listexit(fp, "unable to write HTMLRES prefix");
/*
* Reserve space for the headers. Don't actually write them yet,
* since we don't know the actual locations and sizes of the
* entries; for now, simply reserve the space, so that we can come
* back here later and write the actual headers. Note that we
* deduct the eight bytes we've already written from the amount of
* filler to put in.
*/
for (rem = out_hdr_siz - 8 ; rem != 0 ; )
{
ulong amt;
/* write out a buffer full */
amt = (rem > sizeof(buf) ? sizeof(buf) : rem);
if (osfwb(fpout, buf, amt))
listexit(fp, "unable to write HTMLRES header");
/* deduct the amount we wrote from the remainder */
rem -= amt;
}
/*
* note the current position in the output file - this is the base
* address of the resources
*/
out_res_base = osfpos(fpout);
/*
* Write the resources.
*/
for (cur = out_list ; cur != 0 ; cur = cur->nxt)
{
/*
* note the current file position as an offset from the resource
* base in the output file - this is the offset that we need to
* store in the index entry for this object
*/
cur->ofs = osfpos(fpout) - out_res_base;
/*
* Copy the resource to the output. If it comes from the input
* file, copy from there, otherwise go out and find the external
* file and copy its contents.
*/
if (cur->src_op != 0)
{
osfildef *fpext;
ulong fsiz;
/* it comes from an external file - open the file */
fpext = osfoprb(cur->src_op->opfile, OSFTGAME);
if (fpext == 0)
{
rscptf("%s: ", cur->src_op->opfile);
errexit("unable to open file", 1);
}
/* figure the size of the file */
osfseek(fpext, 0L, OSFSK_END);
fsiz = osfpos(fpext);
osfseek(fpext, 0L, OSFSK_SET);
/* copy the contents of the external file to the output */
copybytes(fpext, fpout, fsiz);
/* the size is the same as the external file's size */
cur->siz = fsiz;
/* done with the file */
osfcls(fpext);
}
else
{
/*
* it comes from the input resource file - seek to the start
* of the resource in the input file, and copy the data to
* the output file
*/
osfseek(fp, in_res_base + cur->src_idx->ofs, OSFSK_SET);
copybytes(fp, fpout, cur->src_idx->siz);
/* the size is the same as in the input file */
cur->siz = cur->src_idx->siz;
}
}
/* note the current output position - this is the end of the resource */
out_endpos = osfpos(fpout);
/*
* Now that we've written all of the resources and know their actual
* layout in the file, we can go back and write the index table.
*/
osfseek(fpout, out_hdr_pos + 8, OSFSK_SET);
for (cur = out_list ; cur != 0 ; cur = cur->nxt)
{
/* build this object's index table entry */
oswp4(buf, cur->ofs);
oswp4(buf + 4, cur->siz);
oswp2(buf + 8, cur->namlen);
/* write the entry */
if (osfwb(fpout, buf, 10)
|| osfwb(fpout, cur->nam, cur->namlen))
listexit(fp, "unable to write HTML index table entry");
}
/*
* We're done building the resource; now all we need to do is go
* back and write the ending position of the resource in the
* resource header.
*/
osfseek(fpout, out_hdr_pos - 4, OSFSK_SET);
oswp4(buf, out_endpos);
if (osfwb(fpout, buf, 4))
errexit("error writing resource", 1);
/* seek back to the end of the resource in the output file */
osfseek(fpout, out_endpos, OSFSK_SET);
done:
/* if we have an input list, free it */
if (in_list != 0)
{
/* delete all of the entries in the input table */
for (i = 0, p = in_list ; i < in_entry_cnt ; ++i, ++p)
{
/* delete this entry if we haven't already done so */
if (*p != 0)
free(*p);
}
/* delete the input pointer list itself */
free(in_list);
}
/*
* delete everything in the additions list, since we're done with
* them now
*/
for (op = add_list ; op != 0 ; op = next_op)
{
/* note the next entry in the list */
next_op = op->opnxt;
/* delete this entry */
free(op);
}
/* return the op list in its current form */
return oplist;
}
/*
* Open a plain ASCII file, with no #charset marker.
*/
CTcSrcFile *CTcSrcFile::open_plain(const char *filename)
{
osfildef *fp;
char buf[5];
size_t siz;
/*
* open the file in binary mode, since we do all of the newline
* interpretation explicitly
*/
if ((fp = osfoprb(filename, OSFTTEXT)) == 0)
return 0;
/* read the first few bytes of the file */
siz = osfrbc(fp, buf, sizeof(buf));
/* check for a 3-byte UTF-8 marker */
if (siz >= 3
&& (uchar)buf[0] == 0xEF
&& (uchar)buf[1] == 0xBB
&& (uchar)buf[2] == 0xBF)
{
/*
* seek to the byte after the marker, so that our caller won't see
* the marker
*/
osfseek(fp, 3, OSFSK_SET);
/* return a source file reader with a utf-8 mapper */
return new CTcSrcFile(fp, new CCharmapToUniUTF8());
}
/* if we read at least two bytes, try auto-detecting UCS-2 */
if (siz >= 2)
{
/* if the first bytes are 0xFF 0xFE, it's UCS-2 low-byte first */
if ((unsigned char)buf[0] == 0xFF && (unsigned char)buf[1] == 0xFE)
{
/* seek to the byte after the marker */
osfseek(fp, 2, OSFSK_SET);
/* return a reader with a little-endian mapper */
return new CTcSrcFile(fp, new CCharmapToUniUcs2Little());
}
/* if the first bytes are 0xFE 0xFF, it's UCS-2 high-byte first */
if ((unsigned char)buf[0] == 0xFE && (unsigned char)buf[1] == 0xFF)
{
/* seek to the byte after the marker */
osfseek(fp, 2, OSFSK_SET);
/* return a reader with a little-endian mapper */
return new CTcSrcFile(fp, new CCharmapToUniUcs2Big());
}
}
/*
* there are no Unicode markers, so our only remaining option is plain
* ASCII - return a source file object with a plain ASCII mapper
*/
return new CTcSrcFile(fp, new CCharmapToUniASCII());
}
/*
* Open a source file
*/
CTcSrcFile *CTcSrcFile::open_source(const char *filename,
class CResLoader *res_loader,
const char *default_charset,
int *charset_error,
int *default_charset_error)
{
char buf[275];
size_t siz;
osfildef *fp;
long startofs;
CCharmapToUni *mapper;
/* presume we won't find an invalid #charset directive */
*charset_error = FALSE;
/* presume we'll have no problem with the default character set */
*default_charset_error = FALSE;
/*
* open the file in binary mode, so that we can scan the first few
* bytes to see if we can detect the character set from information
* at the beginning of the file
*/
fp = osfoprb(filename, OSFTTEXT);
/* if we couldn't open the file, return failure */
if (fp == 0)
return 0;
/* note the starting offset in the file */
startofs = osfpos(fp);
/* read the first few bytes of the file */
siz = osfrbc(fp, buf, sizeof(buf));
/* check for a 3-byte UTF-8 byte-order marker */
if (siz >= 3 && (uchar)buf[0] == 0xEF && (uchar)buf[1] == 0xBB
&& (uchar)buf[2] == 0xBF)
{
char *p;
size_t rem;
uint skip;
/* skip at least the three-byte marker sequence */
skip = 3;
/*
* check for a #charset marker for utf-8 - this would be redundant,
* but we'll allow it
*/
p = buf + 3;
rem = siz - 3;
if (rem > 9 && memcmp(p, "#charset ", 9) == 0)
{
/* skip spaces */
for (p += 9, rem -= 9 ; rem != 0 && (*p == ' ' || *p == '\t') ;
++p, --rem);
/* check for valid character set markers */
if (rem >= 7 && memicmp(p, "\"utf-8\"", 7) == 0)
{
/* skip the whole sequence */
skip = (p + 7) - buf;
}
else if (rem >= 6 && memicmp(p, "\"utf8\"", 6) == 0)
{
/* skip the whole sequence */
skip = (p + 6) - buf;
}
}
/* seek past the character set markers */
osfseek(fp, startofs + skip, OSFSK_SET);
/* return a new utf-8 decoder */
return new CTcSrcFile(fp, new CCharmapToUniUTF8());
}
/* if we read at least two bytes, try auto-detecting unicode */
if (siz >= 2)
{
CTcSrcFile *srcf;
const char *const *cs_names;
int bige;
/* presume we won't find a byte-order marker */
srcf = 0;
/* if the first bytes are 0xFF 0xFE, it's UCS-2 low-byte first */
if ((unsigned char)buf[0] == 0xFF && (unsigned char)buf[1] == 0xFE)
{
static const char *names[] = { "unicodel", "utf-16le", 0 };
/* create a UCS-2 little-endian reader */
srcf = new CTcSrcFile(fp, new CCharmapToUniUcs2Little());
bige = FALSE;
cs_names = names;
}
/* if the first bytes are 0xFE 0xFF, it's UCS-2 high-byte first */
if ((unsigned char)buf[0] == 0xFE && (unsigned char)buf[1] == 0xFF)
{
static const char *names[] = { "unicodeb", "utf-16be", 0 };
/* create a UCS-2 little-endian reader */
srcf = new CTcSrcFile(fp, new CCharmapToUniUcs2Big());
bige = TRUE;
cs_names = names;
}
/* if we found the byte-order marker, we know the character set */
if (srcf != 0)
{
uint skip;
/* we at least want to skip the byte-order marker */
skip = 2;
/* check to see if we have a '#charset' directive */
if (ucs_str_starts_with(buf + 2, siz - 2, "#charset ",
bige, FALSE))
{
char *p;
size_t rem;
/* scan past following spaces */
for (p = buf + 2 + 18, rem = siz - 2 - 18 ;
rem >= 2 && (ucs_char_eq(p, ' ', bige, FALSE)
|| ucs_char_eq(p, '\t', bige, FALSE)) ;
p += 2, rem -= 2) ;
/* check for a '"' */
if (rem >= 2 && ucs_char_eq(p, '"', bige, FALSE))
{
const char *const *n;
/* skip the '"' */
p += 2;
rem -= 2;
/*
* check for a match to any of the valid names for this
* character set
*/
for (n = cs_names ; *n != 0 ; ++n)
{
/* if it's a match, stop scanning */
if (ucs_str_starts_with(p, rem, *n, bige, TRUE))
{
size_t l;
/* get the length of the name */
l = strlen(*n) * 2;
/* check for a close quote */
if (rem >= l + 2
&& ucs_char_eq(p + l, '"', bige, FALSE))
{
/* skip the name and the quote */
p += l + 2;
rem -= l + 2;
/* skip the source text to this point */
skip = p - buf;
/* stop scanning */
break;
}
}
}
}
}
/* seek just past the character set indicators */
osfseek(fp, startofs + skip, OSFSK_SET);
/* return the file */
return srcf;
}
}
/*
* It doesn't appear to use UCS-2 encoding (at least, the file
* doesn't start with a byte-order sensing sequence). Check to see
* if the file starts with "#charset " in ASCII single-byte
* characters.
*/
if (siz >= 9 && memcmp(buf, "#charset ", 9) == 0)
{
char *p;
size_t rem;
/* skip the #charset string and any following spaces */
for (p = buf + 9, rem = siz - 9 ;
rem > 0 && (*p == ' ' || *p == '\t') ; ++p, --rem) ;
/* make sure we're looking at a '"' */
if (rem != 0 && *p == '"')
{
char *charset_name;
/* skip the open quote */
++p;
--rem;
/* remember where the character set name starts */
charset_name = p;
/*
* find the closing quote, which must occur before a CR or
* LF character
*/
for ( ; rem > 0 && *p != '"' && *p != 10 && *p != 13 ;
++p, --rem) ;
/* make sure we found a matching quote */
if (rem != 0 && *p == '"')
{
/* seek just past the #charset string */
osfseek(fp, startofs + (p - buf) + 1, OSFSK_SET);
/*
* put a null terminator at the end of the character set
* name
*/
*p = '\0';
/* create a mapper */
mapper = CCharmapToUni::load(res_loader, charset_name);
/*
* if that succeeded, return a reader for the mapper;
* otherwise, simply proceed as though no #charset had
* been present, so that we create a default mapper
*/
if (mapper != 0)
{
/* success - return a reader */
return new CTcSrcFile(fp, mapper);
}
else
{
/* tell the caller the #charset was invalid */
*charset_error = TRUE;
}
}
}
}
/*
* we didn't find any sensing codes, so seek back to the start of
* the file
*/
osfseek(fp, startofs, OSFSK_SET);
/*
* We couldn't identify the file's character set based on anything
* in the file, so create a mapper for the given default character
* set. If there's not even a default character set defined, create
* a plain ASCII mapper.
*/
if (default_charset != 0)
mapper = CCharmapToUni::load(res_loader, default_charset);
else
mapper = new CCharmapToUniASCII();
/* check to see if we created a mapper */
if (mapper != 0)
{
/* return a source file reader based on the mapper */
return new CTcSrcFile(fp, mapper);
}
else
{
/*
* we failed to create a mapper for the default character set -
* flag the problem
*/
*default_charset_error = TRUE;
/* close the input file */
osfcls(fp);
/* return failure */
return 0;
}
}
/* process an operation */
static void procop(osfildef *fpout, opdef *op, ulong *first_xfcn)
{
osfildef *fpin;
char buf[128];
uint fsiz;
ulong sizpos;
ulong endpos;
/* remember location of first resource if necessary */
if (fpout && *first_xfcn == 0)
*first_xfcn = osfpos(fpout);
fpin = osfoprb(op->opfile, OSFTGAME);
if (fpin == 0)
{
rscptf("%s: ", op->opfile);
errexit("unable to open file", 1);
}
/* get file size */
osfseek(fpin, 0L, OSFSK_END);
fsiz = (uint)osfpos(fpin);
osfseek(fpin, 0L, OSFSK_SET);
/* set up the resource type part of the header */
switch(op->oprestype)
{
case RESTYPE_XFCN:
buf[0] = 4;
memcpy(buf + 1, "XFCN", 4);
break;
case RESTYPE_HTML:
buf[0] = 4;
memcpy(buf + 1, "HTML", 3);
break;
}
/* set up the rest of the header */
if (osfwb(fpout, buf, buf[0] + 1)) errexit("error writing resource", 1);
sizpos = osfpos(fpout); /* remember where size field goes */
oswp4(buf, 0);
if (osfwb(fpout, buf, 4)) errexit("error writing resource", 1);
/* set up the header */
oswp2(buf, fsiz);
buf[2] = strlen(op->opres);
strcpy(buf + 3, op->opres);
if (osfwb(fpout, buf, (uint)(buf[2] + 3)))
errexit("error writing resource", 1);
/* copy the resource to the output */
copybytes(fpin, fpout, fsiz);
/* write end position in the resource header */
endpos = osfpos(fpout);
oswp4(buf, endpos);
osfseek(fpout, sizpos, OSFSK_SET);
if (osfwb(fpout, buf, 4)) errexit("error writing resource", 1);
/* seek back to the end of the resource in the output file */
osfseek(fpout, endpos, OSFSK_SET);
/* done with the input file */
osfcls(fpin);
}
int TADS2::cmap_load_internal(const char *filename) {
osfildef *fp;
static char sig1[] = CMAP_SIG_S100;
char buf[256];
uchar lenbuf[2];
size_t len;
int sysblk;
// if there's no mapping file, use the default mapping
if (filename == 0) {
// initialize with the default mapping
cmap_init_default();
// return success
return 0;
}
// open the file
fp = osfoprb(filename, OSFTCMAP);
if (fp == 0)
return 1;
// check the signature
if (osfrb(fp, buf, sizeof(sig1))
|| memcmp(buf, sig1, sizeof(sig1)) != 0) {
osfcls(fp);
return 2;
}
// load the ID
G_cmap_id[4] = '\0';
if (osfrb(fp, G_cmap_id, 4)) {
osfcls(fp);
return 3;
}
// load the long description
if (osfrb(fp, lenbuf, 2)
|| (len = osrp2(lenbuf)) > sizeof(G_cmap_ldesc)
|| osfrb(fp, G_cmap_ldesc, len)) {
osfcls(fp);
return 4;
}
// load the two tables - input, then output
if (osfrb(fp, G_cmap_input, sizeof(G_cmap_input))
|| osfrb(fp, G_cmap_output, sizeof(G_cmap_output))) {
osfcls(fp);
return 5;
}
// read the next section header
if (osfrb(fp, buf, 4)) {
osfcls(fp);
return 6;
}
// if it's "SYSI", read the system information string
if (!memcmp(buf, "SYSI", 4)) {
// read the length prefix, then the string
if (osfrb(fp, lenbuf, 2)
|| (len = osrp2(lenbuf)) > sizeof(buf)
|| osfrb(fp, buf, len)) {
osfcls(fp);
return 7;
}
// we have a system information block
sysblk = true;
} else {
// there's no system information block
sysblk = false;
}
/*
* call the OS code, so that it can do any system-dependent
* initialization for the new character mapping
*/
os_advise_load_charmap(G_cmap_id, G_cmap_ldesc, sysblk ? buf : "");
// read the next section header
if (sysblk && osfrb(fp, buf, 4)) {
osfcls(fp);
return 8;
}
// see if we have an entity list
if (!memcmp(buf, "ENTY", 4)) {
// read the entities
for (;;) {
unsigned int cval;
char expansion[CMAP_MAX_ENTITY_EXPANSION];
// read the next item's length and character value
if (osfrb(fp, buf, 4)) {
osfcls(fp);
return 9;
}
// decode the values
len = osrp2(buf);
cval = osrp2(buf+2);
// if we've reached the zero marker, we're done
if (len == 0 && cval == 0)
break;
// read the string
if (len > CMAP_MAX_ENTITY_EXPANSION
|| osfrb(fp, expansion, len)) {
osfcls(fp);
return 10;
}
// tell the output code about the expansion
tio_set_html_expansion(cval, expansion, len);
}
}
/*
* ignore anything else we find - if the file format is updated to
* include extra information in the future, and this old code tries
* to load an updated file, we'll just ignore the new information,
* which should always be placed after the "SYSI" block (if present)
* to ensure compatibility with past versions (such as this code)
*/
// no problems - close the file and return success
osfcls(fp);
return 0;
}
int main(int argc, char **argv)
{
osfildef *fp;
const char *fname;
const char *resname;
tads_resinfo res_info;
unsigned long rem;
/* check usage */
if (argc != 3)
{
fprintf(stderr, "usage: resfind <filename> <resname>\n");
exit(2);
}
/* get the arguments */
fname = argv[1];
resname = argv[2];
/* open the file */
if ((fp = osfoprb(fname, OSFTGAME)) == 0
&& (fp = osfoprb(fname, OSFTT3IMG)) == 0)
{
fprintf(stderr, "unable to open file \"%s\"\n", fname);
exit(2);
}
/* find the resource */
if (!tads_find_resource_fp(fp, resname, &res_info))
{
fprintf(stderr, "unable to find resource \"%s\"\n", resname);
osfcls(fp);
exit(1);
}
/* seek to the resource */
osfseek(fp, res_info.seek_pos, OSFSK_SET);
/* copy the resource to standard output */
for (rem = res_info.siz ; rem != 0 ; )
{
char buf[1024];
size_t cur;
/*
* read up to the buffer size or up to the resource size
* remaining, whichever is smaller
*/
cur = sizeof(buf);
if (cur > rem)
cur = (size_t)rem;
/* read the chunk */
if (osfrb(fp, buf, cur))
{
fprintf(stderr, "error reading %u bytes from file\n",
(unsigned)cur);
osfcls(fp);
exit(2);
}
/* copy the chunk to standard output */
fwrite(buf, cur, 1, stdout);
/* deduct the amount we just read from the size remaining */
rem -= cur;
}
/* done with the file - close it */
osfcls(fp);
/* success */
exit(0);
return 0;
}
int main(int argc, char **argv)
{
osfildef *fpin;
osfildef *fpout;
CVmFile *file_in;
CVmFile *file_out;
int status;
CVmHostIfc *hostifc;
CVmMainClientConsole clientifc;
int curarg;
/* initialize for testing */
test_init();
/* initialize the error stack */
err_init(1024);
/* start at the first argument */
curarg = 1;
/* check usage */
if (curarg + 2 > argc)
{
printf("usage: t3pre <original-image> <new-image> [program-args]\n"
"\n"
"Runs preinitialization on the image file, writing a new "
"image file\n"
"with the state of the program after preinitialization.\n");
return OSEXFAIL;
}
/* open the files */
if ((fpin = osfoprb(argv[curarg], OSFTT3IMG)) == 0)
{
printf("Error opening original image file \"%s\"\n", argv[1]);
return OSEXFAIL;
}
if ((fpout = osfopwb(argv[curarg + 1], OSFTT3IMG)) == 0)
{
printf("Error opening new image file \"%s\"\n", argv[2]);
return OSEXFAIL;
}
/* create the CVmFile objects */
file_in = new CVmFile();
file_in->set_file(fpin, 0);
file_out = new CVmFile();
file_out->set_file(fpout, 0);
/* create our host interface */
hostifc = new CVmHostIfcStdio(argv[0]);
/* run preinit and write the new image file */
err_try
{
/* load, run, and write */
vm_run_preinit(file_in, argv[1], file_out, hostifc, &clientifc,
argv + curarg + 1, argc - curarg - 1, 0);
/* note the success status */
status = OSEXSUCC;
}
err_catch(exc)
{
const char *msg;
char buf[128];
/* look up the message */
msg = err_get_msg(vm_messages, vm_message_count,
exc->get_error_code(), FALSE);
/* if that failed, just show the error number */
if (msg == 0)
{
sprintf(buf, "[no message: code %d]", exc->get_error_code());
msg = buf;
}
/* show the message */
printf("VM Error: %s\n", msg);
/* note the failure status */
status = OSEXFAIL;
}
err_end;
/* delete the file objects, which will close the files */
delete file_in;
delete file_out;
/* terminate the error mechanism */
err_terminate();
/* delete our host interface object */
delete hostifc;
/* log any memory leaks */
t3_list_memory_blocks(0);
/* exit with appropriate results */
return status;
}
int main(int argc, char **argv)
{
CResLoader *res_loader;
CTcHostIfc *hostifc;
int curarg;
int fatal_error_count = 0;
osfildef *fpout = 0;
CVmFile *objfile = 0;
CTPNStmProg *node;
const char *obj_fname;
int success;
char pathbuf[OSFNMAX];
/* initialize for testing */
test_init();
/* create the host interface object */
hostifc = new CTcHostIfcStdio();
/* create a resource loader */
os_get_special_path(pathbuf, sizeof(pathbuf), argv[0], OS_GSP_T3_RES);
res_loader = new CResLoader(pathbuf);
/* initialize the compiler */
CTcMain::init(hostifc, res_loader, 0);
/* keep all fixups when writing an object file */
G_keep_objfixups = TRUE;
G_keep_propfixups = TRUE;
G_keep_enumfixups = TRUE;
err_try
{
/* scan -I arguments */
for (curarg = 1 ; curarg < argc ; ++curarg)
{
char *p;
/* get the argument string for easy reference */
p = argv[curarg];
/* if it's not an option, we're done */
if (*p != '-')
break;
/* if it's a -I argument, use it */
if (*(p + 1) == 'I')
{
char *path;
/*
* if it's with this argument, read it, otherwise move
* on to the next argument
*/
if (*(p + 2) == '\0')
path = argv[++curarg];
else
path = p + 2;
/* add the directory to the include path list */
G_tok->add_inc_path(path);
}
else if (*(p + 1) == 'v')
{
/* set verbose mode */
G_tcmain->set_verbosity(TRUE);
}
else if (*(p + 1) == 's')
{
char *fname;
osfildef *symfp;
CVmFile *symfile;
/* load a symbol file */
if (*(p + 2) == '\0')
fname = argv[++curarg];
else
fname = p + 2;
/* open the file */
symfp = osfoprb(fname, OSFTT3SYM);
if (symfp == 0)
{
fprintf(stderr, "unable to open symbol file %s\n", fname);
continue;
}
/* load the symbol file */
symfile = new CVmFile();
symfile->set_file(symfp, 0);
G_prs->read_symbol_file(symfile);
/* done with the symbol file */
delete symfile;
}
else
{
/*
* invalid usage - consume all the arguments and fall
* through to the usage checker
*/
curarg = argc;
break;
}
}
/* check arguments */
if (curarg + 2 != argc)
{
/* terminate the compiler */
CTcMain::terminate();
/* delete our objects */
delete res_loader;
/* exit with an error */
errexit("usage: test_comp_obj [options] <source-file> "
"<object-file>\n"
"options:\n"
" -sfile - load symbols from file\n"
" -Idir - add dir to include path\n"
" -v - verbose error messages");
}
/* set up the tokenizer with the main input file */
if (G_tok->set_source(argv[curarg], argv[curarg]))
errexit("unable to open source file");
/* set up an output file */
obj_fname = argv[curarg+1];
fpout = osfopwb(obj_fname, OSFTT3OBJ);
if (fpout == 0)
errexit("unable to open object file");
objfile = new CVmFile();
objfile->set_file(fpout, 0);
/* read the first token */
G_tok->next();
/* parse at the top level */
node = G_prs->parse_top();
/* if errors occurred during parsing, stop here */
if (G_tcmain->get_error_count() != 0 || node == 0)
goto done;
/* fold symbolic constants for all nodes */
node->fold_constants(G_prs->get_global_symtab());
/* if errors occurred during constant folding, stop now */
if (G_tcmain->get_error_count() != 0)
goto done;
/* generate code and write the object file */
node->build_object_file(objfile, 0);
done: ;
}
err_catch(exc)
{
/*
* if it's not a general internal or fatal error, log it; don't
* log general errors, since these will have been logged as
* specific internal errors before being thrown
*/
if (exc->get_error_code() != TCERR_INTERNAL_ERROR
&& exc->get_error_code() != TCERR_FATAL_ERROR)
G_tok->log_error(TC_SEV_FATAL, exc->get_error_code());
/* count the fatal error */
++fatal_error_count;
}
err_end;
/* report errors */
fprintf(stderr,
"Warnings: %d\n"
"Errors: %d\n"
"Longest string: %d, longest list: %d\n",
G_tcmain->get_warning_count(),
G_tcmain->get_error_count() + fatal_error_count,
G_cg->get_max_str_len(), G_cg->get_max_list_cnt());
/*
* note whether or not the compilation was successful - it succeeded
* if we had no errors or fatal errors
*/
success = (G_tcmain->get_error_count() + fatal_error_count == 0);
/* delete the object file object (this closes the file) */
delete objfile;
/*
* if any errors occurred, delete the object file in the external
* file system - this prevents us from leaving around an incomplete
* or corrupted image file when compilation fails, and helps
* 'make'-type tools realize that they must generate the image file
* target again on the next build, even if source files didn't
* change
*/
if (!success)
osfdel(obj_fname);
/* shut down the compiler */
CTcMain::terminate();
/* done with the res loader */
delete res_loader;
/* delete the host interface */
delete hostifc;
/* show any unfreed memory */
t3_list_memory_blocks(0);
/*
* terminate - exit with a success indication if we had no errors
* (other than warnings); exit with an error indication otherwise
*/
return (success ? OSEXSUCC : OSEXFAIL);
}
int main(int argc, char **argv)
{
CResLoader *res_loader;
CTcHostIfc *hostifc;
int curarg;
int fatal_error_count = 0;
osfildef *fpout = 0;
int next_local = 0;
CVmFile *imgfile = 0;
CVmFile *objfile = 0;
const char *imgfname;
int success;
char pathbuf[OSFNMAX];
static const char tool_data[4] = { 't', 's', 't', 'L' };
/* initialize for testing */
test_init();
/* create the host interface object */
hostifc = new CTcHostIfcStdio();
/* create a resource loader */
os_get_special_path(pathbuf, sizeof(pathbuf), argv[0], OS_GSP_T3_RES);
res_loader = new CResLoader(pathbuf);
/* initialize the compiler */
CTcMain::init(hostifc, res_loader, 0);
err_try
{
/* scan arguments */
for (curarg = 1 ; curarg < argc ; ++curarg)
{
char *p;
/* get the argument string for easy reference */
p = argv[curarg];
/* if it's not an option, we're done */
if (*p != '-')
break;
if (*(p + 1) == 'v')
{
/* set verbose mode */
G_tcmain->set_verbosity(TRUE);
}
else
{
/*
* invalid usage - consume all the arguments and fall
* through to the usage checker
*/
curarg = argc;
break;
}
}
/* check arguments */
if (curarg + 2 > argc)
{
/* terminate the compiler */
CTcMain::terminate();
/* delete our objects */
delete res_loader;
/* exit with an error */
errexit("usage: test_link [options] obj-file [obj-file [...]] "
"image-file\n"
"options:\n"
" -v - verbose error messages");
}
/* set up an output file */
imgfname = argv[argc - 1];
fpout = osfopwb(imgfname, OSFTT3IMG);
if (fpout == 0)
errexit("unable to open image file");
imgfile = new CVmFile();
imgfile->set_file(fpout, 0);
/* read the object files */
for ( ; curarg < argc - 1 ; ++curarg)
{
osfildef *fpobj;
/* open this object file */
fpobj = osfoprb(argv[curarg], OSFTT3OBJ);
if (fpobj == 0)
{
printf("unable to open object file \"%s\"\n", argv[curarg]);
goto done;
}
/* note the loading */
printf("loading %s\n", argv[curarg]);
/* set up the CVmFile object for it */
objfile = new CVmFile();
objfile->set_file(fpobj, 0);
/* read the object file */
G_cg->load_object_file(objfile, argv[curarg]);
/* done with the object file */
delete objfile;
objfile = 0;
}
/* check for unresolved externals */
if (G_prs->check_unresolved_externs())
goto done;
/* write the image file */
G_cg->write_to_image(imgfile, 0, tool_data);
done:
;
}
err_catch(exc)
{
/*
* if it's not a general internal or fatal error, log it; don't
* log general errors, since these will have been logged as
* specific internal errors before being thrown
*/
if (exc->get_error_code() != TCERR_INTERNAL_ERROR
&& exc->get_error_code() != TCERR_FATAL_ERROR)
G_tok->log_error(TC_SEV_FATAL, exc->get_error_code());
/* count the fatal error */
++fatal_error_count;
}
err_end;
/* report errors */
fprintf(stderr,
"Warnings: %d\n"
"Errors: %d\n"
"Longest string: %d, longest list: %d\n",
G_tcmain->get_warning_count(),
G_tcmain->get_error_count() + fatal_error_count,
G_cg->get_max_str_len(), G_cg->get_max_list_cnt());
/*
* note whether or not the compilation was successful - it succeeded
* if we had no errors or fatal errors
*/
success = (G_tcmain->get_error_count() + fatal_error_count == 0);
/* delete the object file object (this closes the file) */
delete imgfile;
/* if we have an open object file, close it */
if (objfile != 0)
delete objfile;
/*
* if any errors occurred, delete the object file in the external
* file system - this prevents us from leaving around an incomplete
* or corrupted image file when compilation fails, and helps
* 'make'-type tools realize that they must generate the image file
* target again on the next build, even if source files didn't
* change
*/
if (!success)
osfdel(imgfname);
/* shut down the compiler */
CTcMain::terminate();
/* done with the res loader */
delete res_loader;
/* delete the host interface */
delete hostifc;
/* show any unfreed memory */
t3_list_memory_blocks(0);
/*
* terminate - exit with a success indication if we had no errors
* (other than warnings); exit with an error indication otherwise
*/
return (success ? OSEXSUCC : OSEXFAIL);
}
int main(int argc, char **argv)
{
int curarg;
osfildef *fpin;
osfildef *fpout;
char tmpfile[OSFNMAX + 1];
char inbuf[OSFNMAX + 1];
char *p;
char *infile;
char buf[128];
opdef *oplist = (opdef *)0;
opctxdef opctx;
int do_create = FALSE;
/* print main banner */
rscptf("TADS Resource Manager version 2.2.4\n");
rscptf("Copyright (c) 1992, 1999 by Michael J. Roberts. ");
rscptf("All Rights Reserved.\n");
if (argc < 2) usage();
/* set default parsing options */
opctx.restype = RESTYPE_DFLT;
opctx.flag = OPFADD | OPFDEL;
opctx.doing_type = FALSE;
/* scan file options (these come before the filename) */
for (curarg = 1 ; curarg < argc ; ++curarg)
{
/* check if it's an option - if not, stop looking */
if (argv[curarg][0] != '-')
break;
/* check the option */
if (!stricmp(argv[curarg], "-create"))
{
/* note that we want to create the file */
do_create = TRUE;
}
else
{
rscptf("unrecognized file option \"%s\"", argv[curarg]);
errexit("", 1);
}
}
/* get the file name */
infile = argv[curarg++];
strcpy(inbuf, infile);
os_defext(inbuf, "gam");
/* open the file for reading, unless we're creating a new file */
if (do_create)
{
/* creating - we have no input file */
fpin = 0;
}
else if ((fpin = osfoprb(inbuf, OSFTGAME)) == 0)
{
/*
* not creating, so the file must already exist - it doesn't, so
* issue an error and quit
*/
errexit("unable to open resource file", 1);
}
/*
* if no operations are desired, and we're not creating a new file,
* just list the existing file's contents and quit
*/
if (curarg == argc && fpin != 0)
{
rscproc(fpin, (osfildef *)0, 0);
osfcls(fpin);
os_term(OSEXSUCC);
}
/*
* Create an output file. If we're creating a new file, create the
* file named on the command line; otherwise, create a temporary
* file that we'll write to while working and then rename to the
* original input filename after we've finished with the original
* input file.
*/
if (do_create)
{
/* create the new file */
if ((fpout = osfopwb(inbuf, OSFTGAME)) == 0)
errexit("unable to create file", 1);
/* report the creation */
rscptf("\nFile created.\n");
}
else
{
/* generate a temporary filename */
strcpy(tmpfile, inbuf);
for (p = tmpfile + strlen(tmpfile) ; p > tmpfile &&
*(p-1) != ':' && *(p-1) != '\\' && *(p-1) != '/' ; --p);
strcpy(p, "$TADSRSC.TMP");
/* open the temporary file */
if ((fpout = osfopwb(tmpfile, OSFTGAME)) == 0)
errexit("unable to create temporary file", 1);
}
/* see if we need to read a response file */
if (curarg < argc && argv[curarg][0] == '@')
{
osfildef *argfp;
int l;
char *p;
if (!(argfp = osfoprt(argv[curarg]+1, OSFTTEXT)))
errexit("unable to open response file", 1);
for (;;)
{
if (!osfgets(buf, sizeof(buf), argfp)) break;
l = strlen(buf);
if (l && buf[l-1] == '\n') buf[--l] = '\0';
for (p = buf ; t_isspace(*p) ; ++p);
if (!*p) continue;
oplist = addop(oplist, p, &opctx);
}
osfcls(argfp);
}
else
{
for ( ; curarg < argc ; ++curarg)
oplist = addop(oplist, argv[curarg], &opctx);
}
/* process the resources */
oplist = rscproc(fpin, fpout, oplist);
/* make sure they all got processed */
for ( ; oplist != 0 ; oplist = oplist->opnxt)
{
if (!(oplist->opflag & OPFDONE))
rscptf("warning: resource \"%s\" not found\n", oplist->opres);
}
/* close files */
if (fpin != 0)
osfcls(fpin);
if (fpout != 0)
osfcls(fpout);
/*
* if we didn't create a new file, remove the original input file
* and rename the temp file to the original file name
*/
if (!do_create)
{
/* remove the original input file */
if (remove(inbuf))
errexit("error deleting input file", 1);
/* rename the temp file to the output file */
if (rename(tmpfile, inbuf))
errexit("error renaming temporary file", 1);
}
/* success */
os_term(OSEXSUCC);
return OSEXSUCC;
}
