diff options
Diffstat (limited to 'src/deh_str.c')
-rw-r--r-- | src/deh_str.c | 408 |
1 files changed, 408 insertions, 0 deletions
diff --git a/src/deh_str.c b/src/deh_str.c new file mode 100644 index 00000000..9bd429b6 --- /dev/null +++ b/src/deh_str.c @@ -0,0 +1,408 @@ +// Emacs style mode select -*- C++ -*- +//----------------------------------------------------------------------------- +// +// Copyright(C) 2005 Simon Howard +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +// 02111-1307, USA. +// +//----------------------------------------------------------------------------- +// +// Parses Text substitution sections in dehacked files +// +//----------------------------------------------------------------------------- + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdarg.h> + +#include "doomtype.h" +#include "deh_str.h" + +#include "z_zone.h" + +typedef struct +{ + char *from_text; + char *to_text; +} deh_substitution_t; + +static deh_substitution_t **hash_table = NULL; +static int hash_table_entries; +static int hash_table_length = -1; + +// This is the algorithm used by glib + +static unsigned int strhash(char *s) +{ + char *p = s; + unsigned int h = *p; + + if (h) + { + for (p += 1; *p; p++) + h = (h << 5) - h + *p; + } + + return h; +} + +// Look up a string to see if it has been replaced with something else +// This will be used throughout the program to substitute text + +char *DEH_String(char *s) +{ + int entry; + + // Fallback if we have not initialized the hash table yet + + if (hash_table_length < 0) + return s; + + entry = strhash(s) % hash_table_length; + + while (hash_table[entry] != NULL) + { + if (!strcmp(hash_table[entry]->from_text, s)) + { + // substitution found! + + return hash_table[entry]->to_text; + } + + entry = (entry + 1) % hash_table_length; + } + + // no substitution found + + return s; +} + +static void InitHashTable(void) +{ + // init hash table + + hash_table_entries = 0; + hash_table_length = 16; + hash_table = Z_Malloc(sizeof(deh_substitution_t *) * hash_table_length, + PU_STATIC, NULL); + memset(hash_table, 0, sizeof(deh_substitution_t *) * hash_table_length); +} + +static void DEH_AddToHashtable(deh_substitution_t *sub); + +static void IncreaseHashtable(void) +{ + deh_substitution_t **old_table; + int old_table_length; + int i; + + // save the old table + + old_table = hash_table; + old_table_length = hash_table_length; + + // double the size + + hash_table_length *= 2; + hash_table = Z_Malloc(sizeof(deh_substitution_t *) * hash_table_length, + PU_STATIC, NULL); + memset(hash_table, 0, sizeof(deh_substitution_t *) * hash_table_length); + + // go through the old table and insert all the old entries + + for (i=0; i<old_table_length; ++i) + { + if (old_table[i] != NULL) + { + DEH_AddToHashtable(old_table[i]); + } + } + + // free the old table + + Z_Free(old_table); +} + +static void DEH_AddToHashtable(deh_substitution_t *sub) +{ + int entry; + + // if the hash table is more than 60% full, increase its size + + if ((hash_table_entries * 10) / hash_table_length > 6) + { + IncreaseHashtable(); + } + + // find where to insert it + + entry = strhash(sub->from_text) % hash_table_length; + + while (hash_table[entry] != NULL) + { + entry = (entry + 1) % hash_table_length; + } + + hash_table[entry] = sub; + ++hash_table_entries; +} + +void DEH_AddStringReplacement(char *from_text, char *to_text) +{ + deh_substitution_t *sub; + + // Initialize the hash table if this is the first time + + if (hash_table_length < 0) + { + InitHashTable(); + } + + sub = Z_Malloc(sizeof(*sub), PU_STATIC, 0); + + sub->from_text = from_text; + sub->to_text = to_text; + + DEH_AddToHashtable(sub); +} + +typedef enum +{ + FORMAT_ARG_INVALID, + FORMAT_ARG_INT, + FORMAT_ARG_FLOAT, + FORMAT_ARG_CHAR, + FORMAT_ARG_STRING, + FORMAT_ARG_PTR, + FORMAT_ARG_SAVE_POS +} format_arg_t; + +// Get the type of a format argument. +// We can mix-and-match different format arguments as long as they +// are for the same data type. + +static format_arg_t FormatArgumentType(char c) +{ + switch (c) + { + case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': + return FORMAT_ARG_INT; + + case 'e': case 'E': case 'f': case 'F': case 'g': case 'G': + case 'a': case 'A': + return FORMAT_ARG_FLOAT; + + case 'c': case 'C': + return FORMAT_ARG_CHAR; + + case 's': case 'S': + return FORMAT_ARG_STRING; + + case 'p': + return FORMAT_ARG_PTR; + + case 'n': + return FORMAT_ARG_SAVE_POS; + + default: + return FORMAT_ARG_INVALID; + } +} + +// Given the specified string, get the type of the first format +// string encountered. + +static format_arg_t NextFormatArgument(char **str) +{ + format_arg_t argtype; + + // Search for the '%' starting the next string. + + while (**str != '\0') + { + if (**str == '%') + { + ++*str; + + // Don't stop for double-%s. + + if (**str != '%') + { + break; + } + } + + ++*str; + } + + // Find the type of the format string. + + while (**str != '\0') + { + argtype = FormatArgumentType(**str); + + if (argtype != FORMAT_ARG_INVALID) + { + ++*str; + + return argtype; + } + + ++*str; + } + + // Stop searching, we have reached the end. + + *str = NULL; + + return FORMAT_ARG_INVALID; +} + +// Check if the specified argument type is a valid replacement for +// the original. + +static boolean ValidArgumentReplacement(format_arg_t original, + format_arg_t replacement) +{ + // In general, the original and replacement types should be + // identical. However, there are some cases where the replacement + // is valid and the types don't match. + + // Characters can be represented as ints. + + if (original == FORMAT_ARG_CHAR && replacement == FORMAT_ARG_INT) + { + return true; + } + + // Strings are pointers. + + if (original == FORMAT_ARG_STRING && replacement == FORMAT_ARG_PTR) + { + return true; + } + + return original == replacement; +} + +// Return true if the specified string contains no format arguments. + +static boolean ValidFormatReplacement(char *original, char *replacement) +{ + char *rover1; + char *rover2; + int argtype1, argtype2; + + // Check each argument in turn and compare types. + + rover1 = original; rover2 = replacement; + + for (;;) + { + argtype1 = NextFormatArgument(&rover1); + argtype2 = NextFormatArgument(&rover2); + + if (argtype2 == FORMAT_ARG_INVALID) + { + // No more arguments left to read from the replacement string. + + break; + } + else if (argtype1 == FORMAT_ARG_INVALID) + { + // Replacement string has more arguments than the original. + + return false; + } + else if (!ValidArgumentReplacement(argtype1, argtype2)) + { + // Not a valid replacement argument. + + return false; + } + } + + return true; +} + +// Get replacement format string, checking arguments. + +static char *FormatStringReplacement(char *s) +{ + char *repl; + + repl = DEH_String(s); + + if (!ValidFormatReplacement(s, repl)) + { + printf("WARNING: Unsafe dehacked replacement provided for " + "printf format string: %s\n", s); + + return s; + } + + return repl; +} + +// printf(), performing a replacement on the format string. + +void DEH_printf(char *fmt, ...) +{ + va_list args; + char *repl; + + repl = FormatStringReplacement(fmt); + + va_start(args, fmt); + + vprintf(repl, args); + + va_end(args); +} + +// fprintf(), performing a replacement on the format string. + +void DEH_fprintf(FILE *fstream, char *fmt, ...) +{ + va_list args; + char *repl; + + repl = FormatStringReplacement(fmt); + + va_start(args, fmt); + + vfprintf(fstream, repl, args); + + va_end(args); +} + +// snprintf(), performing a replacement on the format string. + +void DEH_snprintf(char *buffer, size_t len, char *fmt, ...) +{ + va_list args; + char *repl; + + repl = FormatStringReplacement(fmt); + + va_start(args, fmt); + + vsnprintf(buffer, len, repl, args); + + va_end(args); +} + |