+++ /dev/null
-/* \r
- * tads.c - Treaty of Babel common functions for tads2 and tads3 modules\r
- * \r
- * This file depends on treaty_builder.h\r
- * \r
- * This file is public domain, but note that any changes to this file may\r
- * render it noncompliant with the Treaty of Babel\r
- * \r
- * Modified\r
- *. 04/08/2006 LRRaszewski - changed babel API calls to threadsafe versions\r
- *. 04/08/2006 MJRoberts - initial implementation\r
- */\r
-\r
-\r
-#include "treaty.h"\r
-#include <ctype.h>\r
-#include <stdio.h>\r
-#include <string.h>\r
-#include <stdlib.h>\r
-#include "tads.h"\r
-#include "md5.h"\r
-\r
-#define ASSERT_OUTPUT_SIZE(x) \\r
- do { if (output_extent < (x)) return INVALID_USAGE_RV; } while (0)\r
-\r
-#define T2_SIGNATURE "TADS2 bin\012\015\032"\r
-#define T3_SIGNATURE "T3-image\015\012\032"\r
-\r
-#ifndef FALSE\r
-#define FALSE 0\r
-#endif\r
-#ifndef TRUE\r
-#define TRUE 1\r
-#endif\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * private structures \r
- */\r
-\r
-/*\r
- * resource information structure - this encapsulates the location and size\r
- * of a binary resource object embedded in a story file \r
- */\r
-typedef struct resinfo resinfo;\r
-struct resinfo\r
-{\r
- /* pointer and length of the data in the story file buffer */\r
- const char *ptr;\r
- int32 len;\r
-\r
- /* tads major version (currently, 2 or 3) */\r
- int tads_version;\r
-};\r
-\r
-/*\r
- * Name/value pair list entry \r
- */\r
-typedef struct valinfo valinfo;\r
-struct valinfo\r
-{\r
- const char *name;\r
- size_t name_len;\r
-\r
- /* value string */\r
- char *val;\r
- size_t val_len;\r
-\r
- /* next entry in the list */\r
- valinfo *nxt;\r
-};\r
-\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * forward declarations \r
- */\r
-static valinfo *parse_game_info(const void *story_file, int32 story_len,\r
- int *version);\r
-static int find_resource(const void *story_file, int32 story_len,\r
- const char *resname, resinfo *info);\r
-static int find_cover_art(const void *story_file, int32 story_len,\r
- resinfo *resp, int32 *image_format,\r
- int32 *width, int32 *height);\r
-static int t2_find_res(const void *story_file, int32 story_len,\r
- const char *resname, resinfo *info);\r
-static int t3_find_res(const void *story_file, int32 story_len,\r
- const char *resname, resinfo *info);\r
-static valinfo *find_by_key(valinfo *list_head, const char *key);\r
-static void delete_valinfo_list(valinfo *head);\r
-static int32 generate_md5_ifid(void *story_file, int32 extent,\r
- char *output, int32 output_extent);\r
-static int32 synth_ifiction(valinfo *vals, int tads_version,\r
- char *buf, int32 bufsize,\r
- void *story_file, int32 extent);\r
-static int get_png_dim(const void *img, int32 extent,\r
- int32 *xout, int32 *yout);\r
-static int get_jpeg_dim(const void *img, int32 extent,\r
- int32 *xout, int32 *yout);\r
-\r
-\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * Get the IFID for a given story file. \r
- */\r
-int32 tads_get_story_file_IFID(void *story_file, int32 extent,\r
- char *output, int32 output_extent)\r
-{\r
- valinfo *vals;\r
- \r
- /* if we have GameInfo, try looking for an IFID there */\r
- if ((vals = parse_game_info(story_file, extent, 0)) != 0)\r
- {\r
- valinfo *val;\r
- int found = 0;\r
- \r
- /* find the "IFID" key */\r
- if ((val = find_by_key(vals, "IFID")) != 0)\r
- {\r
- char *p;\r
- \r
- /* copy the output as a null-terminated string */\r
- ASSERT_OUTPUT_SIZE((int32)val->val_len + 1);\r
- memcpy(output, val->val, val->val_len);\r
- output[val->val_len] = '\0';\r
-\r
- /* \r
- * count up the IFIDs in the buffer - there might be more than\r
- * one, separated by commas \r
- */\r
- for (found = 1, p = output ; *p != '\0' ; ++p)\r
- {\r
- /* if this is a comma, it delimits a new IFID */\r
- if (*p == ',')\r
- ++found;\r
- }\r
- }\r
-\r
- /* delete the GameInfo list */\r
- delete_valinfo_list(vals);\r
-\r
- /* if we found an IFID, indicate how many results we found */\r
- if (found != 0)\r
- return found;\r
- }\r
-\r
- /* \r
- * we didn't find an IFID in the GameInfo, so generate a default IFID\r
- * using the MD5 method \r
- */\r
- return generate_md5_ifid(story_file, extent, output, output_extent);\r
-}\r
-\r
-/*\r
- * Get the size of the ifiction metadata for the game \r
- */\r
-int32 tads_get_story_file_metadata_extent(void *story_file, int32 extent)\r
-{\r
- valinfo *vals;\r
- int32 ret;\r
- int ver;\r
- \r
- /*\r
- * First, make sure we have a GameInfo record. If we don't, simply\r
- * indicate that there's no metadata to fetch. \r
- */\r
- if ((vals = parse_game_info(story_file, extent, &ver)) == 0)\r
- return NO_REPLY_RV;\r
-\r
- /*\r
- * Run the ifiction synthesizer with no output buffer, to calculate the\r
- * size we need. \r
- */\r
- ret = synth_ifiction(vals, ver, 0, 0, story_file, extent);\r
-\r
- /* delete the value list */\r
- delete_valinfo_list(vals);\r
-\r
- /* return the required size */\r
- return ret;\r
-}\r
-\r
-/*\r
- * Get the ifiction metadata for the game\r
- */\r
-int32 tads_get_story_file_metadata(void *story_file, int32 extent,\r
- char *buf, int32 bufsize)\r
-{\r
- valinfo *vals;\r
- int32 ret;\r
- int ver;\r
-\r
- /* make sure we have metadata to fetch */\r
- if ((vals = parse_game_info(story_file, extent, &ver)) == 0)\r
- return NO_REPLY_RV;\r
-\r
- /* synthesize the ifiction data into the output buffer */\r
- ret = synth_ifiction(vals, ver, buf, bufsize, story_file, extent);\r
-\r
- /* if that required more space than we had available, return an error */\r
- if (ret > bufsize)\r
- ret = INVALID_USAGE_RV;\r
-\r
- /* delete the value list */\r
- delete_valinfo_list(vals);\r
-\r
- /* return the result */\r
- return ret;\r
-}\r
-\r
-/*\r
- * Get the size of the cover art \r
- */\r
-int32 tads_get_story_file_cover_extent(void *story_file, int32 story_len)\r
-{\r
- resinfo res;\r
- \r
- /* look for the cover art resource */\r
- if (find_cover_art(story_file, story_len, &res, 0, 0, 0))\r
- return res.len;\r
- else\r
- return NO_REPLY_RV;\r
-}\r
-\r
-/*\r
- * Get the format of the cover art \r
- */\r
-int32 tads_get_story_file_cover_format(void *story_file, int32 story_len)\r
-{\r
- int32 typ;\r
-\r
- /* look for CoverArt.jpg */\r
- if (find_cover_art(story_file, story_len, 0, &typ, 0, 0))\r
- return typ;\r
- else\r
- return NO_REPLY_RV;\r
-}\r
-\r
-/*\r
- * Get the cover art data \r
- */\r
-int32 tads_get_story_file_cover(void *story_file, int32 story_len,\r
- void *outbuf, int32 output_extent)\r
-{\r
- resinfo res;\r
-\r
- /* look for CoverArt.jpg, then for CoverArt.png */\r
- if (find_cover_art(story_file, story_len, &res, 0, 0, 0))\r
- {\r
- /* got it - copy the data to the buffer */\r
- ASSERT_OUTPUT_SIZE(res.len);\r
- memcpy(outbuf, res.ptr, res.len);\r
-\r
- /* success */\r
- return res.len;\r
- }\r
-\r
- /* otherwise, we didn't find it */\r
- return NO_REPLY_RV;\r
-}\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * Generate a default IFID using the MD5 hash method \r
- */\r
-static int32 generate_md5_ifid(void *story_file, int32 extent,\r
- char *output, int32 output_extent)\r
-{\r
- md5_state_t md5;\r
- unsigned char md5_buf[16];\r
- char *p;\r
- int i;\r
-\r
- /* calculate the MD5 hash of the story file */\r
- md5_init(&md5);\r
- md5_append(&md5, story_file, extent);\r
- md5_finish(&md5, md5_buf);\r
-\r
- /* make sure we have room to store the result */\r
- ASSERT_OUTPUT_SIZE(39);\r
-\r
- /* the prefix is "TADS2-" or "TADS3-", depending on the format */\r
- if (tads_match_sig(story_file, extent, T2_SIGNATURE))\r
- strcpy(output, "TADS2-");\r
- else\r
- strcpy(output, "TADS3-");\r
-\r
- /* the rest is the MD5 hash of the file, as hex digits */\r
- for (i = 0, p = output + strlen(output) ; i < 16 ; p += 2, ++i)\r
- sprintf(p, "%02X", md5_buf[i]);\r
-\r
- /* indicate that we found one result */\r
- return 1;\r
-}\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * Some UTF-8 utility functions and macros. We use our own rather than the\r
- * ctype.h macros because we're parsing UTF-8 text. \r
- */\r
-\r
-/* is c a space? */\r
-#define u_isspace(c) ((unsigned char)(c) < 128 && isspace(c))\r
-\r
-/* is c a horizontal space? */\r
-#define u_ishspace(c) (u_isspace(c) && (c) != '\n' && (c) != '\r')\r
-\r
-/* is-newline - matches \n, \r, and \u2028 */\r
-static int u_isnl(const char *p, int32 len)\r
-{\r
- return (*p == '\n' \r
- || *p == '\r'\r
- || (len >= 3\r
- && *(unsigned char *)p == 0xe2\r
- && *(unsigned char *)(p+1) == 0x80\r
- && *(unsigned char *)(p+2) == 0xa8));\r
-}\r
-\r
-/* skip to the next utf-8 character */\r
-static void nextc(const char **p, int32 *len)\r
-{\r
- /* skip the first byte */\r
- if (*len != 0)\r
- ++*p, --*len;\r
-\r
- /* skip continuation bytes */\r
- while (*len != 0 && (**p & 0xC0) == 0x80)\r
- ++*p, --*len;\r
-}\r
-\r
-/* skip to the previous utf-8 character */\r
-static void prevc(const char **p, int32 *len)\r
-{\r
- /* move back one byte */\r
- --*p, ++*len;\r
-\r
- /* keep skipping as long as we're looking at continuation characters */\r
- while ((**p & 0xC0) == 0x80)\r
- --*p, ++*len;\r
-}\r
-\r
-/*\r
- * Skip a newline sequence. Skips all common conventions, including \n,\r
- * \r, \n\r, \r\n, and \u2028. \r
- */\r
-static void skip_newline(const char **p, int32 *rem)\r
-{\r
- /* make sure we have something to skip */\r
- if (*rem == 0)\r
- return;\r
-\r
- /* check what we have */\r
- switch (**(const unsigned char **)p)\r
- {\r
- case '\n':\r
- /* skip \n or \n\r */\r
- nextc(p, rem);\r
- if (**p == '\r')\r
- nextc(p, rem);\r
- break;\r
-\r
- case '\r':\r
- /* skip \r or \r\n */\r
- nextc(p, rem);\r
- if (**p == '\n')\r
- nextc(p, rem);\r
- break;\r
-\r
- case 0xe2:\r
- /* \u2028 (unicode line separator) - just skip the one character */\r
- nextc(p, rem);\r
- break;\r
- }\r
-}\r
-\r
-/*\r
- * Skip to the next line \r
- */\r
-static void skip_to_next_line(const char **p, int32 *rem)\r
-{\r
- /* look for the next newline */\r
- for ( ; *rem != 0 ; nextc(p, rem))\r
- {\r
- /* if this is a newline of some kind, we're at the end of the line */\r
- if (u_isnl(*p, *rem))\r
- {\r
- /* skip the newline, and we're done */\r
- skip_newline(p, rem);\r
- break;\r
- }\r
- }\r
-}\r
-\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * ifiction synthesizer output context \r
- */\r
-typedef struct synthctx synthctx;\r
-struct synthctx\r
-{\r
- /* the current output pointer */\r
- char *buf;\r
-\r
- /* the number of bytes remaining in the output buffer */\r
- int32 buf_size;\r
-\r
- /* \r
- * the total number of bytes needed for the output (this might be more\r
- * than we've actually written, since we count up the bytes required\r
- * even if we need more space than the buffer provides) \r
- */\r
- int32 total_size;\r
-\r
- /* the head of the name/value pair list from the parsed GameInfo */\r
- valinfo *vals;\r
-};\r
-\r
-/* initialize a synthesizer context */\r
-static void init_synthctx(synthctx *ctx, char *buf, int32 bufsize,\r
- valinfo *vals)\r
-{\r
- /* set up at the beginning of the output buffer */\r
- ctx->buf = buf;\r
- ctx->buf_size = bufsize;\r
-\r
- /* we haven't written anything to the output buffer yet */\r
- ctx->total_size = 0;\r
-\r
- /* remember the name/value pair list */\r
- ctx->vals = vals;\r
-}\r
-\r
-/* \r
- * Write out a chunk to a synthesized ifiction record, updating pointers\r
- * and counters. We won't copy past the end of the buffer, but we'll\r
- * continue counting the output length needed in any case. \r
- */\r
-static void write_ifiction(synthctx *ctx, const char *src, size_t srclen)\r
-{\r
- int32 copy_len;\r
-\r
- /* copy as much as we can, up to the remaining buffer size */\r
- copy_len = srclen;\r
- if (copy_len > ctx->buf_size)\r
- copy_len = ctx->buf_size;\r
-\r
- /* do the copying, if any */\r
- if (copy_len != 0)\r
- {\r
- /* copy the bytes */\r
- memcpy(ctx->buf, src, (size_t)copy_len);\r
-\r
- /* adjust the buffer pointer and output buffer size remaining */\r
- ctx->buf += copy_len;\r
- ctx->buf_size -= copy_len;\r
- }\r
-\r
- /* count this source data in the total size */\r
- ctx->total_size += srclen;\r
-}\r
-\r
-/* write a null-terminated chunk to the synthesized ifiction record */\r
-static void write_ifiction_z(synthctx *ctx, const char *src)\r
-{\r
- write_ifiction(ctx, src, strlen(src));\r
-}\r
-\r
-/*\r
- * Write a PCDATA string to the synthesized ifiction record. In\r
- * particular, we rewrite '<', '>', and '&' as '<', '>', and '&',\r
- * respectively; we trim off leading and trailing spaces; and we compress\r
- * each run of whitespace down to a single \u0020 (' ') character.\r
- */\r
-static void write_ifiction_pcdata(synthctx *ctx, const char *p, size_t len)\r
-{\r
- /* first, skip any leading whitespace */\r
- for ( ; len != 0 && u_ishspace(*p) ; ++p, --len) ;\r
-\r
- /* keep going until we run out of string */\r
- for (;;)\r
- {\r
- const char *start;\r
- \r
- /* scan to the next whitespace or markup-significant character */\r
- for (start = p ;\r
- len != 0 && !u_ishspace(*p)\r
- && *p != '<' && *p != '>' && *p != '&' ; ++p, --len) ;\r
-\r
- /* write the part up to here */\r
- if (p != start)\r
- write_ifiction(ctx, start, p - start);\r
-\r
- /* if we've reached the end of the string, we can stop */\r
- if (len == 0)\r
- break;\r
-\r
- /* check what stopped us */\r
- switch (*p)\r
- {\r
- case '<':\r
- write_ifiction_z(ctx, "<");\r
- ++p, --len;\r
- break;\r
-\r
- case '>':\r
- write_ifiction_z(ctx, ">");\r
- ++p, --len;\r
- break;\r
-\r
- case '&':\r
- write_ifiction_z(ctx, "&");\r
- ++p, --len;\r
- break;\r
-\r
- default:\r
- /* \r
- * The only other thing that could have stopped us is\r
- * whitespace. Skip all consecutive whitespace. \r
- */\r
- for ( ; len != 0 && u_ishspace(*p) ; ++p, --len);\r
-\r
- /* \r
- * if that's not the end of the string, replace the run of\r
- * whitespace with a single space character in the output; if\r
- * we've reached the end of the string, we don't even want to\r
- * do that, since we want to trim off trailing spaces \r
- */\r
- if (len != 0)\r
- write_ifiction_z(ctx, " ");\r
- break;\r
- }\r
- }\r
-}\r
-\r
-/*\r
- * Translate a GameInfo keyed value to the corresponding ifiction tagged\r
- * value. We find the GameInfo value keyed by 'gameinfo_key', and write\r
- * out the same string under the ifiction XML tag 'ifiction_tag'. We write\r
- * a complete XML container sequence - <tag>value</tag>.\r
- * \r
- * If the given GameInfo key doesn't exist, we use the default value string\r
- * 'dflt', if given. If the GameInfo key doesn't exist and 'dflt' is null,\r
- * we don't write anything - we don't even write the open/close tags.\r
- * \r
- * If 'html' is true, we assume the value is in html format, and we write\r
- * it untranslated. Otherwise, we write it as PCDATA, translating markup\r
- * characters into '&' entities and compressing whitespace. \r
- */\r
-static void write_ifiction_xlat_base(synthctx *ctx, int indent,\r
- const char *gameinfo_key,\r
- const char *ifiction_tag,\r
- const char *dflt, int html)\r
-{\r
- valinfo *val;\r
- const char *valstr;\r
- size_t vallen;\r
- \r
- /* look up the GameInfo key */\r
- if ((val = find_by_key(ctx->vals, gameinfo_key)) != 0)\r
- {\r
- /* we found the GameInfo value - use it */\r
- valstr = val->val;\r
- vallen = val->val_len;\r
- }\r
- else if (dflt != 0)\r
- {\r
- /* the GameInfo value doesn't exist, but we have a default - use it */\r
- valstr = dflt;\r
- vallen = strlen(dflt);\r
- }\r
- else\r
- {\r
- /* there's no GameInfo value and no default, so write nothing */\r
- return;\r
- }\r
-\r
- /* write the indentation */\r
- while (indent != 0)\r
- {\r
- static const char spaces[] = " ";\r
- size_t cur;\r
-\r
- /* figure how much we can write on this round */\r
- cur = indent;\r
- if (cur > sizeof(spaces) - 1)\r
- cur = sizeof(spaces) - 1;\r
-\r
- /* write it */\r
- write_ifiction(ctx, spaces, cur);\r
-\r
- /* deduct it from the amount remaining */\r
- indent -= cur;\r
- }\r
-\r
- /* write the open tag */\r
- write_ifiction_z(ctx, "<");\r
- write_ifiction_z(ctx, ifiction_tag);\r
- write_ifiction_z(ctx, ">");\r
-\r
- /* write the value, applying pcdata translations */\r
- if (html)\r
- write_ifiction(ctx, valstr, vallen);\r
- else\r
- write_ifiction_pcdata(ctx, valstr, vallen);\r
-\r
- /* write the close tag */\r
- write_ifiction_z(ctx, "</");\r
- write_ifiction_z(ctx, ifiction_tag);\r
- write_ifiction_z(ctx, ">\n");\r
-}\r
-\r
-#define write_ifiction_xlat(ctx, indent, gikey, iftag, dflt) \\r
- write_ifiction_xlat_base(ctx, indent, gikey, iftag, dflt, FALSE)\r
-\r
-#define write_ifiction_xlat_html(ctx, indent, gikey, iftag, dflt) \\r
- write_ifiction_xlat_base(ctx, indent, gikey, iftag, dflt, TRUE)\r
-\r
-\r
-/*\r
- * Retrieve the next author name from the GameInfo "Author" format. The\r
- * format is as follows:\r
- * \r
- * name <email> <email>... ; ...\r
- * \r
- * That is, each author is listed with a name followed by one or more email\r
- * addresses in angle brackets, and multiple authors are separated by\r
- * semicolons. \r
- */\r
-static int scan_author_name(const char **p, size_t *len,\r
- const char **start, const char **end)\r
-{\r
- /* keep going until we find a non-empty author name */\r
- for (;;)\r
- {\r
- /* skip leading spaces */\r
- for ( ; *len != 0 && u_ishspace(**p) ; ++*p, --*len) ;\r
-\r
- /* if we ran out of string, there's definitely no author name */\r
- if (*len == 0)\r
- return FALSE;\r
-\r
- /* \r
- * Find the end of this author name. The author name ends at the\r
- * next semicolon or angle bracket. \r
- */\r
- for (*start = *p ; *len != 0 && **p != ';' && **p != '<' ;\r
- ++*p, --*len) ;\r
-\r
- /* trim off any trailing spaces */\r
- for (*end = *p ; *end > *start && u_ishspace(*(*end - 1)) ; --*end) ;\r
-\r
- /* now skip any email addresses */\r
- while (*len != 0 && **p == '<')\r
- {\r
- /* skip to the closing bracket */\r
- for (++*p, --*len ; *len != 0 && **p != '>' ; ++*p, --*len) ;\r
-\r
- /* skip the bracket */\r
- if (*len != 0)\r
- ++*p, --*len;\r
-\r
- /* skip whitespace */\r
- for ( ; *len != 0 && u_ishspace(**p) ; ++*p, --*len) ;\r
-\r
- /* \r
- * if we're not at a semicolon, another angle bracket, or the\r
- * end of the string, it's a syntax error \r
- */\r
- if (*len != 0 && **p != '<' && **p != ';')\r
- {\r
- *len = 0;\r
- return FALSE;\r
- }\r
- }\r
-\r
- /* if we're at a semicolon, skip it */\r
- if (*len != 0 && **p == ';')\r
- ++*p, --*len;\r
-\r
- /* \r
- * if we found a non-empty name, return it; otherwise, continue on\r
- * to the next semicolon section \r
- */\r
- if (*end != *start)\r
- return TRUE;\r
- }\r
-}\r
-\r
-\r
-/*\r
- * Synthesize an ifiction record for the given GameInfo name/value pair\r
- * list. Returns the number of bytes required for the result, including\r
- * null termination. We'll copy as much as we can to the output buffer, up\r
- * to bufsize; if the buffer size is insufficient to hold the result, we'll\r
- * still indicate the length needed for the full result, but we're careful\r
- * not to actually copy anything past the end of the buffer. \r
- */\r
-static int32 synth_ifiction(valinfo *vals, int tads_version,\r
- char *buf, int32 bufsize,\r
- void *story_file, int32 extent)\r
-{\r
- char default_ifid[TREATY_MINIMUM_EXTENT];\r
- valinfo *ifid = find_by_key(vals, "IFID");\r
- const char *ifid_val;\r
- size_t ifid_len;\r
- valinfo *author = find_by_key(vals, "AuthorEmail");\r
- valinfo *url = find_by_key(vals, "Url");\r
- synthctx ctx;\r
- const char *p;\r
- size_t rem;\r
- int32 art_fmt;\r
- int32 art_wid, art_ht;\r
-\r
- /* initialize the output content */\r
- init_synthctx(&ctx, buf, bufsize, vals);\r
-\r
- /* make sure the tads version is one we know how to handle */\r
- if (tads_version != 2 && tads_version != 3)\r
- return NO_REPLY_RV;\r
-\r
- /* \r
- * The IFID is mandatory. If there's not an IFID specifically listed\r
- * in the GameInfo, we need to generate the default IFID based on the\r
- * MD5 hash of the game file. \r
- */\r
- if (ifid != 0)\r
- {\r
- /* use the explicit IFID(s) listed in the GameInfo */\r
- ifid_val = ifid->val;\r
- ifid_len = ifid->val_len;\r
- }\r
- else\r
- {\r
- /* generate the default IFID */\r
- generate_md5_ifid(story_file, extent,\r
- default_ifid, TREATY_MINIMUM_EXTENT);\r
-\r
- /* use this as the IFID */\r
- ifid_val = default_ifid;\r
- ifid_len = strlen(default_ifid);\r
- }\r
-\r
- /* write the header, and start the <identification> section */\r
- write_ifiction_z(\r
- &ctx,\r
- "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"\r
- "<ifindex version=\"1.0\" "\r
- "xmlns=\"http://babel.ifarchive.org/protocol/iFiction/\">\n"\r
- " <!-- Bibliographic data translated from TADS GameInfo -->\n"\r
- " <story>\n"\r
- " <colophon>\n"\r
- " <generator>Babel</generator>\n"\r
- " <generatorversion>" TREATY_VERSION "</generatorversion>\n"\r
- " <originated>2006-04-14</originated>\n"\r
- " </colophon>\n"\r
- " <identification>\n");\r
-\r
- /* write each IFID (there might be several) */\r
- for (p = ifid_val, rem = ifid_len ; rem != 0 ; )\r
- {\r
- const char *start;\r
- const char *end;\r
-\r
- /* skip leading spaces */\r
- for ( ; rem != 0 && u_ishspace(*p) ; ++p, --rem) ;\r
- \r
- /* find the end of this IFID */\r
- for (start = p ; rem != 0 && *p != ',' ; ++p, --rem) ;\r
-\r
- /* remove trailing spaces */\r
- for (end = p ; end > start && u_ishspace(*(end-1)) ; --end) ;\r
-\r
- /* if we found one, write it out */\r
- if (end != start)\r
- {\r
- write_ifiction_z(&ctx, " <ifid>");\r
- write_ifiction(&ctx, start, end - start);\r
- write_ifiction_z(&ctx, "</ifid>\n");\r
- }\r
-\r
- /* skip the comma */\r
- if (rem != 0 && *p == ',')\r
- ++p, --rem;\r
- }\r
-\r
- /* add the format information */\r
- write_ifiction_z(&ctx,\r
- tads_version == 2\r
- ? " <format>tads2</format>\n"\r
- : " <format>tads3</format>\n");\r
-\r
- /* close the <identification> section and start the <bibliographic> */\r
- write_ifiction_z(&ctx,\r
- " </identification>\n"\r
- " <bibliographic>\n");\r
-\r
- /* write the various bibliographic data */\r
- write_ifiction_xlat(&ctx, 6, "Name", "title", "An Interactive Fiction");\r
- write_ifiction_xlat(&ctx, 6, "Headline", "headline", 0);\r
- write_ifiction_xlat(&ctx, 6, "Desc", "description", 0);\r
- write_ifiction_xlat(&ctx, 6, "Genre", "genre", 0);\r
- write_ifiction_xlat(&ctx, 6, "Forgiveness", "forgiveness", 0);\r
- write_ifiction_xlat(&ctx, 6, "Series", "series", 0);\r
- write_ifiction_xlat(&ctx, 6, "SeriesNumber", "seriesnumber", 0);\r
- write_ifiction_xlat(&ctx, 6, "Language", "language", 0);\r
- write_ifiction_xlat(&ctx, 6, "FirstPublished", "firstpublished", 0);\r
-\r
- /* if there's an author, write the list of author names */\r
- if (author != 0)\r
- {\r
- int cnt;\r
- int i;\r
- const char *start;\r
- const char *end;\r
-\r
- /* start the <author> tag */\r
- write_ifiction_z(&ctx, " <author>");\r
- \r
- /* \r
- * first, count up the number of authors - authors are separated by\r
- * semicolons, so there's one more author than there are semicolons\r
- */\r
- for (p = author->val, rem = author->val_len, cnt = 1 ;\r
- scan_author_name(&p, &rem, &start, &end) ; ) ;\r
-\r
- /* \r
- * Now generate the list of authors. If there are multiple\r
- * authors, use commas to separate them. \r
- */\r
- for (p = author->val, rem = author->val_len, i = 0 ; ; ++i)\r
- {\r
- /* scan this author's name */\r
- if (!scan_author_name(&p, &rem, &start, &end))\r
- break;\r
- \r
- /* write out this author name */\r
- write_ifiction_pcdata(&ctx, start, end - start);\r
-\r
- /* if there's another name to come, write a separator */\r
- if (i + 1 < cnt)\r
- {\r
- /* \r
- * write just "and" to separate two items; write ","\r
- * between items in lists of more than two, with ",and"\r
- * between the last two items \r
- */\r
- write_ifiction_z(&ctx,\r
- cnt == 2 ? " and " :\r
- i + 2 < cnt ? ", " : ", and ");\r
- }\r
- }\r
-\r
- /* end the <author> tag */\r
- write_ifiction_z(&ctx, "</author>\n");\r
- }\r
-\r
- /* end the biblio section */\r
- write_ifiction_z(&ctx, " </bibliographic>\n");\r
-\r
- /* if there's cover art, add its information */\r
- if (find_cover_art(story_file, extent, 0, &art_fmt, &art_wid, &art_ht)\r
- && (art_fmt == PNG_COVER_FORMAT || art_fmt == JPEG_COVER_FORMAT))\r
- {\r
- char buf[200];\r
- \r
- sprintf(buf,\r
- " <cover>\n"\r
- " <format>%s</format>\n"\r
- " <height>%lu</height>\n"\r
- " <width>%lu</width>\n"\r
- " </cover>\n",\r
- art_fmt == PNG_COVER_FORMAT ? "png" : "jpg",\r
- (long)art_ht, (long)art_wid);\r
-\r
- write_ifiction_z(&ctx, buf);\r
- }\r
-\r
- /* if there's an author email, include it */\r
- if (author != 0 || url != 0)\r
- {\r
- const char *p;\r
- size_t rem;\r
- int i;\r
- \r
- /* open the section */\r
- write_ifiction_z(&ctx, " <contacts>\n");\r
-\r
- /* add the author email, if provided */\r
- if (author != 0)\r
- {\r
- /* write the email list */\r
- for (i = 0, p = author->val, rem = author->val_len ; ; ++i)\r
- {\r
- const char *start;\r
- \r
- /* skip to the next email address */\r
- for ( ; rem != 0 && *p != '<' ; ++p, --rem) ;\r
- \r
- /* if we didn't find an email address, we're done */\r
- if (rem == 0)\r
- break;\r
- \r
- /* find the matching '>' */\r
- for (++p, --rem, start = p ; rem != 0 && *p != '>' ;\r
- ++p, --rem) ;\r
-\r
- /* \r
- * if this is the first one, open the section; otherwise,\r
- * add a comma \r
- */\r
- if (i == 0)\r
- write_ifiction_z(&ctx, " <authoremail>");\r
- else\r
- write_ifiction_z(&ctx, ",");\r
- \r
- /* write this address */\r
- write_ifiction(&ctx, start, p - start);\r
- \r
- /* \r
- * skip the closing bracket, if there is one; if we're out\r
- * of string, we're done \r
- */\r
- if (rem != 0)\r
- ++p, --rem;\r
- else\r
- break;\r
- }\r
-\r
- /* if we found any emails to write, end the section */\r
- if (i != 0)\r
- write_ifiction_z(&ctx, "</authoremail>\n");\r
- }\r
-\r
- /* if there's a URL, add it */\r
- if (url != 0)\r
- {\r
- write_ifiction_z(&ctx, " <url>");\r
- write_ifiction(&ctx, url->val, url->val_len);\r
- write_ifiction_z(&ctx, "</url>\n");\r
- }\r
-\r
- /* close the section */\r
- write_ifiction_z(&ctx, " </contacts>\n");\r
- }\r
-\r
- /* add the tads-specific section */\r
- write_ifiction_z(&ctx, " <tads>\n");\r
- \r
- write_ifiction_xlat(&ctx, 6, "Version", "version", 0);\r
- write_ifiction_xlat(&ctx, 6, "ReleaseDate", "releasedate", 0);\r
- write_ifiction_xlat(&ctx, 6, "PresentationProfile",\r
- "presentationprofile", 0);\r
- write_ifiction_xlat(&ctx, 6, "Byline", "byline", 0);\r
-\r
- write_ifiction_z(&ctx, " </tads>\n");\r
-\r
- /* close the story section and the main body */\r
- write_ifiction_z(&ctx, " </story>\n</ifindex>\n");\r
- \r
- /* add the null terminator */\r
- write_ifiction(&ctx, "", 1);\r
-\r
- /* return the total output size */\r
- return ctx.total_size;\r
-}\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * Check a data block to see if it starts with the given signature. \r
- */\r
-int tads_match_sig(const void *buf, int32 len, const char *sig)\r
-{\r
- /* note the length of the signature string */\r
- size_t sig_len = strlen(sig);\r
- \r
- /* if matches if the buffer starts with the signature string */\r
- return (len >= (int32)sig_len && memcmp(buf, sig, sig_len) == 0);\r
-}\r
-\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * portable-to-native format conversions \r
- */\r
-#define osbyte(p, ofs) \\r
- (*(((unsigned char *)(p)) + (ofs)))\r
-\r
-#define osrp1(p) \\r
- ((unsigned int)osbyte(p, 0))\r
-\r
-#define osrp2(p) \\r
- ((unsigned int)osbyte(p, 0) \\r
- + ((unsigned int)osbyte(p, 1) << 8))\r
-\r
-#define osrp4(p) \\r
- (((unsigned long)osbyte(p, 0)) \\r
- + (((unsigned long)osbyte(p, 1)) << 8) \\r
- + (((unsigned long)osbyte(p, 2)) << 16) \\r
- + (((unsigned long)osbyte(p, 3)) << 24))\r
-\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * Parse a game file and retrieve the GameInfo data. Returns the head of a\r
- * linked list of valinfo entries.\r
- */\r
-static valinfo *parse_game_info(const void *story_file, int32 story_len,\r
- int *tads_version)\r
-{\r
- resinfo res;\r
- const char *p;\r
- int32 rem;\r
- valinfo *val_head = 0;\r
-\r
- /* \r
- * first, find the GameInfo resource - if it's not there, there's no\r
- * game information to parse \r
- */\r
- if (!find_resource(story_file, story_len, "GameInfo.txt", &res))\r
- return 0;\r
-\r
- /* if the caller wants the TADS version number, hand it back */\r
- if (tads_version != 0)\r
- *tads_version = res.tads_version;\r
-\r
- /* parse the data */\r
- for (p = res.ptr, rem = res.len ; rem != 0 ; )\r
- {\r
- const char *name_start;\r
- size_t name_len;\r
- const char *val_start;\r
- valinfo *val;\r
- const char *inp;\r
- int32 inlen;\r
- char *outp;\r
-\r
- /* skip any leading whitespace */\r
- while (rem != 0 && u_isspace(*p))\r
- ++p, --rem;\r
-\r
- /* if the line starts with '#', it's a comment, so skip it */\r
- if (rem != 0 && *p == '#')\r
- {\r
- skip_to_next_line(&p, &rem);\r
- continue;\r
- }\r
-\r
- /* we must have the start of a name - note it */\r
- name_start = p;\r
-\r
- /* skip ahead to a space or colon */\r
- while (rem != 0 && *p != ':' && !u_ishspace(*p))\r
- nextc(&p, &rem);\r
-\r
- /* note the length of the name */\r
- name_len = p - name_start;\r
-\r
- /* skip any whitespace before the presumed colon */\r
- while (rem != 0 && u_ishspace(*p))\r
- nextc(&p, &rem);\r
-\r
- /* if we're not at a colon, the line is ill-formed, so skip it */\r
- if (rem == 0 || *p != ':')\r
- {\r
- /* skip the entire line, and go back for the next one */\r
- skip_to_next_line(&p, &rem);\r
- continue;\r
- }\r
-\r
- /* skip the colon and any whitespace immediately after it */\r
- for (nextc(&p, &rem) ; rem != 0 && u_ishspace(*p) ; nextc(&p, &rem)) ;\r
-\r
- /* note where the value starts */\r
- val_start = p;\r
-\r
- /*\r
- * Scan the value to get its length. The value runs from here to\r
- * the next newline that's not followed immediately by a space. \r
- */\r
- while (rem != 0)\r
- {\r
- const char *nl;\r
- int32 nlrem;\r
- \r
- /* skip to the next line */\r
- skip_to_next_line(&p, &rem);\r
-\r
- /* if we're at eof, we can stop now */\r
- if (rem == 0)\r
- break;\r
-\r
- /* note where this line starts */\r
- nl = p;\r
- nlrem = rem;\r
-\r
- /* \r
- * if we're at a non-whitespace character, it's definitely not\r
- * a continuation line \r
- */\r
- if (!u_ishspace(*p))\r
- break;\r
-\r
- /* \r
- * check for spaces followed by a non-space character - this\r
- * would signify a continuation line\r
- */\r
- for ( ; rem != 0 && u_ishspace(*p) ; nextc(&p, &rem)) ;\r
- if (rem == 0 || u_isnl(p, rem))\r
- {\r
- /* \r
- * we're at end of file, we found a line with nothing but\r
- * whitespace, so this isn't a continuation line; go back\r
- * to the start of this line and end the value here \r
- */\r
- p = nl;\r
- rem = nlrem;\r
- break;\r
- }\r
-\r
- /* \r
- * We found whitespace followed by non-whitespace, so this is a\r
- * continuation line. Keep going for now.\r
- */\r
- }\r
-\r
- /* remove any trailing newlines */\r
- while (p > val_start)\r
- {\r
- /* move back one character */\r
- prevc(&p, &rem);\r
-\r
- /* \r
- * if it's a newline, keep going; otherwise, keep this\r
- * character and stop trimming \r
- */\r
- if (!u_isnl(p, rem))\r
- {\r
- nextc(&p, &rem);\r
- break;\r
- }\r
- }\r
-\r
- /* \r
- * Allocate a new value entry. Make room for the entry itself plus\r
- * a copy of the value. We don't need to make a copy of the name,\r
- * since we can just use the original copy from the story file\r
- * buffer. We do need a copy of the value because we might need to\r
- * transform it slightly, to remove newlines and leading spaces on\r
- * continuation lines. \r
- */\r
- val = (valinfo *)malloc(sizeof(valinfo) + (p - val_start));\r
-\r
- /* link it into our list */\r
- val->nxt = val_head;\r
- val_head = val;\r
-\r
- /* point the name directly to the name in the buffer */\r
- val->name = name_start;\r
- val->name_len = name_len;\r
-\r
- /* point the value to the space allocated along with the valinfo */\r
- val->val = (char *)(val + 1);\r
-\r
- /* store the name, removing newlines and continuation-line spaces */\r
- for (outp = val->val, inp = val_start, inlen = p - val_start ;\r
- inlen != 0 ; )\r
- {\r
- const char *l;\r
- \r
- /* find the next newline */\r
- for (l = inp ; inlen != 0 && !u_isnl(inp, inlen) ;\r
- nextc(&inp, &inlen)) ;\r
-\r
- /* copy this line to the output */\r
- memcpy(outp, l, inp - l);\r
- outp += inp - l;\r
-\r
- /* if we're out of input, we're done */\r
- if (inlen == 0)\r
- break;\r
-\r
- /* we're at a newline: replace it with a space in the output */\r
- *outp++ = ' ';\r
-\r
- /* skip the newline and subsequent whitespace in the input */\r
- for (skip_newline(&inp, &inlen) ;\r
- inlen != 0 && u_ishspace(*inp) ; nextc(&inp, &inlen)) ;\r
- }\r
-\r
- /* set the length of the parsed value */\r
- val->val_len = outp - val->val;\r
-\r
- /* skip to the next line and continue parsing */\r
- skip_to_next_line(&p, &rem);\r
- }\r
-\r
- /* return the head of the linked list of value entries */\r
- return val_head;\r
-}\r
-static int my_memicmp(const void *aa, const void *bb, int l)\r
-{\r
- int s=0,i;\r
- char *a=(char *) aa;\r
- char *b=(char *) bb;\r
- for(i=0;i<l && !s;i++)\r
- s=tolower(a[i])-tolower(b[i]);\r
- return s;\r
-}\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * Given a valinfo list obtained from parse_game_info(), find the value for\r
- * the given key \r
- */\r
-static valinfo *find_by_key(valinfo *list_head, const char *key)\r
-{\r
- valinfo *p;\r
- size_t key_len = strlen(key);\r
- \r
- /* scan the list for the given key */\r
- for (p = list_head ; p != 0 ; p = p->nxt)\r
- {\r
- /* if this one matches the key we're looking for, return it */\r
- if (p->name_len == key_len && my_memicmp(p->name, key, key_len) == 0)\r
- return p;\r
- }\r
-\r
- /* no luck */\r
- return 0;\r
-}\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * Delete a valinfo list obtained from parse_game_info() \r
- */\r
-static void delete_valinfo_list(valinfo *head)\r
-{\r
- /* keep going until we run out of entries */\r
- while (head != 0)\r
- {\r
- /* remember the next entry, before we delete this one */\r
- valinfo *nxt = head->nxt;\r
-\r
- /* delete this one */\r
- free(head);\r
-\r
- /* move on to the next one */\r
- head = nxt;\r
- }\r
-}\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * Find the cover art resource. We'll look for CoverArt.jpg and\r
- * CoverArt.png, in that order. \r
- */\r
-static int find_cover_art(const void *story_file, int32 story_len,\r
- resinfo *resp, int32 *image_format,\r
- int32 *width, int32 *height)\r
-{\r
- resinfo res;\r
- int32 x, y;\r
-\r
- /* if they didn't want the resource info, provide a placeholder */\r
- if (resp == 0)\r
- resp = &res;\r
-\r
- /* look for CoverArt.jpg first */\r
- if (find_resource(story_file, story_len, "CoverArt.jpg", resp))\r
- {\r
- /* get the width and height */\r
- if (!get_jpeg_dim(resp->ptr, resp->len, &x, &y))\r
- return FALSE;\r
-\r
- /* hand back the width and height if it was requested */\r
- if (width != 0)\r
- *width = x;\r
- if (height != 0)\r
- *height = y;\r
-\r
- /* tell them it's a JPEG image */\r
- if (image_format != 0)\r
- *image_format = JPEG_COVER_FORMAT;\r
-\r
- /* indicate success */\r
- return TRUE;\r
- }\r
-\r
- /* look for CoverArt.png second */\r
- if (find_resource(story_file, story_len, "CoverArt.png", resp))\r
- {\r
- /* get the width and height */\r
- if (!get_png_dim(resp->ptr, resp->len, &x, &y))\r
- return FALSE;\r
-\r
- /* hand back the width and height if it was requested */\r
- if (width != 0)\r
- *width = x;\r
- if (height != 0)\r
- *height = y;\r
-\r
- /* tell them it's a PNG image */\r
- if (image_format != 0)\r
- *image_format = PNG_COVER_FORMAT;\r
-\r
- /* indicate success */\r
- return TRUE;\r
- }\r
-\r
- /* didn't find it */\r
- return FALSE;\r
-}\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * Find a resource in a TADS 2 or 3 story file that's been loaded into\r
- * memory. On success, fills in the offset and size of the resource and\r
- * returns TRUE; if the resource isn't found, returns FALSE.\r
- */\r
-static int find_resource(const void *story_file, int32 story_len,\r
- const char *resname, resinfo *info)\r
-{\r
- /* if there's no file, there's no resource */\r
- if (story_file == 0)\r
- return FALSE;\r
-\r
- /* check for tads 2 */\r
- if (tads_match_sig(story_file, story_len, T2_SIGNATURE))\r
- {\r
- info->tads_version = 2;\r
- return t2_find_res(story_file, story_len, resname, info);\r
- }\r
-\r
- /* check for tads 3 */\r
- if (tads_match_sig(story_file, story_len, T3_SIGNATURE))\r
- {\r
- info->tads_version = 3;\r
- return t3_find_res(story_file, story_len, resname, info);\r
- }\r
-\r
- /* it's not one of ours */\r
- return FALSE;\r
-}\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * Find a resource in a tads 2 game file \r
- */\r
-static int t2_find_res(const void *story_file, int32 story_len,\r
- const char *resname, resinfo *info)\r
-{\r
- const char *basep = (const char *)story_file;\r
- const char *endp = basep + story_len;\r
- const char *p;\r
- size_t resname_len;\r
-\r
- /* note the length of the name we're seeking */\r
- resname_len = strlen(resname);\r
-\r
- /* \r
- * skip past the tads 2 file header (13 bytes for the signature, 7\r
- * bytes for the version header, 2 bytes for the flags, 26 bytes for\r
- * the timestamp) \r
- */\r
- p = basep + 13 + 7 + 2 + 26;\r
-\r
- /* \r
- * scan the sections in the file; stop on $EOF, and skip everything\r
- * else but HTMLRES, which is the section type that \r
- */\r
- while (p < endp)\r
- {\r
- unsigned long endofs;\r
-\r
- /*\r
- * We're pointing to a section block header, which looks like this:\r
- * \r
- *. <byte> type-length\r
- *. <byte * type-length> type-name\r
- *. <uint32> next-section-address\r
- */\r
-\r
- /* read the ending offset */\r
- endofs = osrp4(p + 1 + osrp1(p));\r
-\r
- /* check the type */\r
- if (p[0] == 7 && memcmp(p + 1, "HTMLRES", 7) == 0)\r
- {\r
- unsigned long found_ofs;\r
- int found;\r
- unsigned long entry_cnt;\r
-\r
- /* we haven't found the resource yet */\r
- found = FALSE;\r
-\r
- /* \r
- * It's a multimedia resource block. Skip the section block\r
- * header and look at the index table - the index table\r
- * consists of a uint32 giving the number of entries, followed\r
- * by a reserved uint32, followed by the entries. \r
- */\r
- p += 12;\r
- entry_cnt = osrp4(p);\r
-\r
- /* skip to the first index entry */\r
- p += 8;\r
-\r
- /* scan the index entries */\r
- for ( ; entry_cnt != 0 ; --entry_cnt)\r
- {\r
- unsigned long res_ofs;\r
- unsigned long res_siz;\r
- size_t name_len;\r
-\r
- /*\r
- * We're at the next index entry, which looks like this:\r
- *\r
- *. <uint32> resource-address (bytes from end of index)\r
- *. <uint32> resource-length (in bytes)\r
- *. <uint2> name-length\r
- *. <byte * name-length> name\r
- */\r
- res_ofs = osrp4(p);\r
- res_siz = osrp4(p + 4);\r
- name_len = osrp2(p + 8);\r
- p += 10;\r
-\r
- /* check for a match to the name we're looking for */\r
- if (name_len == resname_len\r
- && my_memicmp(resname, p, name_len) == 0)\r
- {\r
- /* \r
- * it's the one we want - note its resource location\r
- * and size, but keep scanning for now, since we need\r
- * to find the end of the index before we'll know where\r
- * the actual resources begin \r
- */\r
- found = TRUE;\r
- found_ofs = res_ofs;\r
- info->len = res_siz;\r
- }\r
-\r
- /* skip this one's name */\r
- p += name_len;\r
- }\r
-\r
- /* \r
- * if we found our resource, the current seek position is the\r
- * base of the offset we found in the directory; so we can\r
- * finally fix up the offset to give the actual file location\r
- * and return the result \r
- */\r
- if (found)\r
- {\r
- /* fix up the offset with the actual file location */\r
- info->ptr = p + found_ofs;\r
-\r
- /* tell the caller we found it */\r
- return TRUE;\r
- }\r
- }\r
- else if (p[0] == 4 && memcmp(p + 1, "$EOF", 4) == 0)\r
- {\r
- /* \r
- * that's the end of the file - we've finished without finding\r
- * the resource, so return failure \r
- */\r
- return FALSE;\r
- }\r
-\r
- /* move to the next section */\r
- p = basep + endofs;\r
- }\r
-\r
- /* \r
- * reached EOF without an $EOF marker - file must be corrupted; return\r
- * 'not found' \r
- */\r
- return FALSE;\r
-}\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * Find a resource in a T3 image file \r
- */\r
-static int t3_find_res(const void *story_file, int32 story_len,\r
- const char *resname, resinfo *info)\r
-{\r
- const char *basep = (const char *)story_file;\r
- const char *endp = basep + story_len;\r
- const char *p;\r
- size_t resname_len;\r
-\r
- /* note the length of the name we're seeking */\r
- resname_len = strlen(resname);\r
-\r
- /* \r
- * skip the file header - 11 bytes for the signature, 2 bytes for the\r
- * format version, 32 reserved bytes, and 24 bytes for the timestamp \r
- */\r
- p = basep + 11 + 2 + 32 + 24;\r
-\r
- /* scan the data blocks */\r
- while (p < endp)\r
- {\r
- unsigned long siz;\r
-\r
- /*\r
- * We're at the next block header, which looks like this:\r
- *\r
- *. <byte * 4> type-name\r
- *. <uint32> block-size\r
- *. <uint16> flags\r
- */\r
-\r
- /* get the block size */\r
- siz = osrp4(p + 4);\r
-\r
- /* check the type */\r
- if (memcmp(p, "MRES", 4) == 0)\r
- {\r
- unsigned int entry_cnt;\r
- unsigned int i;\r
- const char *blockp;\r
-\r
- /* skip the header */\r
- p += 10;\r
-\r
- /* \r
- * remember the location of the base of the block - the data\r
- * seek location for each index entry is given as an offset\r
- * from this location \r
- */\r
- blockp = p;\r
-\r
- /* the first thing in the table is the number of entries */\r
- entry_cnt = osrp2(p);\r
- p += 2;\r
-\r
- /* read the entries */\r
- for (i = 0 ; i < entry_cnt ; ++i)\r
- {\r
- unsigned long entry_ofs;\r
- unsigned long entry_siz;\r
- size_t entry_name_len;\r
- char namebuf[256];\r
- char *xp;\r
- size_t xi;\r
-\r
- /* \r
- * Parse this index entry:\r
- * \r
- *. <uint32> address (as offset from the block base)\r
- *. <uint32> size (in bytes)\r
- *. <uint8> name-length\r
- *. <byte * name-length> name (all bytes XORed with 0xFF)\r
- */\r
- entry_ofs = osrp4(p);\r
- entry_siz = osrp4(p + 4);\r
- entry_name_len = (unsigned char)p[8];\r
-\r
- /* unmask the name */\r
- memcpy(namebuf, p + 9, resname_len);\r
- for (xi = resname_len, xp = namebuf ; xi != 0 ; --xi)\r
- *xp++ ^= 0xFF;\r
-\r
- /* if this is the one we're looking for, return it */\r
- if (entry_name_len == resname_len\r
- && my_memicmp(resname, namebuf, resname_len) == 0)\r
- {\r
- /* \r
- * fill in the return information - note that the entry\r
- * offset given in the header is an offset from data\r
- * block's starting location, so fix this up to an\r
- * absolute seek location for the return value \r
- */\r
- info->ptr = blockp + entry_ofs;\r
- info->len = entry_siz;\r
-\r
- /* return success */\r
- return TRUE;\r
- }\r
-\r
- /* skip this entry (header + name length) */\r
- p += 9 + entry_name_len;\r
- }\r
-\r
- /* \r
- * if we got this far, we didn't find the name; so skip past\r
- * the MRES section by adding the section length to the base\r
- * pointer, and resume the main file scan \r
- */\r
- p = blockp + siz;\r
- }\r
- else if (memcmp(p, "EOF ", 4) == 0)\r
- {\r
- /* \r
- * end of file - we've finished without finding the resource,\r
- * so return failure \r
- */\r
- return FALSE;\r
- }\r
- else\r
- {\r
- /* \r
- * we don't care about anything else - just skip this block and\r
- * keep going; to skip the block, simply seek ahead past the\r
- * block header and then past the block's contents, using the\r
- * size given the in block header \r
- */\r
- p += siz + 10;\r
- }\r
- }\r
-\r
- /* \r
- * reached EOF without an EOF marker - file must be corrupted; return\r
- * 'not found' \r
- */\r
- return FALSE;\r
-}\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * JPEG and PNG information extraction (based on the versions in\r
- * babel_story_functions.c) \r
- */\r
-static int get_jpeg_dim(const void *img, int32 extent,\r
- int32 *xout, int32 *yout)\r
-{\r
- const unsigned char *dp=(const unsigned char *) img;\r
- const unsigned char *ep=dp+extent;\r
- unsigned int t1, t2, w, h;\r
-\r
- t1 = *dp++;\r
- t2 = *dp++;\r
- if (t1 != 0xff || t2 != 0xD8)\r
- return FALSE;\r
-\r
- while(1)\r
- {\r
- if (dp>ep) return FALSE;\r
- for(t1=*(dp++);t1!=0xff;t1=*(dp++)) if (dp>ep) return FALSE;\r
- do { t1=*(dp++); if (dp>ep) return FALSE;} while (t1 == 0xff);\r
-\r
- if ((t1 & 0xF0) == 0xC0 && !(t1==0xC4 || t1==0xC8 || t1==0xCC))\r
- {\r
- dp+=3;\r
- if (dp>ep) return FALSE;\r
- h=*(dp++) << 8;\r
- if (dp>ep) return FALSE;\r
- h|=*(dp++);\r
- if (dp>ep) return FALSE;\r
- w=*(dp++) << 8;\r
- if (dp>ep) return FALSE;\r
- w|=*(dp);\r
-\r
- *xout = w;\r
- *yout = h;\r
- return TRUE;\r
- }\r
- else if (t1==0xD8 || t1==0xD9)\r
- break;\r
- else\r
- {\r
- int l;\r
-\r
- if (dp>ep) return FALSE;\r
- l=*(dp++) << 8;\r
- if (dp>ep) return FALSE;\r
- l|= *(dp++);\r
- l-=2;\r
- dp+=l;\r
- if (dp>ep) return FALSE;\r
- }\r
- }\r
- return FALSE;\r
-}\r
-\r
-static int32 png_read_int(const unsigned char *mem)\r
-{\r
- int32 i4 = mem[0],\r
- i3 = mem[1],\r
- i2 = mem[2],\r
- i1 = mem[3];\r
- return i1 | (i2<<8) | (i3<<16) | (i4<<24);\r
-}\r
-\r
-\r
-static int get_png_dim(const void *img, int32 extent,\r
- int32 *xout, int32 *yout)\r
-{\r
- const unsigned char *dp=(const unsigned char *)img;\r
-\r
- if (extent<33 ||\r
- !(dp[0]==137 && dp[1]==80 && dp[2]==78 && dp[3]==71 &&\r
- dp[4]==13 && dp[5] == 10 && dp[6] == 26 && dp[7]==10)||\r
- !(dp[12]=='I' && dp[13]=='H' && dp[14]=='D' && dp[15]=='R'))\r
- return FALSE;\r
-\r
- *xout = png_read_int(dp+16);\r
- *yout = png_read_int(dp+20);\r
- return TRUE;\r
-}\r
-\r
-/* ------------------------------------------------------------------------ */\r
-/*\r
- * Testing main() - this implements a set of unit tests on the tads\r
- * version. \r
- */\r
-\r
-#ifdef TADS_TEST\r
-\r
-#include "babel_handler.h"\r
-\r
-void main(int argc, char **argv)\r
-{\r
- FILE *fp;\r
- int32 siz;\r
- void *buf;\r
- valinfo *head;\r
- int32 rv;\r
- int tadsver;\r
- char outbuf[TREATY_MINIMUM_EXTENT];\r
-\r
- /* check arguments */\r
- if (argc != 2)\r
- {\r
- printf("usage: tads <game-file>\n");\r
- exit(1);\r
- }\r
-\r
- /* initialize the babel subsystems */\r
- babel_init(argv[1]);\r
-\r
- /* open the story file */\r
- if ((fp = fopen(argv[1], "rb")) == 0)\r
- {\r
- printf("error opening input file\n");\r
- exit(2);\r
- }\r
-\r
- /* check the file size */\r
- fseek(fp, 0, SEEK_END);\r
- siz = ftell(fp);\r
- fseek(fp, 0, SEEK_SET);\r
-\r
- /* allocate space for it */\r
- if ((buf = malloc(siz)) == 0)\r
- {\r
- printf("error allocating space to load file\n");\r
- exit(2);\r
- }\r
-\r
- /* load it */\r
- if ((int32)fread(buf, 1, siz, fp) != siz)\r
- {\r
- printf("error reading file\n");\r
- exit(2);\r
- }\r
-\r
- /* done with the file */\r
- fclose(fp);\r
-\r
-\r
-\r
- /* ===== test 1 - basic parse_game_info() test ===== */\r
-\r
- /* parse the gameinfo record and print the results */\r
- if ((head = parse_game_info(buf, siz, &tadsver)) != 0)\r
- {\r
- valinfo *val;\r
-\r
- printf("found GameInfo - tads major version = %d\n", tadsver);\r
- for (val = head ; val != 0 ; val = val->nxt)\r
- {\r
- printf("%.*s=[%.*s]\n",\r
- (int)val->name_len, val->name,\r
- (int)val->val_len, val->val);\r
- }\r
- printf("\n");\r
- }\r
- else\r
- printf("no GameInfo found\n\n");\r
-\r
-\r
-\r
- /* ===== test 2 - test the get_story_file_IFID generator ===== */\r
- rv = tads_get_story_file_IFID(buf, siz, outbuf, TREATY_MINIMUM_EXTENT);\r
- if (rv == 1)\r
- printf("IFID = [%s]\n\n", outbuf);\r
- else\r
- printf("IFID return code = %ld\n", rv);\r
-\r
-\r
-\r
- /* ===== test 3 - test the ifiction synthesizer ===== */\r
- if ((rv = tads_get_story_file_metadata_extent(buf, siz)) > 0)\r
- {\r
- char *ifbuf;\r
-\r
- /* try allocating the space */\r
- if ((ifbuf = malloc((size_t)rv)) != 0)\r
- {\r
- /* synthesize the story file */\r
- rv = tads_get_story_file_metadata(buf, siz, ifbuf, rv);\r
- if (rv > 0)\r
- printf("ifiction metadata:\n=====\n%.*s\n=====\n\n",\r
- (int)rv, ifbuf);\r
- else\r
- printf("tads_get_story_file_metadata result = %ld\n", rv);\r
- }\r
- else\r
- printf("unable to allocate %ld bytes for metadata record\n", rv);\r
- }\r
- else\r
- printf("tads_get_story_file_metadata_extent result code = %ld\n", rv);\r
- \r
-\r
- /* free the loaded story file buffer */\r
- free(buf);\r
-}\r
-\r
-\r
-#endif TADS_TEST\r
-\r
projects / projects / chimara / chimara.git / blobdiff