diff options
Diffstat (limited to 'engines/sci')
| -rw-r--r-- | engines/sci/engine/cfsml.pl | 1183 | ||||
| -rw-r--r-- | engines/sci/engine/said.y | 948 | ||||
| -rw-r--r-- | engines/sci/engine/savegame.cfsml | 1150 |
3 files changed, 3281 insertions, 0 deletions
diff --git a/engines/sci/engine/cfsml.pl b/engines/sci/engine/cfsml.pl new file mode 100644 index 0000000000..982a536b70 --- /dev/null +++ b/engines/sci/engine/cfsml.pl @@ -0,0 +1,1183 @@ +#! /usr/bin/env perl +# The C File Storage Meta Language "reference" implementation +# This implementation is supposed to conform to version +$version = "0.8.2"; +# of the spec. Please contact the maintainer if it doesn't. +# +# cfsml.pl Copyright (C) 1999, 2000, 2001 Christoph Reichenbach +# +# +# This program may be modified and copied freely according to the terms of +# the GNU general public license (GPL), as long as the above copyright +# notice and the licensing information contained herein are preserved. +# +# Please refer to www.gnu.org for licensing details. +# +# This work is provided AS IS, without warranty of any kind, expressed or +# implied, including but not limited to the warranties of merchantibility, +# noninfringement, and fitness for a specific purpose. The author will not +# be held liable for any damage caused by this work or derivatives of it. +# +# By using this source code, you agree to the licensing terms as stated +# above. +# +# +# Please contact the maintainer for bug reports or inquiries. +# +# Current Maintainer: +# +# Christoph Reichenbach (CJR) [jameson@linuxgames.com] +# +# +# Warning: This is still a "bit" messy. Sorry for that. +# + +#$debug = 1; + +$write_lines = "true"; +$source_file = "CFSML source file"; +$type_integer = "integer"; +$type_string = "string"; +$type_record = "RECORD"; +$type_pointer = "POINTER"; +$type_abspointer = "ABSPOINTER"; + +%types; # Contains all type bindings +%records; # Contains all record bindings + +$mode = undef; +while ($op = shift @ARGV) { + if ($mode eq undef) { + if ($op eq "-f") { + $mode = "fname"; + } elsif ($op eq "-l") { + $write_lines = undef; + } elsif ($op eq "-v") { + print "cfsml.pl, the CFSML code generator, version $version\n"; + print "This program is provided WITHOUT WARRANTY of any kind. It may be\n"; + print "copied and modified freely according to the terms of the GNU\n"; + print "General Public License.\n"; + exit(0); + } elsif ($op eq "-h") { + print "CFSML help:\n"; + print "Usage: cat source | cfsml.pl [-v] [-h] [-l] [-f <filename>] > dest\n"; + print " -h : help\n"; + print " -v : print version\n"; + print " -l : disable line number printing in dest file\n"; + print " -f : specify file name for line number printing\n"; + exit(0); + } else { + die "Unknown option '$op'\n"; + } + } elsif ($mode eq "fname") { + $source_file = $op; + $mode = 0; + } else { + die "Invalid internal state '$mode'\n"; + } +} + +sub write_line_pp +# write_line_pp(int line_nr, bool input_file?) +{ + my $line_nr = shift; + my $_file = shift; + my $filename = "cfsml.pl"; + + if (_file) { + $filename = $source_file; + } + + if ($write_lines) { + print "#line $line_nr \"$filename\"\n"; + } +} + +sub create_string_functions + { + $firstline = __LINE__; + $firstline += 4; + write_line_pp($firstline, 0); + print <<'EOF'; + +#include <stdarg.h> /* We need va_lists */ +#include "sci/include/sci_memory.h" + +#ifdef CFSML_DEBUG_MALLOC +/* +#define free(p) dbg_sci_free(p) +#define malloc(s) dbg_sci_malloc(s) +#define calloc(n, s) dbg_sci_calloc(n, s) +#define realloc(p, s) dbg_sci_realloc(p, s) +*/ +#define free dbg_sci_free +#define malloc dbg_sci_malloc +#define calloc dbg_sci_calloc +#define realloc dbg_sci_realloc +#endif + +static void +_cfsml_error(const char *fmt, ...) +{ + va_list argp; + + fprintf(stderr, "Error: "); + va_start(argp, fmt); + vfprintf(stderr, fmt, argp); + va_end(argp); + +} + + +static struct _cfsml_pointer_refstruct { + struct _cfsml_pointer_refstruct *next; + void *ptr; +} *_cfsml_pointer_references = NULL; + +static struct _cfsml_pointer_refstruct **_cfsml_pointer_references_current = &_cfsml_pointer_references; + +static char *_cfsml_last_value_retrieved = NULL; +static char *_cfsml_last_identifier_retrieved = NULL; + +static void +_cfsml_free_pointer_references_recursively(struct _cfsml_pointer_refstruct *refs, int free_pointers) +{ + if (!refs) + return; + #ifdef CFSML_DEBUG_MALLOC + SCI_MEMTEST; + #endif + + _cfsml_free_pointer_references_recursively(refs->next, free_pointers); + #ifdef CFSML_DEBUG_MALLOC + SCI_MEMTEST; + + fprintf(stderr,"Freeing ptrref %p [%p] %s\n", refs->ptr, refs, free_pointers? + "ALL": "cleanup only"); + #endif + + if (free_pointers) + free(refs->ptr); + + #ifdef CFSML_DEBUG_MALLOC + SCI_MEMTEST; + #endif + free(refs); + #ifdef CFSML_DEBUG_MALLOC + SCI_MEMTEST; + #endif +} + +static void +_cfsml_free_pointer_references(struct _cfsml_pointer_refstruct **meta_ref, int free_pointers) +{ + _cfsml_free_pointer_references_recursively(*meta_ref, free_pointers); + *meta_ref = NULL; + _cfsml_pointer_references_current = meta_ref; +} + +static struct _cfsml_pointer_refstruct ** +_cfsml_get_current_refpointer() +{ + return _cfsml_pointer_references_current; +} + +static void _cfsml_register_pointer(void *ptr) +{ + struct _cfsml_pointer_refstruct *newref = (struct _cfsml_pointer_refstruct*)sci_malloc(sizeof (struct _cfsml_pointer_refstruct)); + #ifdef CFSML_DEBUG_MALLOC + SCI_MEMTEST; + fprintf(stderr,"Registering ptrref %p [%p]\n", ptr, newref); + #endif + newref->next = *_cfsml_pointer_references_current; + newref->ptr = ptr; + *_cfsml_pointer_references_current = newref; +} + + +static char * +_cfsml_mangle_string(const char *s) +{ + const char *source = s; + char c; + char *target = (char *) sci_malloc(1 + strlen(s) * 2); /* We will probably need less than that */ + char *writer = target; + + while ((c = *source++)) { + + if (c < 32) { /* Special character? */ + *writer++ = '\\'; /* Escape... */ + c += ('a' - 1); + } else if (c == '\\' || c == '"') + *writer++ = '\\'; /* Escape, but do not change */ + *writer++ = c; + + } + *writer = 0; /* Terminate string */ + + return (char *) sci_realloc(target, strlen(target) + 1); +} + + +static char * +_cfsml_unmangle_string(const char *s, unsigned int length) +{ + char *target = (char *) sci_malloc(1 + strlen(s)); + char *writer = target; + const char *source = s; + const char *end = s + length; + char c; + + while ((source != end) && (c = *source++) && (c > 31)) { + if (c == '\\') { /* Escaped character? */ + c = *source++; + if ((c != '\\') && (c != '"')) /* Un-escape 0-31 only */ + c -= ('a' - 1); + } + *writer++ = c; + } + *writer = 0; /* Terminate string */ + + return (char *) sci_realloc(target, strlen(target) + 1); +} + + +static char * +_cfsml_get_identifier(FILE *fd, int *line, int *hiteof, int *assignment) +{ + int c; + int mem = 32; + int pos = 0; + int done = 0; + char *retval = (char *) sci_malloc(mem); + + if (_cfsml_last_identifier_retrieved) { + free(_cfsml_last_identifier_retrieved); + _cfsml_last_identifier_retrieved = NULL; + } + + while (isspace(c = fgetc(fd)) && (c != EOF)); + if (c == EOF) { + _cfsml_error("Unexpected end of file at line %d\n", *line); + free(retval); + *hiteof = 1; + return NULL; + } + + ungetc(c, fd); + + while (((c = fgetc(fd)) != EOF) && ((pos == 0) || (c != '\n')) && (c != '=')) { + + if (pos == mem - 1) /* Need more memory? */ + retval = (char *) sci_realloc(retval, mem *= 2); + + if (!isspace(c)) { + if (done) { + _cfsml_error("Single word identifier expected at line %d\n", *line); + free(retval); + return NULL; + } + retval[pos++] = c; + } else + if (pos != 0) + done = 1; /* Finished the variable name */ + else if (c == '\n') + ++(*line); + } + + if (c == EOF) { + _cfsml_error("Unexpected end of file at line %d\n", *line); + free(retval); + *hiteof = 1; + return NULL; + } + + if (c == '\n') { + ++(*line); + if (assignment) + *assignment = 0; + } else + if (assignment) + *assignment = 1; + + if (pos == 0) { + _cfsml_error("Missing identifier in assignment at line %d\n", *line); + free(retval); + return NULL; + } + + if (pos == mem - 1) /* Need more memory? */ + retval = (char *) sci_realloc(retval, mem += 1); + + retval[pos] = 0; /* Terminate string */ +EOF + +if ($debug) { + print " printf(\"identifier is '%s'\\n\", retval);\n"; +} + + $firstline = __LINE__; + $firstline += 4; + write_line_pp($firstline, 0); + print <<'EOF2'; + + return _cfsml_last_identifier_retrieved = retval; +} + + +static char * +_cfsml_get_value(FILE *fd, int *line, int *hiteof) +{ + int c; + int mem = 64; + int pos = 0; + char *retval = (char *) sci_malloc(mem); + + if (_cfsml_last_value_retrieved) { + free(_cfsml_last_value_retrieved); + _cfsml_last_value_retrieved = NULL; + } + + while (((c = fgetc(fd)) != EOF) && (c != '\n')) { + + if (pos == mem - 1) /* Need more memory? */ + retval = (char *) sci_realloc(retval, mem *= 2); + + if (pos || (!isspace(c))) + retval[pos++] = c; + + } + + while ((pos > 0) && (isspace(retval[pos - 1]))) + --pos; /* Strip trailing whitespace */ + + if (c == EOF) + *hiteof = 1; + + if (pos == 0) { + _cfsml_error("Missing value in assignment at line %d\n", *line); + free(retval); + return NULL; + } + + if (c == '\n') + ++(*line); + + if (pos == mem - 1) /* Need more memory? */ + retval = (char *) sci_realloc(retval, mem += 1); + + retval[pos] = 0; /* Terminate string */ +EOF2 + + if ($debug) { + print " printf(\"value is '%s'\\n\", retval);\n"; + } + + $firstline = __LINE__; + $firstline += 4; + write_line_pp($firstline, 0); + print <<'EOF3'; + return (_cfsml_last_value_retrieved = (char *) sci_realloc(retval, strlen(retval) + 1)); + /* Re-allocate; this value might be used for quite some while (if we are + ** restoring a string) + */ +} +EOF3 + } + + +# Call with $expression as a simple expression, like "tos + 1". +# Returns (in this case) ("tos", "-1"). +sub lvaluize + { + my @retval; +# print "//DEBUG: $expression ["; + my @tokens = split (/([+-\/\*])/, $expression); +# print join(",", @tokens); + $retval[0] = $tokens[0]; + + my $rightvalue = ""; + for ($i = 1; $tokens[$i]; $i++) { + + if ($tokens[$i] eq "+") { + $rightvalue .= "-"; + } elsif ($tokens[$i] eq "-") { + $rightvalue .= "+"; + } elsif ($tokens[$i] eq "/") { + $rightvalue .= "*"; + } elsif ($tokens[$i] eq "*") { + $rightvalue .= "/"; + } else { + $rightvalue .= $tokens[$i]; + } + } + + $retval[1] = $rightvalue; + +# print "] => ($retval[0];$retval[1])\n"; + + return @retval; + } + + + +sub create_declaration + { + $typename = $type; + $ctype = $types{$type}->{'ctype'}; + + if (not $types{$type}->{'external'}) { + $types{$type}{'writer'} = "_cfsml_write_" . $typename; + $types{$type}{'reader'} = "_cfsml_read_" . $typename; + write_line_pp(__LINE__, 0); + print "static void\n$types{$type}{'writer'}(FILE *fh, $ctype* save_struc);\n"; + print "static int\n$types{$type}{'reader'}(FILE *fh, $ctype* save_struc, const char *lastval,". + " int *line, int *hiteof);\n\n"; + }; + + } + +sub create_writer + { + $typename = $type; + $ctype = $types{$type}{'ctype'}; + + write_line_pp(__LINE__, 0); + print "static void\n_cfsml_write_$typename(FILE *fh, $ctype* save_struc)\n{\n"; + if ($types{$type}{'type'} eq $type_record) { + print " int min, max, i;\n\n"; + } + + if ($types{$type}{'type'} eq $type_integer) { + print " fprintf(fh, \"%li\", (long) *save_struc);\n"; + } + elsif ($types{$type}{'type'} eq $type_string) { + write_line_pp(__LINE__, 0); + print " if (!(*save_struc))\n"; + print " fprintf(fh, \"\\\\null\\\\\");\n"; + print " else {\n"; + print " char *token = _cfsml_mangle_string((const char *) *save_struc);\n"; + print " fprintf(fh, \"\\\"%s\\\"\", token);\n"; + print " free(token);\n"; + print " }\n"; + } + elsif ($types{$type}{'type'} eq $type_record) { + write_line_pp(__LINE__, 0); + print " fprintf(fh, \"{\\n\");\n"; + + for $n (@{$records{$type}}) { + + print " fprintf(fh, \"$n->{'name'} = \");\n"; + + if ($n->{'array'}) { # Check for arrays + + if ($n->{'array'} eq 'static' or $n->{'size'} * 2) { # fixed integer value? + print " min = max = $n->{'size'};\n"; + } + else { # No, a variable + print " min = max = save_struc->$n->{'size'};\n"; + } + + if ($n->{'maxwrite'}) { # A write limit? + print " if (save_struc->$n->{'maxwrite'} < min)\n"; + print " min = save_struc->$n->{'maxwrite'};\n"; + } + + if ($n->{'array'} eq 'dynamic') { + print " if (!save_struc->$n->{'name'})\n"; + print " min = max = 0; /* Don't write if it points to NULL */\n"; + } + + write_line_pp(__LINE__, 0); + print " fprintf(fh, \"[%d][\\n\", max);\n"; + print " for (i = 0; i < min; i++) {\n"; + print " $types{$n->{'type'}}{'writer'}"; + my $subscribstr = "[i]"; # To avoid perl interpolation problems + print "(fh, &(save_struc->$n->{'name'}$subscribstr));\n"; + print " fprintf(fh, \"\\n\");\n"; + print " }\n"; + print " fprintf(fh, \"]\");\n"; + + } elsif ($n->{'type'} eq $type_pointer) { # Relative pointer + + print " fprintf(fh, \"%d\", save_struc->$n->{'name'} - save_struc->$n->{'anchor'});" . + " /* Relative pointer */\n"; + + } elsif ($n->{'type'} eq $type_abspointer) { # Absolute pointer + + print " if (!save_struc->$n->{'name'})\n"; + print " fprintf(fh, \"\\\\null\\\\\");\n"; + print " else \n"; + print " $types{$n->{'reftype'}}{'writer'}"; + print "(fh, save_struc->$n->{'name'});\n"; + + } else { # Normal record entry + + print " $types{$n->{'type'}}{'writer'}"; + print "(fh, ($types{$n->{'type'}}{'ctype'}*) &(save_struc->$n->{'name'}));\n"; + + } + + print " fprintf(fh, \"\\n\");\n"; + } + + print " fprintf(fh, \"}\");\n"; + } + else { + print STDERR "Warning: Attempt to create_writer for invalid type '$types{$type}{'type'}'\n"; + } + print "}\n\n"; + + } + + +sub create_reader + { + $typename = $type; + $ctype = $types{$type}{'ctype'}; + + write_line_pp(__LINE__, 0); + print "static int\n_cfsml_read_$typename"; + print "(FILE *fh, $ctype* save_struc, const char *lastval, int *line, int *hiteof)\n{\n"; + + print " char *token;\n"; + if ($types{$type}{'type'} eq $type_record) { + print "int min, max, i;\n"; + } + my $reladdress_nr = 0; # Number of relative addresses needed + my $reladdress = 0; # Current relative address number + my $reladdress_resolver = ""; # Relative addresses are resolved after the main while block + + if ($types{$type}{'type'} eq $type_record) { + + foreach $n (@{$records{$type}}) { # Count relative addresses we need + if ($n->{'type'} eq $type_pointer) { + ++$reladdress_nr; + } + } + + if ($reladdress_nr) { # Allocate stack space for all relative addresses needed + print " int reladdresses[$reladdress_nr] = {0};\n"; + } + } + + if ($types{$type}{'type'} eq $type_integer) { + write_line_pp(__LINE__, 0); + print "\n *save_struc = strtol(lastval, &token, 0);\n"; + print " if ( (*save_struc == 0) && (token == lastval) ) {\n"; + print " _cfsml_error(\"strtol failed at line %d\\n\", *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n"; + print " if (*token != 0) {\n"; + print " _cfsml_error(\"Non-integer encountered while parsing int value at line %d\\n\","; + print " *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n"; + print " return CFSML_SUCCESS;\n"; + } elsif ($types{$type}{'type'} eq $type_string) { + write_line_pp(__LINE__, 0); + print "\n"; + print " if (strcmp(lastval, \"\\\\null\\\\\")) { /* null pointer? */\n"; + print " unsigned int length = strlen(lastval);\n"; + print " if (*lastval == '\"') { /* Quoted string? */\n"; + print " while (lastval[length] != '\"')\n"; + print " --length;\n\n"; + print " if (!length) { /* No matching double-quotes? */\n"; + print " _cfsml_error(\"Unbalanced quotes at line %d\\n\", *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n\n"; + print " lastval++; /* ...and skip the opening quotes locally */\n"; + print " length--;\n"; + print " }\n"; + print " *save_struc = _cfsml_unmangle_string(lastval, length);\n"; + print " _cfsml_register_pointer(*save_struc);\n"; + print " return CFSML_SUCCESS;\n"; + print " } else {\n"; + print " *save_struc = NULL;\n"; + print " return CFSML_SUCCESS;\n"; + print " }\n"; + } elsif ($types{$type}{'type'} eq $type_record) { + write_line_pp(__LINE__, 0); + print " int assignment, closed, done;\n\n"; + print " if (strcmp(lastval, \"{\")) {\n"; + print " _cfsml_error(\"Reading record $type; expected opening braces in line %d, got \\\"%s\\\"\\n\","; + print "*line, lastval);\n"; + print " return CFSML_FAILURE;\n"; + print " };\n"; + print " closed = 0;\n"; + print " do {\n"; + print " const char *value;\n"; + print " token = _cfsml_get_identifier(fh, line, hiteof, &assignment);\n\n"; + print " if (!token) {\n"; + print " _cfsml_error(\"Expected token at line %d\\n\", *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n"; + print " if (!assignment) {\n"; + print " if (!strcmp(token, \"}\")) \n"; + print " closed = 1;\n"; + print " else {\n"; + print " _cfsml_error(\"Expected assignment or closing braces in line %d\\n\", *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n"; + print " } else {\n"; + print " value = \"\";\n"; + print " while (!value || !strcmp(value, \"\"))\n"; + print " value = _cfsml_get_value(fh, line, hiteof);\n"; + print " if (!value) {\n"; + print " _cfsml_error(\"Expected token at line %d\\n\", *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n"; +# print " }\n"; + + + foreach $n (@{$records{$type}}) { # Now take care of all record elements + + my $type = $n->{'type'}; + my $reference = undef; + if ($type eq $type_abspointer) { + $reference = 1; + $type = $n->{'reftype'}; + } + my $name = $n->{'name'}; + my $reader = $types{$type}{'reader'}; + my $size = $n->{'size'}; + + print " if (!strcmp(token, \"$name\")) {\n"; + + if ($type eq $type_pointer) { # A relative pointer + + $reader = $types{'int'}{'reader'}; # Read relpointer as int + + write_line_pp(__LINE__, 0); + print " if ($reader(fh, &(reladdresses[$reladdress]), value, line, hiteof)) {\n"; + print " _cfsml_error(\"Expected token at line %d\\n\", *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n"; + + # Make sure that the resulting variable is interpreted correctly + $reladdress_resolver .= " save_struc->$n->{'name'} =". + " save_struc->$n->{'anchor'} + reladdresses[$reladdress];\n"; + + ++$reladdress; # Prepare reladdress for next element + + } elsif ($n->{'array'}) { # Is it an array? + write_line_pp(__LINE__, 0); + print " if ((value[0] != '[') || (value[strlen(value) - 1] != '[')) {\n"; + # The value must end with [, since we're starting array data, and it must also + # begin with [, since this is either the only character in the line, or it starts + # the "amount of memory to allocate" block + print " _cfsml_error(\"Opening brackets expected at line %d\\n\", *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n"; + + if ($n->{'array'} eq 'dynamic') { + write_line_pp(__LINE__, 0); + # We need to allocate the array first + print " /* Prepare to restore dynamic array */\n"; + # Read amount of memory to allocate + print " max = strtol(value + 1, NULL, 0);\n"; + print " if (max < 0) {\n"; + print " _cfsml_error(\"Invalid number of elements to allocate for dynamic "; + print "array '%s' at line %d\\n\", token, *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n\n"; + + print " if (max) {\n"; + print " save_struc->$name = ($n->{'type'} *) sci_malloc(max * sizeof($type));\n"; + print "#ifdef SATISFY_PURIFY\n"; + print " memset(save_struc->$name, 0, max * sizeof($type));\n"; + print "#endif\n"; + print " _cfsml_register_pointer(save_struc->$name);\n"; + print " }\n"; + print " else\n"; + print " save_struc->$name = NULL;\n" + + } else { # static array + print " /* Prepare to restore static array */\n"; + print " max = $size;\n"; + } + + write_line_pp(__LINE__, 0); + print " done = i = 0;\n"; + print " do {\n"; + if ($type eq $type_record) { + print " if (!(value = _cfsml_get_value(fh, line, hiteof))) {\n"; + } else { + print " if (!(value = _cfsml_get_identifier(fh, line, hiteof, NULL))) {\n"; + } + write_line_pp(__LINE__, 0); + + print " _cfsml_error(\"Token expected at line %d\\n\", *line);\n"; + print " return 1;\n"; + print " }\n"; + print " if (strcmp(value, \"]\")) {\n"; + print " if (i == max) {\n"; + print " _cfsml_error(\"More elements than space available (%d) in '%s' at "; + print "line %d\\n\", max, token, *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n"; + my $helper = "[i++]"; + print " if ($reader(fh, &(save_struc->$name$helper), value, line, hiteof)) {\n"; + print " _cfsml_error(\"Token expected by $reader() for $name$helper at line %d\\n\", *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n"; + print " } else done = 1;\n"; + print " } while (!done);\n"; + + if ($n->{'array'} eq "dynamic") { + my @xpr = lvaluize($expression = $n->{'size'}); + print " save_struc->$xpr[0] = max $xpr[1]; /* Set array size accordingly */\n"; + } + + if ($n->{'maxwrite'}) { + my @xpr = lvaluize($expression = $n->{'maxwrite'}); + print " save_struc->$xpr[0] = i $xpr[1]; /* Set number of elements */\n"; + } + + } + elsif ($reference) { + write_line_pp(__LINE__, 0); + print " if (strcmp(value, \"\\\\null\\\\\")) { /* null pointer? */\n"; + print " save_struc->$name = sci_malloc(sizeof ($type));\n"; + print " _cfsml_register_pointer(save_struc->$name);\n"; + print " if ($reader(fh, save_struc->$name, value, line, hiteof)) {\n"; + print " _cfsml_error(\"Token expected by $reader() for $name at line %d\\n\", *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n"; + print " } else save_struc->$name = NULL;\n"; + } + else { # It's a simple variable or a struct + write_line_pp(__LINE__, 0); + print " if ($reader(fh, ($types{$type}{'ctype'}*) &(save_struc->$name), value, line, hiteof)) {\n"; + print " _cfsml_error(\"Token expected by $reader() for $name at line %d\\n\", *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n"; + } + print " } else\n"; + + } + write_line_pp(__LINE__, 0); + print " {\n"; + print " _cfsml_error(\"$type: Assignment to invalid identifier '%s' in line %d\\n\","; + print " token, *line);\n"; + print " return CFSML_FAILURE;\n"; + print " }\n"; + print " }\n"; + + print " } while (!closed); /* Until closing braces are hit */\n"; + + print $reladdress_resolver; # Resolves any relative addresses + + print " return CFSML_SUCCESS;\n"; + } else { + print STDERR "Warning: Attempt to create_reader for invalid type '$types{$type}{'type'}'\n"; + } + + print "}\n\n"; + } + +# Built-in types + +%types = ( + 'int' => { + 'type' => $type_integer, + 'ctype' => "int", + }, + + 'string' => { + 'type' => $type_string, + 'ctype' => "char *", + }, + ); + + + +sub create_function_block { + print "\n/* Auto-generated CFSML declaration and function block */\n\n"; + write_line_pp(__LINE__, 0); + print "#define CFSML_SUCCESS 0\n"; + print "#define CFSML_FAILURE 1\n\n"; + create_string_functions; + + foreach $n ( keys %types ) { + create_declaration($type = $n); + } + + foreach $n ( keys %types ) { + if (not $types{$n}->{'external'}) { + create_writer($type = $n); + create_reader($type = $n); + } + } + print "\n/* Auto-generated CFSML declaration and function block ends here */\n"; + print "/* Auto-generation performed by cfsml.pl $version */\n"; +} + + +# Gnerates code to read a data type +# Parameters: $type: Type to read +# $datap: Pointer to the write destination +# $fh: Existing filehandle of an open file to use +# $eofvar: Variable to store _cfsml_eof into +sub insert_reader_code { + print "/* Auto-generated CFSML data reader code */\n"; + write_line_pp(__LINE__, 0); + print " {\n"; + if (!$linecounter) { + write_line_pp(__LINE__, 0); + print " int _cfsml_line_ctr = 0;\n"; + $linecounter = '_cfsml_line_ctr'; + } + if ($atomic) { + write_line_pp(__LINE__, 0); + print " struct _cfsml_pointer_refstruct **_cfsml_myptrrefptr = _cfsml_get_current_refpointer();\n"; + } + write_line_pp(__LINE__, 0); + print " int _cfsml_eof = 0, _cfsml_error;\n"; + print " int dummy;\n"; + + if ($firsttoken) { + write_line_pp(__LINE__, 0); + print " const char *_cfsml_inp = $firsttoken;\n"; + } else { + write_line_pp(__LINE__, 0); + print " const char *_cfsml_inp =". + " _cfsml_get_identifier($fh, &($linecounter), &_cfsml_eof, &dummy);\n\n"; + } + + write_line_pp(__LINE__, 0); + print " _cfsml_error =". + " $types{$type}{'reader'}($fh, $datap, _cfsml_inp, &($linecounter), &_cfsml_eof);\n"; + + if ($eofvar) { + write_line_pp(__LINE__, 0); + print " $eofvar = _cfsml_error;\n"; + } + if ($atomic) { + write_line_pp(__LINE__, 0); + print " _cfsml_free_pointer_references(_cfsml_myptrrefptr, _cfsml_error);\n"; + } + write_line_pp(__LINE__, 0); + print " if (_cfsml_last_value_retrieved) {\n"; + print " free(_cfsml_last_value_retrieved);\n"; + print " _cfsml_last_value_retrieved = NULL;\n"; + print " }\n"; + print " if (_cfsml_last_identifier_retrieved) {\n"; + print " free(_cfsml_last_identifier_retrieved);\n"; + print " _cfsml_last_identifier_retrieved = NULL;\n"; + print " }\n"; + print " }\n"; + print "/* End of auto-generated CFSML data reader code */\n"; +} + +# Generates code to write a data type +# Parameters: $type: Type to write +# $datap: Pointer to the write destination +# $fh: Existing filehandle of an open file to use +sub insert_writer_code { + write_line_pp(__LINE__, 0); + print "/* Auto-generated CFSML data writer code */\n"; + print " $types{$type}{'writer'}($fh, $datap);\n"; + print " fprintf($fh, \"\\n\");\n"; + print "/* End of auto-generated CFSML data writer code */\n"; +} + + +################ +# Main program # +################ + +$parsing = 0; +$struct = undef; # Not working on a struct +$commentmode = undef; +$line = 0; + +while (<STDIN>) { + + $line++; + + if ($parsing) { + ($data) = split "#"; # Remove shell-style comments + @_ = ($data); + + s/\/\*.*\*\///g; # Remove C-style one-line comments + + ($data) = split "\/\/"; # Remove C++-style comments + @_ = ($data); + + if ($commentmode) { + + if (grep /\*\//, $_) { + ($empty, $_) = split /\*\//; + } else { + @_ = (); # Empty line + } + + } else { + if (grep /\/\*/, $_) { + $commentmode = 1; + ($_) = split /\/\*/; + } + } + + + # Now tokenize: + s/;//; + split /(\".*\"|[,\[\]\(\)\{\}])|\s+/; + + @items = @_; + + @tokens = (); + + $tokens_nr = 0; + for ($n = 0; $n < scalar @items; $n++) { # Get rid of all undefs + if ($_[$n]) { + $_ = $items[$n]; + s/\"//g; + $tokens[$tokens_nr++] = $_; + } + } + + # Now all tokens are in @tokens, and we have $tokens_nr of them. + +# print "//DEBUG: " . join ("|", @tokens) . "\n"; + + if ($tokens_nr) { + if ($tokens_nr == 2 && $tokens[0] eq "%END" && $tokens[1] eq "CFSML") { + + $struct && die "Record $struct needs closing braces in intput file (line $line)."; + + $parsing = 0; + create_function_block; + my $linep = $line + 1; + write_line_pp($linep, 1); + } elsif ($struct) { # Parsing struct + if ($tokens_nr == 1) { + if ($tokens[0] eq "}") { + $struct = undef; + } else { die "Invalid declaration of $token[0] in input file (line $line)\n";}; + } else { # Must be a member declaration + + my @structrecs = (@{$records{$struct}}); + my $newidx = (scalar @structrecs) or "0"; + my %member = (); + $member{'name'} = $tokens[1]; + $member{'type'} = $tokens[0]; + + if ($tokens_nr == 3 && $tokens[1] == "*") { + $tokens_nr = 2; + $member{'name'} = $tokens[2]; + $member{'reftype'} = $tokens[0]; + $member{'type'} = $type_abspointer; + } + + if ($tokens_nr == 4 and $tokens[0] eq $type_pointer) { # Relative pointer + + if (not $tokens[2] eq "RELATIVETO") { + die "Invalid relative pointer declaration in input file (line $line)\n"; + } + + $member{'anchor'} = $tokens[3]; # RelPointer anchor + + } else { # Non-pointer + + if (not $types{$tokens[0]}) { + die "Unknown type $tokens[0] used in input file (line $line)\n"; + } + + if ($tokens_nr > 2) { # Array + + if ($tokens[2] ne "[") { + die "Invalid token '$tokens[2]' in input file (line $line)\n"; + } + + $member{'array'} = "static"; + + if ($tokens[$tokens_nr - 1] ne "]") { + die "Array declaration incorrectly terminated in input file (line $line)\n"; + } + + $parsepos = 3; + + while ($parsepos < $tokens_nr) { + + if ($tokens[$parsepos] eq ",") { + + $parsepos++; + + } elsif ($tokens[$parsepos] eq "STATIC") { + + $member{'array'} = "static"; + $parsepos++; + + } elsif ($tokens[$parsepos] eq "DYNAMIC") { + + $member{'array'} = "dynamic"; + $parsepos++; + + } elsif ($tokens[$parsepos] eq "MAXWRITE") { + + $member{'maxwrite'} = $tokens[$parsepos + 1]; + $parsepos += 2; + + } elsif ($tokens[$parsepos] eq "]") { + + $parsepos++; + if ($parsepos != $tokens_nr) { + die "Error: Invalid tokens after array declaration in input file (line $line)\n"; + + } + } else { + + if ($member{'size'}) { + die "Attempt to use more than one array size in input file (line $line)\n" . + "(Original size was \"$member->{'size'}\", new size is \"$tokens[$parsepos]\"\n"; + } + + $member{'size'} = $tokens[$parsepos]; + $parsepos++; + } + } + + + unless ($member{'size'}) { + die "Array declaration without size in input file (line $line)\n"; + } + } + } + + @{$records{$struct}}->[$newidx] = \%member; + } + } else { # not parsing struct; normal operation. + + if ($tokens[0] eq "TYPE") { # Simple type declaration + + my $newtype = $tokens[1]; + + $types{$newtype}->{'ctype'} = $tokens[2]; + + if ($tokens_nr == 5) { # must be ...LIKE... + + unless ($tokens[3] eq "LIKE") { + die "Invalid TYPE declaration in input file (line $line)\n"; + } + + $types{$newtype}->{'type'} = $types{$tokens[4]}->{'type'}; + $types{$newtype}->{'reader'} = $types{$tokens[4]}->{'reader'}; + $types{$newtype}->{'writer'} = $types{$tokens[4]}->{'writer'}; + + } elsif ($tokens_nr == 6) { # must be ...USING... + + unless ($tokens[3] eq "USING") { + die "Invalid TYPE declaration in input file (line $line)\n"; + } + + $types{$newtype}->{'writer'} = $tokens[4]; + $types{$newtype}->{'reader'} = $tokens[5]; + $types{$newtype}->{'external'} = 'T'; + + } else { + die "Invalid TYPE declaration in input file (line $line)\n"; + } + + } elsif ($tokens[0] eq "RECORD") { + + $struct = $tokens[1]; + if ($types{$struct}) { + die "Attempt to re-define existing type $struct as a struct in input file (line $line)"; + } + $types{$struct}{'type'} = $type_record; + if ($tokens_nr < 3 or $tokens_nr > 6 or $tokens[$tokens_nr - 1] ne "{") { + die "Invalid record declaration in input file (line $line)"; + } + + my $extoffset = 2; + + if ($tokens_nr > 3) { + if ($tokens[2] ne "EXTENDS") { # Record declaration with explicit c type + $types{$struct}{'ctype'} = $tokens[2]; + $extoffset = 3; + } else { # Record name is the same as the c type name + $types{$struct}{'ctype'} = $struct; + } + } elsif ($tokens_nr == 3) { + $types{$struct}{'ctype'} = $struct; + } + + if (($tokens_nr > $extoffset + 1) && ($extoffset + 1 <= $tokens_nr)) { + if ($tokens[$extoffset] ne "EXTENDS") { + die "Invalid or improper keyword \"$tokens[$extoffset]\" in input file (line $line)"; + } + if ($extoffset + 2 >= $tokens_nr) { + die "RECORD \"$struct\" extends on unspecified type in input file (line $line)"; + } + my $ext_type = $tokens[$extoffset + 1]; + + if (!($types{$ext_type}{type} eq $type_record)) { + print "$types{$ext_type}{type}"; + die "RECORD \"$struct\" attempts to extend non-existing or non-record type \"$ext_type\" in input file (line $line)"; + } + + (@{$records{$struct}}) = (@{$records{$ext_type}}); # Copy type information from super type + } + + } else { + die "Invalid declaration \"$tokens[0]\" in line $line"; + } + } + } + + + } else { + + ($subtoken) = split ";"; # Get rid of trailing ;s + $tokens_nr = @tokens = split " ", $subtoken; + + if ($tokens_nr == 1 && $tokens[0] eq "%CFSML") { + + $parsing = 1; + + } elsif ($tokens[0] eq "%CFSMLWRITE" and $tokens[3] eq "INTO" and $tokens_nr >= 5) { + + insert_writer_code($type = $tokens[1], $datap = $tokens[2], $fh = $tokens[4]); + my $templine = $line + 1; + write_line_pp($templine, 1); # Yes, this sucks. + + } elsif (($tokens[0] eq "%CFSMLREAD") or ($tokens[0] eq "%CFSMLREAD-ATOMIC") and $tokens[3] eq "FROM" and $tokens_nr >= 5) { + + my $myeofvar = 0; + my $myfirsttoken = 0; + my $mylinecounter = 0; + + my $idcounter = 5; + + while ($idcounter < $tokens_nr) { + if ($tokens[$idcounter] eq "ERRVAR" and $tokens_nr >= $idcounter + 2) { + $myeofvar = $tokens[$idcounter + 1]; + $idcounter += 2; + } elsif ($tokens[$idcounter] eq "FIRSTTOKEN" and $tokens_nr >= $idcounter + 2) { + $myfirsttoken = $tokens[$idcounter + 1]; + $idcounter += 2; + } elsif ($tokens[$idcounter] eq "LINECOUNTER" and $tokens_nr >= $idcounter + 2) { + $mylinecounter = $tokens[$idcounter + 1]; + $idcounter += 2; + } else { + die "Unknown %CFSMLREAD operational token: $tokens[$idcounter]\n"; + } + } + insert_reader_code($type = $tokens[1], $datap = $tokens[2], + $fh = $tokens[4], $eofvar = $myeofvar, $firsttoken = $myfirsttoken, + $linecounter = $mylinecounter, $atomic = ($tokens[0] eq "%CFSMLREAD-ATOMIC")); + my $templine = $line + 1; + write_line_pp($templine, 1); # Yes, this sucks, too. + + } else { + print; + } + } + +} + +if ($parsing) { + print <STDERR>, "Warning: Missing %END CFSML\n"; +} diff --git a/engines/sci/engine/said.y b/engines/sci/engine/said.y new file mode 100644 index 0000000000..33c8401849 --- /dev/null +++ b/engines/sci/engine/said.y @@ -0,0 +1,948 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +%{ + +#include "sci/include/engine.h" + +#define SAID_BRANCH_NULL 0 + +#define MAX_SAID_TOKENS 128 + +/* Maximum number of words to be expected in a parsed sentence */ +#define AUGMENT_MAX_WORDS 64 + + +#define ANYWORD 0xfff + +#define WORD_TYPE_BASE 0x141 +#define WORD_TYPE_REF 0x144 +#define WORD_TYPE_SYNTACTIC_SUGAR 0x145 + +#define AUGMENT_SENTENCE_PART_BRACKETS 0x152 + +/* Minor numbers */ +#define AUGMENT_SENTENCE_MINOR_MATCH_PHRASE 0x14c +#define AUGMENT_SENTENCE_MINOR_MATCH_WORD 0x153 +#define AUGMENT_SENTENCE_MINOR_RECURSE 0x144 +#define AUGMENT_SENTENCE_MINOR_PARENTHESES 0x14f + + +#undef YYDEBUG /*1*/ +/*#define SAID_DEBUG*/ +/*#define SCI_DEBUG_PARSE_TREE_AUGMENTATION*/ /* uncomment to debug parse tree augmentation*/ + + +#ifdef SCI_DEBUG_PARSE_TREE_AUGMENTATION +#define scidprintf sciprintf +#else +#define scidprintf if (0) sciprintf +#endif + + +static char *said_parse_error; + +static int said_token; +static int said_tokens_nr; +static int said_tokens[MAX_SAID_TOKENS]; + +static int said_blessed; /* increminated by said_top_branch */ + +static int said_tree_pos; /* Set to 0 if we're out of space */ +#define SAID_TREE_START 4; /* Reserve space for the 4 top nodes */ + +#define VALUE_IGNORE -424242 + +static parse_tree_node_t said_tree[VOCAB_TREE_NODES]; + +typedef int wgroup_t; +typedef int tree_t; +typedef int said_spec_t; + +static tree_t +said_aug_branch(int, int, tree_t, tree_t); + +static tree_t +said_attach_branch(tree_t, tree_t); +/* +static tree_t +said_wgroup_branch(wgroup_t); +*/ +static said_spec_t +said_top_branch(tree_t); + +static tree_t +said_paren(tree_t, tree_t); + +static tree_t +said_value(int, tree_t); + +static tree_t +said_terminal(int); + + +static int +yylex(void); + +static int +yyerror(char *s) +{ + said_parse_error = sci_strdup(s); + return 1; /* Abort */ +} + +%} + +%token WGROUP /* Word group */ +%token YY_COMMA /* 0xf0 */ +%token YY_AMP /* 0xf1 */ +%token YY_SLASH /* 0xf2 */ +%token YY_PARENO /* 0xf3 */ +%token YY_PARENC /* 0xf4 */ +%token YY_BRACKETSO /* 0xf5 */ +%token YY_BRACKETSC /* 0xf6 */ +%token YY_HASH /* 0xf7 */ +%token YY_LT /* 0xf8 */ +%token YY_GT /* 0xf9 */ +%token YY_BRACKETSO_LT /* special token used to imitate LR(2) behaviour */ +%token YY_BRACKETSO_SLASH /* special token used to imitate LR(2) behaviour */ +%token YY_LT_BRACKETSO /* special token used to imitate LR(2) behaviour */ +%token YY_LT_PARENO /* special token used to imitate LR(2) behaviour */ + +%% + +saidspec : leftspec optcont + { $$ = said_top_branch(said_attach_branch($1, $2)); } + | leftspec midspec optcont + { $$ = said_top_branch(said_attach_branch($1, said_attach_branch($2, $3))); } + | leftspec midspec rightspec optcont + { $$ = said_top_branch(said_attach_branch($1, said_attach_branch($2, said_attach_branch($3, $4)))); } + ; + + +optcont : /* empty */ + { $$ = SAID_BRANCH_NULL; } + | YY_GT + { $$ = said_paren(said_value(0x14b, said_value(0xf900, said_terminal(0xf900))), SAID_BRANCH_NULL); } + ; + + + +leftspec : /* empty */ + { $$ = SAID_BRANCH_NULL; } + | expr + { $$ = said_paren(said_value(0x141, said_value(0x149, $1)), SAID_BRANCH_NULL); } + ; + + + +midspec : YY_SLASH expr + { $$ = said_aug_branch(0x142, 0x14a, $2, SAID_BRANCH_NULL); } + | YY_BRACKETSO_SLASH YY_SLASH expr YY_BRACKETSC + { $$ = said_aug_branch(0x152, 0x142, said_aug_branch(0x142, 0x14a, $3, SAID_BRANCH_NULL), SAID_BRANCH_NULL); } + | YY_SLASH + { $$ = SAID_BRANCH_NULL; } + ; + + + +rightspec : YY_SLASH expr + { $$ = said_aug_branch(0x143, 0x14a, $2, SAID_BRANCH_NULL); } + | YY_BRACKETSO_SLASH YY_SLASH expr YY_BRACKETSC + { $$ = said_aug_branch(0x152, 0x143, said_aug_branch(0x143, 0x14a, $3, SAID_BRANCH_NULL), SAID_BRANCH_NULL); } + | YY_SLASH + { $$ = SAID_BRANCH_NULL; } + ; + + + +word : WGROUP + { $$ = said_paren(said_value(0x141, said_value(0x153, said_terminal($1))), SAID_BRANCH_NULL); } + ; + + +cwordset : wordset + { $$ = said_aug_branch(0x141, 0x14f, $1, SAID_BRANCH_NULL); } + | YY_BRACKETSO wordset YY_BRACKETSC + { $$ = said_aug_branch(0x141, 0x14f, said_aug_branch(0x152, 0x14c, said_aug_branch(0x141, 0x14f, $2, SAID_BRANCH_NULL), SAID_BRANCH_NULL), SAID_BRANCH_NULL); } + ; + + +wordset : word + { $$ = $1; } + | YY_PARENO expr YY_PARENC + { $$ = $1; } + | wordset YY_COMMA wordset + { $$ = said_attach_branch($1, $3); } + | wordset YY_BRACKETSO_LT wordrefset YY_BRACKETSC + { $$ = said_attach_branch($1, $3); } + | wordset YY_COMMA YY_BRACKETSO wordset YY_BRACKETSC + { $$ = said_attach_branch($1, $3); } + ; + + + +expr : cwordset cwordrefset + { $$ = said_attach_branch($1, $2); } + | cwordset + { $$ = $1; } + | cwordrefset + { $$ = $1; } + ; + + + +cwordrefset : wordrefset + { $$ = $1; } + | YY_BRACKETSO_LT wordrefset YY_BRACKETSC + { $$ = said_aug_branch(0x152, 0x144, $2, SAID_BRANCH_NULL); } + | wordrefset YY_BRACKETSO_LT wordrefset YY_BRACKETSC + { $$ = said_attach_branch($1, said_aug_branch(0x152, 0x144, $3, SAID_BRANCH_NULL)); } + ; + + + +wordrefset : YY_LT word recref + { $$ = said_aug_branch(0x144, 0x14f, $2, $3); } + | YY_LT_PARENO YY_PARENO expr YY_PARENC + { $$ = said_aug_branch(0x144, 0x14f, said_aug_branch(0x141, 0x144, $2, SAID_BRANCH_NULL), SAID_BRANCH_NULL); } + | YY_LT wordset + { $$ = said_aug_branch(0x144, 0x14f, $2, SAID_BRANCH_NULL); } + | YY_LT_BRACKETSO YY_BRACKETSO wordset YY_BRACKETSC + { $$ = said_aug_branch(0x152, 0x144, said_aug_branch(0x144, 0x14f, $3, SAID_BRANCH_NULL), SAID_BRANCH_NULL); } + ; + + + +recref : YY_LT wordset recref + { $$ = said_aug_branch(0x141, 0x144, said_aug_branch(0x144, 0x14f, $2, SAID_BRANCH_NULL), $3); } + | YY_LT wordset + { $$ = said_aug_branch(0x141, 0x144, said_aug_branch(0x144, 0x14f, $2, SAID_BRANCH_NULL), SAID_BRANCH_NULL); } + | YY_LT_PARENO YY_PARENO expr YY_PARENC + { $$ = said_aug_branch(0x141, 0x14c, $2, SAID_BRANCH_NULL); } + ; + + + +%% + + +int +parse_yy_token_lookup[] = {YY_COMMA, YY_AMP, YY_SLASH, YY_PARENO, YY_PARENC, YY_BRACKETSO, YY_BRACKETSC, + YY_HASH, YY_LT, YY_GT}; + +static int +yylex(void) +{ + int retval = said_tokens[said_token++]; + + if (retval < SAID_LONG(SAID_FIRST)) { + yylval = retval; + retval = WGROUP; + } else { + retval >>= 8; + + if (retval == SAID_TERM) + retval = 0; + else { + assert(retval >= SAID_FIRST); + retval = parse_yy_token_lookup[retval - SAID_FIRST]; + if (retval == YY_BRACKETSO) { + if ((said_tokens[said_token] >> 8) == SAID_LT) + retval = YY_BRACKETSO_LT; + else + if ((said_tokens[said_token] >> 8) == SAID_SLASH) + retval = YY_BRACKETSO_SLASH; + } else if (retval == YY_LT && (said_tokens[said_token] >> 8) == SAID_BRACKO) { + retval = YY_LT_BRACKETSO; + } else if (retval == YY_LT && (said_tokens[said_token] >> 8) == SAID_PARENO) { + retval = YY_LT_PARENO; + } + } + } + + return retval; +} + +#define SAID_NEXT_NODE ((said_tree_pos == 0) || (said_tree_pos >= VOCAB_TREE_NODES))? said_tree_pos = 0 : said_tree_pos++ + +static inline int +said_leaf_node(tree_t pos, int value) +{ + said_tree[pos].type = PARSE_TREE_NODE_LEAF; + + if (value != VALUE_IGNORE) + said_tree[pos].content.value = value; + + return pos; +} + +static inline int +said_branch_node(tree_t pos, int left, int right) +{ + said_tree[pos].type = PARSE_TREE_NODE_BRANCH; + + if (left != VALUE_IGNORE) + said_tree[pos].content.branches[0] = left; + + if (right != VALUE_IGNORE) + said_tree[pos].content.branches[1] = right; + + return pos; +} + + +static tree_t +said_paren(tree_t t1, tree_t t2) +{ + if (t1) + return said_branch_node(SAID_NEXT_NODE, + t1, + t2 + ); + else + return t2; +} + +static tree_t +said_value(int val, tree_t t) +{ + return said_branch_node(SAID_NEXT_NODE, + said_leaf_node(SAID_NEXT_NODE, val), + t + ); + +} + +static tree_t +said_terminal(int val) +{ + return said_leaf_node(SAID_NEXT_NODE, val); +} + + +static tree_t +said_aug_branch(int n1, int n2, tree_t t1, tree_t t2) +{ + int retval; + + retval = said_branch_node(SAID_NEXT_NODE, + said_branch_node(SAID_NEXT_NODE, + said_leaf_node(SAID_NEXT_NODE, n1), + said_branch_node(SAID_NEXT_NODE, + said_leaf_node(SAID_NEXT_NODE, n2), + t1 + ) + ), + t2 + ); + +#ifdef SAID_DEBUG + fprintf(stderr,"AUG(0x%x, 0x%x, [%04x], [%04x]) = [%04x]\n", n1, n2, t1, t2, retval); +#endif + + return retval; +} + +static tree_t +said_attach_branch(tree_t base, tree_t attacheant) +{ +#ifdef SAID_DEBUG + fprintf(stderr,"ATT2([%04x], [%04x]) = [%04x]\n", base, attacheant, base); +#endif + + if (!attacheant) + return base; + if (!base) + return attacheant; + + if (!base) + return 0; /* Happens if we're out of space */ + + said_branch_node(base, VALUE_IGNORE, attacheant); + + return base; +} + +static said_spec_t +said_top_branch(tree_t first) +{ +#ifdef SAID_DEBUG + fprintf(stderr, "TOP([%04x])\n", first); +#endif + said_branch_node(0, 1, 2); + said_leaf_node(1, 0x141); /* Magic number #1 */ + said_branch_node(2, 3, first); + said_leaf_node(3, 0x13f); /* Magic number #2 */ + + ++said_blessed; + + return 0; +} + + +int +said_parse_spec(state_t *s, byte *spec) +{ + int nextitem; + + said_parse_error = NULL; + said_token = 0; + said_tokens_nr = 0; + said_blessed = 0; + + said_tree_pos = SAID_TREE_START; + + do { + nextitem = *spec++; + if (nextitem < SAID_FIRST) + said_tokens[said_tokens_nr++] = nextitem << 8 | *spec++; + else + said_tokens[said_tokens_nr++] = SAID_LONG(nextitem); + + } while ((nextitem != SAID_TERM) && (said_tokens_nr < MAX_SAID_TOKENS)); + + if (nextitem == SAID_TERM) + yyparse(); + else { + sciprintf("Error: SAID spec is too long\n"); + return 1; + } + + if (said_parse_error) { + sciprintf("Error while parsing SAID spec: %s\n", said_parse_error); + free(said_parse_error); + return 1; + } + + if (said_tree_pos == 0) { + sciprintf("Error: Out of tree space while parsing SAID spec\n"); + return 1; + } + + if (said_blessed != 1) { + sciprintf("Error: Found %d top branches\n"); + return 1; + } + + return 0; +} + +/**********************/ +/**** Augmentation ****/ +/**********************/ + + +/** primitive functions **/ + +#define AUG_READ_BRANCH(a, br, p) \ + if (tree[p].type != PARSE_TREE_NODE_BRANCH) \ + return 0; \ + a = tree[p].content.branches[br]; + +#define AUG_READ_VALUE(a, p) \ + if (tree[p].type != PARSE_TREE_NODE_LEAF) \ + return 0; \ + a = tree[p].content.value; + +#define AUG_ASSERT(i) \ + if (!i) return 0; + +static int +aug_get_next_sibling(parse_tree_node_t *tree, int pos, int *first, int *second) + /* Returns the next sibling relative to the specified position in 'tree', + ** sets *first and *second to its augment node values, returns the new position + ** or 0 if there was no next sibling + */ +{ + int seek, valpos; + + AUG_READ_BRANCH(pos, 1, pos); + AUG_ASSERT(pos); + AUG_READ_BRANCH(seek, 0, pos); + AUG_ASSERT(seek); + + /* Now retreive first value */ + AUG_READ_BRANCH(valpos, 0, seek); + AUG_ASSERT(valpos); + AUG_READ_VALUE(*first, valpos); + + /* Get second value */ + AUG_READ_BRANCH(seek, 1, seek); + AUG_ASSERT(seek); + AUG_READ_BRANCH(valpos, 0, seek); + AUG_ASSERT(valpos); + AUG_READ_VALUE(*second, valpos); + + return pos; +} + + +static int +aug_get_wgroup(parse_tree_node_t *tree, int pos) + /* Returns 0 if pos in tree is not the root of a 3-element list, otherwise + ** it returns the last element (which, in practice, is the word group + */ +{ + int val; + + AUG_READ_BRANCH(pos, 0, pos); + AUG_ASSERT(pos); + AUG_READ_BRANCH(pos, 1, pos); + AUG_ASSERT(pos); + AUG_READ_BRANCH(pos, 1, pos); + AUG_ASSERT(pos); + AUG_READ_VALUE(val, pos); + + return val; +} + + +static int +aug_get_base_node(parse_tree_node_t *tree) +{ + int startpos = 0; + AUG_READ_BRANCH(startpos, 1, startpos); + return startpos; +} + + +/** semi-primitive functions **/ + + +static int +aug_get_first_child(parse_tree_node_t *tree, int pos, int *first, int *second) + /* like aug_get_next_sibling, except that it recurses into the tree and + ** finds the first child (usually *not* Ayanami Rei) of the current branch + ** rather than its next sibling. + */ +{ + AUG_READ_BRANCH(pos, 0, pos); + AUG_ASSERT(pos); + AUG_READ_BRANCH(pos, 1, pos); + AUG_ASSERT(pos); + + return aug_get_next_sibling(tree, pos, first, second); +} + +static void +aug_find_words_recursively(parse_tree_node_t *tree, int startpos, + int *base_words, int *base_words_nr, + int *ref_words, int *ref_words_nr, + int maxwords, int refbranch) + /* Finds and lists all base (141) and reference (144) words */ +{ + int major, minor; + int word; + int pos = aug_get_first_child(tree, startpos, &major, &minor); + + /* if (major == WORD_TYPE_REF) + refbranch = 1;*/ + + while (pos) { + if ((word = aug_get_wgroup(tree, pos))) { /* found a word */ + + if (!refbranch && major == WORD_TYPE_BASE) { + if ((*base_words_nr) == maxwords) { + sciprintf("Out of regular words\n"); + return; /* return gracefully */ + } + + base_words[*base_words_nr] = word; /* register word */ + ++(*base_words_nr); + + } + if (major == WORD_TYPE_REF || refbranch) { + if ((*ref_words_nr) == maxwords) { + sciprintf("Out of reference words\n"); + return; /* return gracefully */ + } + + ref_words[*ref_words_nr] = word; /* register word */ + ++(*ref_words_nr); + + } + if (major != WORD_TYPE_SYNTACTIC_SUGAR && major != WORD_TYPE_BASE && major != WORD_TYPE_REF) + sciprintf("aug_find_words_recursively(): Unknown word type %03x\n", major); + + } else /* Did NOT find a word group: Attempt to recurse */ + aug_find_words_recursively(tree, pos, base_words, base_words_nr, + ref_words, ref_words_nr, maxwords, refbranch || major == WORD_TYPE_REF); + + pos = aug_get_next_sibling(tree, pos, &major, &minor); + } +} + + +static void +aug_find_words(parse_tree_node_t *tree, int startpos, + int *base_words, int *base_words_nr, + int *ref_words, int *ref_words_nr, + int maxwords) + /* initializing wrapper for aug_find_words_recursively() */ +{ + *base_words_nr = 0; + *ref_words_nr = 0; + + aug_find_words_recursively(tree, startpos, base_words, base_words_nr, ref_words, ref_words_nr, maxwords, 0); +} + + +static inline int +aug_contains_word(int *list, int length, int word) +{ + int i; + if (word == ANYWORD) + return (length); + + for (i = 0; i < length; i++) + if (list[i] == word) + return 1; + + return 0; +} + + +static int +augment_sentence_expression(parse_tree_node_t *saidt, int augment_pos, + parse_tree_node_t *parset, int parse_branch, + int major, int minor, + int *base_words, int base_words_nr, + int *ref_words, int ref_words_nr); + +static int +augment_match_expression_p(parse_tree_node_t *saidt, int augment_pos, + parse_tree_node_t *parset, int parse_basepos, + int major, int minor, + int *base_words, int base_words_nr, + int *ref_words, int ref_words_nr) +{ + int cmajor, cminor, cpos; + cpos = aug_get_first_child(saidt, augment_pos, &cmajor, &cminor); + if (!cpos) { + sciprintf("augment_match_expression_p(): Empty condition\n"); + return 1; + } + + scidprintf("Attempting to match (%03x %03x (%03x %03x\n", major, minor, cmajor, cminor); + + if ((major == WORD_TYPE_BASE) && (minor == AUGMENT_SENTENCE_MINOR_RECURSE)) + return augment_match_expression_p(saidt, cpos, + parset, parse_basepos, + cmajor, cminor, + base_words, base_words_nr, + ref_words, ref_words_nr); + + + switch (major) { + + case WORD_TYPE_BASE: + while (cpos) { + if (cminor == AUGMENT_SENTENCE_MINOR_MATCH_WORD) { + int word = aug_get_wgroup(saidt, cpos); + scidprintf("Looking for word %03x\n", word); + + if (aug_contains_word(base_words, base_words_nr, word)) + return 1; + } else if (cminor == AUGMENT_SENTENCE_MINOR_MATCH_PHRASE) { + if (augment_sentence_expression(saidt, cpos, + parset, parse_basepos, + cmajor, cminor, + base_words, base_words_nr, + ref_words, ref_words_nr)) + return 1; + } else if (cminor == AUGMENT_SENTENCE_MINOR_PARENTHESES) { + int gc_major, gc_minor; + int gchild = aug_get_first_child(saidt, cpos, &gc_major, &gc_minor); + + while (gchild) { + if (augment_match_expression_p(saidt, cpos, + parset, parse_basepos, + major, minor, + base_words, base_words_nr, + ref_words, ref_words_nr)) + return 1; + gchild = aug_get_next_sibling(saidt, gchild, &gc_major, &gc_minor); + } + } else + sciprintf("augment_match_expression_p(): Unknown type 141 minor number %3x\n", cminor); + + cpos = aug_get_next_sibling(saidt, cpos, &cmajor, &cminor); + + } + break; + + case WORD_TYPE_REF: + while (cpos) { + if (cminor == AUGMENT_SENTENCE_MINOR_MATCH_WORD) { + int word = aug_get_wgroup(saidt, cpos); + scidprintf("Looking for refword %03x\n", word); + + if (aug_contains_word(ref_words, ref_words_nr, word)) + return 1; + } else if (cminor == AUGMENT_SENTENCE_MINOR_MATCH_PHRASE) { + if (augment_match_expression_p(saidt, cpos, + parset, parse_basepos, + cmajor, cminor, + base_words, base_words_nr, + ref_words, ref_words_nr)) + return 1; + } else if (cminor == AUGMENT_SENTENCE_MINOR_PARENTHESES) { + int gc_major, gc_minor; + int gchild = aug_get_first_child(saidt, cpos, &gc_major, &gc_minor); + + while (gchild) { + if (augment_match_expression_p(saidt, cpos, + parset, parse_basepos, + major, minor, + base_words, base_words_nr, + ref_words, ref_words_nr)) + return 1; + gchild = aug_get_next_sibling(saidt, gchild, &gc_major, &gc_minor); + } + } else + sciprintf("augment_match_expression_p(): Unknown type 144 minor number %3x\n", cminor); + + cpos = aug_get_next_sibling(saidt, cpos, &cmajor, &cminor); + + } + break; + + case AUGMENT_SENTENCE_PART_BRACKETS: + if (augment_match_expression_p(saidt, cpos, + parset, parse_basepos, + cmajor, cminor, + base_words, base_words_nr, + ref_words, ref_words_nr)) + return 1; + + scidprintf("Didn't match subexpression; checking sub-bracked predicate %03x\n", cmajor); + + switch (cmajor) { + case WORD_TYPE_BASE: + if (!base_words_nr) + return 1; + break; + + case WORD_TYPE_REF: + if (!ref_words_nr) + return 1; + break; + + default: + sciprintf("augment_match_expression_p(): (subp1) Unkonwn sub-bracket predicate %03x\n", cmajor); + } + + break; + + default: + sciprintf("augment_match_expression_p(): Unknown predicate %03x\n", major); + + } + + scidprintf("Generic failure\n"); + return 0; +} + +static int +augment_sentence_expression(parse_tree_node_t *saidt, int augment_pos, + parse_tree_node_t *parset, int parse_branch, + int major, int minor, + int *base_words, int base_words_nr, + int *ref_words, int ref_words_nr) +{ + int check_major, check_minor; + int check_pos = aug_get_first_child(saidt, augment_pos, &check_major, &check_minor); + do { + if (!(augment_match_expression_p(saidt, check_pos, parset, parse_branch, + check_major, check_minor, base_words, base_words_nr, + ref_words, ref_words_nr))) + return 0; + } while ((check_pos = aug_get_next_sibling(saidt, check_pos, &check_major, &check_minor))); + return 1; +} + + + +static int +augment_sentence_part(parse_tree_node_t *saidt, int augment_pos, + parse_tree_node_t *parset, int parse_basepos, + int major, int minor) +{ + int pmajor, pminor; + int parse_branch = parse_basepos; + int optional = 0; + int foundwords = 0; + + scidprintf("Augmenting (%03x %03x\n", major, minor); + + if (major == AUGMENT_SENTENCE_PART_BRACKETS) { /* '[/ foo]' is true if '/foo' or if there + ** exists no x for which '/x' is true + */ + if ((augment_pos = aug_get_first_child(saidt, augment_pos, &major, &minor))) { + scidprintf("Optional part: Now augmenting (%03x %03x\n", major, minor); + optional = 1; + } else { + scidprintf("Matched empty optional expression\n"); + return 1; + } + } + + if ((major < 0x141) + || (major > 0x143)) { + scidprintf("augment_sentence_part(): Unexpected sentence part major number %03x\n", major); + return 0; + } + + while ((parse_branch = aug_get_next_sibling(parset, parse_branch, &pmajor, &pminor))) + if (pmajor == major) { /* found matching sentence part */ + int success; + int base_words_nr; + int ref_words_nr; + int base_words[AUGMENT_MAX_WORDS]; + int ref_words[AUGMENT_MAX_WORDS]; +#ifdef SCI_DEBUG_PARSE_TREE_AUGMENTATION + int i; +#endif + + scidprintf("Found match with pminor = %03x\n", pminor); + aug_find_words(parset, parse_branch, base_words, &base_words_nr, + ref_words, &ref_words_nr, AUGMENT_MAX_WORDS); + foundwords |= (ref_words_nr | base_words_nr); +#ifdef SCI_DEBUG_PARSE_TREE_AUGMENTATION + sciprintf("%d base words:", base_words_nr); + for (i = 0; i < base_words_nr; i++) + sciprintf(" %03x", base_words[i]); + sciprintf("\n%d reference words:", ref_words_nr); + for (i = 0; i < ref_words_nr; i++) + sciprintf(" %03x", ref_words[i]); + sciprintf("\n"); +#endif + + success = augment_sentence_expression(saidt, augment_pos, + parset, parse_basepos, major, minor, + base_words, base_words_nr, + ref_words, ref_words_nr); + + if (success) { + scidprintf("SUCCESS on augmenting (%03x %03x\n", major, minor); + return 1; + } + } + + if (optional && (foundwords == 0)) { + scidprintf("Found no words and optional branch => SUCCESS on augmenting (%03x %03x\n", major, minor); + return 1; + } + scidprintf("FAILURE on augmenting (%03x %03x\n", major, minor); + return 0; +} + +static int +augment_parse_nodes(parse_tree_node_t *parset, parse_tree_node_t *saidt) +{ + int augment_basepos = 0; + int parse_basepos; + int major, minor; + int dontclaim = 0; + + parse_basepos = aug_get_base_node(parset); + if (!parse_basepos) { + sciprintf("augment_parse_nodes(): Parse tree is corrupt\n"); + return 0; + } + + augment_basepos = aug_get_base_node(saidt); + if (!augment_basepos) { + sciprintf("augment_parse_nodes(): Said tree is corrupt\n"); + return 0; + } + while ((augment_basepos = aug_get_next_sibling(saidt, augment_basepos, &major, &minor))) { + + if ((major == 0x14b) + && (minor == SAID_LONG(SAID_GT))) + dontclaim = 1; /* special case */ + else /* normal sentence part */ + if (!(augment_sentence_part(saidt, augment_basepos, parset, parse_basepos, major, minor))) { + scidprintf("Returning failure\n"); + return 0; /* fail */ + } + } + + scidprintf("Returning success with dontclaim=%d\n", dontclaim); + + if (dontclaim) + return SAID_PARTIAL_MATCH; + else return 1; /* full match */ +} + + +/*******************/ +/**** Main code ****/ +/*******************/ + +int +said(state_t *s, byte *spec, int verbose) +{ + int retval; + + parse_tree_node_t *parse_tree_ptr = s->parser_nodes; + + if (s->parser_valid) { + + if (said_parse_spec(s, spec)) { + sciprintf("Offending spec was: "); + vocab_decypher_said_block(s, spec); + return SAID_NO_MATCH; + } + + if (verbose) + vocab_dump_parse_tree("Said-tree", said_tree); /* Nothing better to do yet */ + retval = augment_parse_nodes(parse_tree_ptr, &(said_tree[0])); + + if (!retval) + return SAID_NO_MATCH; + else if (retval != SAID_PARTIAL_MATCH) + return SAID_FULL_MATCH; + else return SAID_PARTIAL_MATCH; + } + + return SAID_NO_MATCH; +} + + + +#ifdef SAID_DEBUG_PROGRAM +int +main (int argc, char *argv) +{ + byte block[] = {0x01, 0x00, 0xf8, 0xf5, 0x02, 0x01, 0xf6, 0xf2, 0x02, 0x01, 0xf2, 0x01, 0x03, 0xff}; + state_t s; + con_passthrough = 1; + + s.parser_valid = 1; + said(&s, block); +} +#endif diff --git a/engines/sci/engine/savegame.cfsml b/engines/sci/engine/savegame.cfsml new file mode 100644 index 0000000000..321d79fcb9 --- /dev/null +++ b/engines/sci/engine/savegame.cfsml @@ -0,0 +1,1150 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +/* Savegame handling for state_t structs. Makes heavy use of cfsml magic. */ +/* DON'T EDIT savegame.c ! Only modify savegame.cfsml, if something needs +** to be changed. Refer to freesci/docs/misc/cfsml.spec if you don't understand +** savegame.cfsml. If this doesn't solve your problem, contact the maintainer. +*/ + +#include "sci/include/sci_memory.h" +#include "sci/include/gfx_operations.h" +#include "sci/include/sfx_engine.h" +#include "sci/include/engine.h" +#include "sci/engine/heap.h" + +#ifdef _MSC_VER +#include <direct.h> +#endif + +#ifdef _WIN32 +#pragma warning( disable : 4101 ) +#endif + +#define HUNK_TYPE_GFX_SNAPSHOT_STRING "g\n" + +/* Missing: +** - SFXdriver +** - File input/output state (this is likely not to happen) +*/ + +static state_t *_global_save_state; +/* Needed for some graphical stuff. */ +#define FILE_VERSION _global_save_state->savegame_version + + +void +write_reg_t(FILE *fh, reg_t *foo) { + fprintf(fh, PREG, PRINT_REG(*foo)); +} + +int +read_reg_t(FILE *fh, reg_t *foo, const char *lastval, int *line, int *hiteof) { + int segment, offset; + + if (sscanf(lastval, PREG, &segment, &offset)<2) { + sciprintf("Error parsing reg_t on line %d\n", *line); + return 1; + } + + *foo = make_reg(segment, offset); + return 0; +} + +void +write_sci_version(FILE *fh, sci_version_t *foo) { + fprintf(fh, "%d.%03d.%03d", SCI_VERSION_MAJOR(*foo), SCI_VERSION_MINOR(*foo), + SCI_VERSION_PATCHLEVEL(*foo)); +} + +int +read_sci_version(FILE *fh, sci_version_t *foo, const char *lastval, int *line, int *hiteof) { + return version_parse(lastval, foo); +} + +void +write_PTN(FILE *fh, parse_tree_node_t *foo) { + if (foo->type == PARSE_TREE_NODE_LEAF) + fprintf(fh, "L%d", foo->content.value); + else + fprintf(fh, "B(%d,%d)", foo->content.branches[0], foo->content.branches[1]); +} + +int +read_PTN(FILE *fh, parse_tree_node_t *foo, const char *lastval, int *line, int *hiteof) { + if (lastval[0] == 'L') { + const char *c = lastval + 1; + char *strend; + + while (*c && isspace(*c)) + ++c; + + if (!*c) + return 1; + + foo->content.value = strtol(c, &strend, 0); + + return (strend == c); /* Error if nothing could be read */ + + return 0; + } else if (lastval[0] == 'B') { + const char *c = lastval + 1; + char *strend; + + while (*c && isspace(*c)) ++c; + if (*c++ != '(') return 1; + while (*c && isspace(*c)) ++c; + + foo->content.branches[0] = strtol(c, &strend, 0); + if (strend == c) + return 1; + c = strend; + + while (*c && isspace(*c)) ++c; + if (*c++ != ',') + return 1; + + while (*c && isspace(*c)) ++c; + + foo->content.branches[1] = strtol(c, &strend, 0); + if (strend == c) + return 1; + c = strend; + + while (*c && isspace(*c)) ++c; + if (*c++ != ')') return 1; + + return 0; + } else return 1; /* failure to parse anything */ +} + + +void +write_menubar_tp(FILE *fh, menubar_t **foo); +int +read_menubar_tp(FILE *fh, menubar_t **foo, const char *lastval, int *line, int *hiteof); + +void +write_mem_obj_tp(FILE *fh, mem_obj_t **foo); +int +read_mem_obj_tp(FILE *fh, mem_obj_t **foo, const char *lastval, int *line, int *hiteof); + +void +write_int_hash_map_tp(FILE *fh, int_hash_map_t **foo); +int +read_int_hash_map_tp(FILE *fh, int_hash_map_t **foo, const char *lastval, int *line, int *hiteof); + +void +write_songlib_t(FILE *fh, songlib_t *foo); +int +read_songlib_t(FILE *fh, songlib_t *foo, const char *lastval, int *line, int *hiteof); + +void +write_int_hash_map_node_tp(FILE *fh, int_hash_map_t::node_t **foo); +int +read_int_hash_map_node_tp(FILE *fh, int_hash_map_t::node_t **foo, const char *lastval, int *line, int *hiteof); + +int +read_song_tp(FILE *fh, song_t **foo, const char *lastval, int *line, int *hiteof); + +typedef mem_obj_t *mem_obj_ptr; + +%CFSML + +TYPE byte "byte" LIKE int; +TYPE long "long" LIKE int; +TYPE gint16 "gint16" LIKE int; +TYPE seg_id_t "seg_id_t" LIKE int; +TYPE sci_version_t "sci_version_t" USING write_sci_version read_sci_version; +TYPE menubar_tp "menubar_t *" USING write_menubar_tp read_menubar_tp; +TYPE mem_obj_t "mem_obj_t" USING write_mem_obj_t read_mem_obj_t; +TYPE mem_obj_ptr "mem_obj_t *" USING write_mem_obj_tp read_mem_obj_tp; +TYPE reg_t "reg_t" USING write_reg_t read_reg_t; +TYPE size_t "size_t" LIKE int; +TYPE int_hash_map_tp "int_hash_map_t *" USING write_int_hash_map_tp read_int_hash_map_tp; +TYPE int_hash_map_node_tp "int_hash_map_t::node_t *" USING write_int_hash_map_node_tp read_int_hash_map_node_tp; +TYPE songlib_t "songlib_t" USING write_songlib_t read_songlib_t; +TYPE song_tp "song_t *" USING write_song_tp read_song_tp; +TYPE song_iterator_t "song_iterator_t" USING write_song_iterator_t read_song_iterator_t; +TYPE song_handle_t "song_handle_t" LIKE int; + +RECORD song_t "song_t" { + song_handle_t handle; + int resource_num; + int priority; + int status; + int restore_behavior; + int restore_time; + int loops; + int hold; +} + +RECORD int_hash_map_t "int_hash_map_t" { + int base_value; + int_hash_map_node_tp nodes[STATIC DCS_INT_HASH_MAX+1]; +} + +RECORD menu_item_t "menu_item_t" { + int type; + string keytext; + int keytext_size; + + int flags; + byte said[STATIC MENU_SAID_SPEC_SIZE]; + reg_t said_pos; + string text; + reg_t text_pos; + int modifiers; + int key; + int enabled; + int tag; +} + +RECORD menu_t "menu_t" { + string title; + int title_width; + int width; + + menu_item_t items[DYNAMIC items_nr]; +} + +RECORD menubar_t "menubar_t" { + menu_t menus[DYNAMIC menus_nr]; +} + +RECORD synonym_t "synonym_t" { + int replaceant; + int replacement; +} + + +RECORD seg_manager_t "seg_manager_t" { + int_hash_map_tp id_seg_map; + mem_obj_ptr heap[DYNAMIC heap_size]; + int heap_size; + int reserved_id; + int exports_wide; + int sci1_1; + int gc_mark_bits; + size_t mem_allocated; + seg_id_t clones_seg_id; + seg_id_t lists_seg_id; + seg_id_t nodes_seg_id; +} + +RECORD class_t "class_t" { + int script; + reg_t reg; +} + +RECORD sfx_state_t "sfx_state_t" { + songlib_t songlib; +} + +RECORD state_t "state_t" { + int savegame_version; + + string game_version; + sci_version_t version; + menubar_tp menubar; + int status_bar_foreground; + int status_bar_background; + seg_manager_t seg_manager; + int classtable_size; + class_t classtable[DYNAMIC classtable_size]; + sfx_state_t sound; +} + +RECORD local_variables_t "local_variables_t" { + int script_id; + int nr; + reg_t locals[DYNAMIC nr]; +} + +RECORD object_t "object_t" { + int flags; + reg_t pos; + int variables_nr; + int variable_names_nr; + int methods_nr; + reg_t variables[DYNAMIC variables_nr]; +} + +RECORD clone_t "clone_t" { + int flags; + reg_t pos; + int variables_nr; + int variable_names_nr; + int methods_nr; + reg_t variables[DYNAMIC variables_nr]; +} + +RECORD list_t "list_t" { + reg_t first; + reg_t last; +} + +RECORD node_t "node_t" { + reg_t pred; + reg_t succ; + reg_t key; + reg_t value; +} + +RECORD clone_entry_t "clone_entry_t" { + int next_free; + clone_t entry; +} + +RECORD clone_table_t "clone_table_t" { + int entries_nr; + int first_free; + int entries_used; + int max_entry; + clone_entry_t table[DYNAMIC entries_nr]; +} + +RECORD list_entry_t "list_entry_t" { + int next_free; + list_t entry; +} + +RECORD list_table_t "list_table_t" { + int entries_nr; + int first_free; + int entries_used; + int max_entry; + list_entry_t table[DYNAMIC entries_nr]; +} + +RECORD node_entry_t "node_entry_t" { + int next_free; + node_t entry; +} + +RECORD node_table_t "node_table_t" { + int entries_nr; + int first_free; + int entries_used; + int max_entry; + node_entry_t table[DYNAMIC entries_nr]; +} + +RECORD script_t "script_t" { + int nr; + + size_t buf_size; + size_t script_size; + size_t heap_size; + + int_hash_map_tp obj_indices; + int exports_nr; + int synonyms_nr; + int lockers; + int objects_allocated; + int objects_nr; + object_t objects[DYNAMIC objects_allocated]; + + int locals_offset; + int locals_segment; + + int marked_as_deleted; +} + +RECORD sys_string_t "sys_string_t" { + string name; + int max_size; + string value; +} + +RECORD sys_strings_t "sys_strings_t" { + sys_string_t strings[STATIC SYS_STRINGS_MAX]; +} + +RECORD dynmem_t "dynmem_t" { + int size; + string description; + byte buf[DYNAMIC size]; +} + +%END CFSML + +void +write_songlib_t(FILE *fh, songlib_t *songlib) { + song_t *seeker = *(songlib->lib); + int songcount = song_lib_count(*songlib); + + fprintf(fh, "{\n"); + fprintf(fh, "songcount = %d\n", songcount); + fprintf(fh, "list = \n"); + fprintf(fh, "[\n"); + while (seeker) { + seeker->restore_time = seeker->it->get_timepos(seeker->it); + %CFSMLWRITE song_t seeker INTO fh; + seeker = seeker->next; + } + fprintf(fh, "]\n"); + fprintf(fh, "}\n"); +} + +int read_songlib_t(FILE *fh, songlib_t *songlib, const char *lastval, int *line, int *hiteof) { + int songcount; + int i; + song_t *newsong; + int oldstatus; + + fscanf(fh, "{\n"); + fscanf(fh, "songcount = %d\n", &songcount); + fscanf(fh, "list = \n"); + fscanf(fh, "[\n"); + *line += 4; + song_lib_init(songlib); + for (i = 0; i < songcount; i++) { + %CFSMLREAD song_tp &newsong FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line; + song_lib_add(*songlib, newsong); + } + fscanf(fh, "]\n"); + fscanf(fh, "}\n");; + *line += 2; + return 0; +} + +struct { + int type; + const char *name; +} mem_obj_string_names[] = { + {MEM_OBJ_INVALID, "INVALID"}, + {MEM_OBJ_SCRIPT, "SCRIPT"}, + {MEM_OBJ_CLONES, "CLONES"}, + {MEM_OBJ_LOCALS, "LOCALS"}, + {MEM_OBJ_STACK, "STACK"}, + {MEM_OBJ_SYS_STRINGS,"SYS_STRINGS"}, + {MEM_OBJ_LISTS,"LISTS"}, + {MEM_OBJ_NODES,"NODES"}, + {MEM_OBJ_HUNK,"HUNK"}, + {MEM_OBJ_DYNMEM,"DYNMEM"}}; + +int mem_obj_string_to_enum(const char *str) { + int i; + + for (i = 0; i <= MEM_OBJ_MAX; i++) { + if (!scumm_stricmp(mem_obj_string_names[i].name, str)) + return i; + } + + return -1; +} + +static int bucket_length; + +void write_int_hash_map_tp(FILE *fh, int_hash_map_t **foo) { + %CFSMLWRITE int_hash_map_t *foo INTO fh; +} + +void write_song_tp(FILE *fh, song_t **foo) { + %CFSMLWRITE song_t *foo INTO fh; +} + +song_iterator_t *build_iterator(state_t *s, int song_nr, int type, songit_id_t id); + +int read_song_tp(FILE *fh, song_t **foo, const char *lastval, int *line, int *hiteof) { + char *token; + int assignment; + *foo = (song_t*) malloc(sizeof(song_t)); + token = _cfsml_get_identifier(fh, line, hiteof, &assignment); + %CFSMLREAD song_t (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN token LINECOUNTER *line; + (*foo)->delay = 0; + (*foo)->it = NULL; + (*foo)->next_playing = (*foo)->next_stopping = (*foo)->next = NULL; + return 0; +} +int +read_int_hash_map_tp(FILE *fh, int_hash_map_t **foo, const char *lastval, int *line, int *hiteof) { + *foo = (int_hash_map_t*)malloc(sizeof(int_hash_map_t)); + %CFSMLREAD int_hash_map_t (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line; + (*foo)->holes = NULL; + return 0; +} + +void +write_int_hash_map_node_tp(FILE *fh, int_hash_map_t::node_t **foo) { + if (!(*foo)) { + fputs("\\null", fh); + } else { + fprintf(fh,"[\n%d=>%d\n", (*foo)->name, (*foo)->value); + if ((*foo)->next) { + %CFSMLWRITE int_hash_map_node_tp &((*foo)->next) INTO fh; + } else fputc('L', fh); + fputs("]", fh); + } +} + +int +read_int_hash_map_node_tp(FILE *fh, int_hash_map_t::node_t **foo, const char *lastval, int *line, int *hiteof) { + static char buffer[80]; + + if (lastval[0] == '\\') { + *foo = NULL; /* No hash map node */ + } else { + *foo = (int_hash_map_t::node_t*)malloc(sizeof(int_hash_map_t::node_t)); + if (lastval[0] != '[') { + sciprintf("Expected opening bracket in hash_map_node_t on line %d\n", *line); + return 1; + } + + do { + (*line)++; + fgets(buffer, 80, fh); + if (buffer[0] == 'L') { + (*foo)->next = NULL; + buffer[0] = buffer[1]; + } /* HACK: deliberately no else clause here */ + if (buffer[0] == ']') { + break; + } + else if (buffer[0] == '[') { + if (read_int_hash_map_node_tp(fh, &((*foo)->next), buffer, line, hiteof)) + return 1; + } + else if (sscanf(buffer, "%d=>%d", &((*foo)->name), &((*foo)->value))<2) { + sciprintf("Error parsing hash_map_node_t on line %d\n", *line); + return 1; + } + } while (1); + } + + return 0; +} + +void +write_menubar_tp(FILE *fh, menubar_t **foo) { + if (*foo) { + + %CFSMLWRITE menubar_t (*foo) INTO fh; + + } else { /* Nothing to write */ + fputs("\\null\\", fh); + } +} + + +int +read_menubar_tp(FILE *fh, menubar_t **foo, const char *lastval, int *line, int *hiteof) { + + if (lastval[0] == '\\') { + *foo = NULL; /* No menu bar */ + } else { + + *foo = (menubar_t *) sci_malloc(sizeof(menubar_t)); + %CFSMLREAD menubar_t (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line; + + } + return *hiteof; +} + +void +write_mem_obj_t(FILE *fh, mem_obj_t *foo) { + fprintf(fh, "%s\n", mem_obj_string_names[foo->type].name); + %CFSMLWRITE int &foo->segmgr_id INTO fh; + switch (foo->type) { + case MEM_OBJ_SCRIPT: + %CFSMLWRITE script_t &foo->data.script INTO fh; + break; + case MEM_OBJ_CLONES: + %CFSMLWRITE clone_table_t &foo->data.clones INTO fh; + break; + case MEM_OBJ_LOCALS: + %CFSMLWRITE local_variables_t &foo->data.locals INTO fh; + break; + case MEM_OBJ_SYS_STRINGS: + %CFSMLWRITE sys_strings_t &foo->data.sys_strings INTO fh; + break; + case MEM_OBJ_STACK: + %CFSMLWRITE int &foo->data.stack.nr INTO fh; + break; + case MEM_OBJ_HUNK: + break; + case MEM_OBJ_LISTS: + %CFSMLWRITE list_table_t &foo->data.lists INTO fh; + break; + case MEM_OBJ_NODES: + %CFSMLWRITE node_table_t &foo->data.nodes INTO fh; + break; + case MEM_OBJ_DYNMEM: + %CFSMLWRITE dynmem_t &foo->data.dynmem INTO fh; + break; + } +} + +int +read_mem_obj_t(FILE *fh, mem_obj_t *foo, const char *lastval, int *line, int *hiteof) { + char buffer[80]; + foo->type = mem_obj_string_to_enum(lastval); + if (foo->type < 0) { + sciprintf("Unknown mem_obj_t type %s on line %d\n", lastval, *line); + return 1; + } + + %CFSMLREAD int &foo->segmgr_id FROM fh ERRVAR *hiteof LINECOUNTER *line; + switch (foo->type) { + case MEM_OBJ_SCRIPT: + %CFSMLREAD script_t &foo->data.script FROM fh ERRVAR *hiteof LINECOUNTER *line; + break; + case MEM_OBJ_CLONES: + %CFSMLREAD clone_table_t &foo->data.clones FROM fh ERRVAR *hiteof LINECOUNTER *line; + break; + case MEM_OBJ_LOCALS: + %CFSMLREAD local_variables_t &foo->data.locals FROM fh ERRVAR *hiteof LINECOUNTER *line; + break; + case MEM_OBJ_SYS_STRINGS: + %CFSMLREAD sys_strings_t &foo->data.sys_strings FROM fh ERRVAR *hiteof LINECOUNTER *line; + break; + case MEM_OBJ_LISTS: + %CFSMLREAD list_table_t &foo->data.lists FROM fh ERRVAR *hiteof LINECOUNTER *line; + break; + case MEM_OBJ_NODES: + %CFSMLREAD node_table_t &foo->data.nodes FROM fh ERRVAR *hiteof LINECOUNTER *line; + break; + case MEM_OBJ_STACK: + %CFSMLREAD int &foo->data.stack.nr FROM fh ERRVAR *hiteof LINECOUNTER *line; + foo->data.stack.entries = (reg_t *)sci_calloc(foo->data.stack.nr, sizeof(reg_t)); + break; + case MEM_OBJ_HUNK: + init_hunk_table(&foo->data.hunks); + break; + case MEM_OBJ_DYNMEM: + %CFSMLREAD dynmem_t &foo->data.dynmem FROM fh ERRVAR *hiteof LINECOUNTER *line; + break; + } + + return *hiteof; +} + +void +write_mem_obj_tp(FILE *fh, mem_obj_t **foo) { + if (*foo) { + + %CFSMLWRITE mem_obj_t (*foo) INTO fh; + + } else { /* Nothing to write */ + fputs("\\null\\", fh); + } +} + +int +read_mem_obj_tp(FILE *fh, mem_obj_t **foo, const char *lastval, int *line, int *hiteof) { + + if (lastval[0] == '\\') { + *foo = NULL; /* No menu bar */ + } else { + *foo = (mem_obj_t *) sci_malloc(sizeof(mem_obj_t)); + %CFSMLREAD mem_obj_t (*foo) FROM fh ERRVAR *hiteof FIRSTTOKEN lastval LINECOUNTER *line; + return *hiteof; + } + return 0; +} + + + +/* This function is called to undo some strange stuff done in preparation +** to writing a gamestate to disk +*/ +void +_gamestate_unfrob(state_t *s) { +} + + +int +gamestate_save(state_t *s, char *dirname) { + FILE *fh; + sci_dir_t dir; + char *filename; + int fd; + + _global_save_state = s; + s->savegame_version = FREESCI_CURRENT_SAVEGAME_VERSION; + s->dyn_views_list_serial = (s->dyn_views)? s->dyn_views->serial : -2; + s->drop_views_list_serial = (s->drop_views)? s->drop_views->serial : -2; + s->port_serial = (s->port)? s->port->serial : -2; + + if (s->execution_stack_base) { + sciprintf("Cannot save from below kernel function\n"); + return 1; + } + + scimkdir (dirname, 0700); + + if (chdir(dirname)) { + sciprintf("Could not enter directory '%s'\n", dirname); + return 1; + } + + sci_init_dir(&dir); + filename = sci_find_first(&dir, "*"); + while (filename) { + if (strcmp(filename, "..") && strcmp(filename, ".")) + unlink(filename); /* Delete all files in directory */ + filename = sci_find_next(&dir); + } + sci_finish_find(&dir); + +/* + if (s->sound_server) { + if ((s->sound_server->save)(s, dirname)) { + sciprintf("Saving failed for the sound subsystem\n"); + chdir(".."); + return 1; + } + } +*/ + fh = fopen("state", "w" FO_TEXT); + + /* Calculate the time spent with this game */ + s->game_time = time(NULL) - s->game_start_time.tv_sec; + +SCI_MEMTEST; + %CFSMLWRITE state_t s INTO fh; +SCI_MEMTEST; + + fclose(fh); + + _gamestate_unfrob(s); + + + chdir(".."); + return 0; +} + +static seg_id_t +find_unique_seg_by_type(seg_manager_t *self, int type) { + int i; + + for (i = 0; i < self->heap_size; i++) + if (self->heap[i] && + self->heap[i]->type == type) + return i; + return -1; +} + +static byte * +find_unique_script_block(state_t *s, byte *buf, int type) { + int magic_pos_adder = s->version >= SCI_VERSION_FTU_NEW_SCRIPT_HEADER ? 0 : 2; + + buf += magic_pos_adder; + do { + int seeker_type = getUInt16(buf); + int seeker_size; + + if (seeker_type == 0) break; + if (seeker_type == type) return buf; + + seeker_size = getUInt16(buf + 2); + buf += seeker_size; + } while(1); + + return NULL; +} + +static +void reconstruct_stack(state_t *retval) { + seg_id_t stack_seg = find_unique_seg_by_type(&retval->seg_manager, MEM_OBJ_STACK); + dstack_t *stack = &(retval->seg_manager.heap[stack_seg]->data.stack); + + retval->stack_segment = stack_seg; + retval->stack_base = stack->entries; + retval->stack_top = retval->stack_base + VM_STACK_SIZE; +} + +static +int clone_entry_used(clone_table_t *table, int n) { + int backup; + int seeker = table->first_free; + clone_entry_t *entries = table->table; + + if (seeker == HEAPENTRY_INVALID) return 1; + + do { + if (seeker == n) return 0; + backup = seeker; + seeker = entries[seeker].next_free; + } while (entries[backup].next_free != HEAPENTRY_INVALID); + + return 1; +} + +static +void load_script(state_t *s, seg_id_t seg) { + resource_t *script, *heap = NULL; + script_t *scr = &(s->seg_manager.heap[seg]->data.script); + + scr->buf = (byte *) malloc(scr->buf_size); + + script = scir_find_resource(s->resmgr, sci_script, scr->nr, 0); + if (s->version >= SCI_VERSION(1,001,000)) + heap = scir_find_resource(s->resmgr, sci_heap, scr->nr, 0); + + switch (s->seg_manager.sci1_1) { + case 0 : + sm_mcpy_in_out( &s->seg_manager, 0, script->data, script->size, seg, SEG_ID); + break; + case 1 : + sm_mcpy_in_out( &s->seg_manager, 0, script->data, script->size, seg, SEG_ID); + sm_mcpy_in_out( &s->seg_manager, scr->script_size, heap->data, heap->size, seg, SEG_ID); + break; + } +} + +static +void reconstruct_scripts(state_t *s, seg_manager_t *self) { + int i; + mem_obj_t *mobj; + object_t **objects; + int *objects_nr; + for (i = 0; i < self->heap_size; i++) + if (self->heap[i]) { + mobj = self->heap[i]; + switch (mobj->type) { + case MEM_OBJ_SCRIPT: { + int j; + script_t *scr = &mobj->data.script; + + load_script(s, i); + scr->locals_block = scr->locals_segment == 0 ? NULL : + &s->seg_manager.heap[scr->locals_segment]->data.locals; + scr->export_table = (guint16 *) find_unique_script_block(s, scr->buf, sci_obj_exports); + scr->synonyms = find_unique_script_block(s, scr->buf, sci_obj_synonyms); + scr->code = NULL; + scr->code_blocks_nr = 0; + scr->code_blocks_allocated = 0; + + if (!self->sci1_1) + scr->export_table += 3; + + for (j = 0; j < scr->objects_nr; j++) { + byte *data = scr->buf + scr->objects[j].pos.offset; + scr->objects[j].base = scr->buf; + scr->objects[j].base_obj = data; + } + + } + } + } + + for (i = 0; i < self->heap_size; i++) + if (self->heap[i]) { + mobj = self->heap[i]; + switch (mobj->type) { + case MEM_OBJ_SCRIPT: { + int j; + script_t *scr = &mobj->data.script; + + for (j = 0; j < scr->objects_nr; j++) { + byte *data = scr->buf + scr->objects[j].pos.offset; + + if (self->sci1_1) { + guint16 *funct_area = (guint16 *) (scr->buf + getUInt16( data + 6 )); + guint16 *prop_area = (guint16 *) (scr->buf + getUInt16( data + 4 )); + + scr->objects[j].base_method = funct_area; + scr->objects[j].base_vars = prop_area; + } else { + int funct_area = getUInt16( data + SCRIPT_FUNCTAREAPTR_OFFSET ); + object_t *base_obj; + + base_obj = obj_get(s, scr->objects[j].variables[SCRIPT_SPECIES_SELECTOR]); + + if (!base_obj) { + sciprintf("Object without a base class: Script %d, index %d (reg address "PREG"\n", + scr->nr, j, PRINT_REG(scr->objects[j].variables[SCRIPT_SPECIES_SELECTOR])); + continue; + } + scr->objects[j].variable_names_nr = base_obj->variables_nr; + scr->objects[j].base_obj = base_obj->base_obj; + + scr->objects[j].base_method = (guint16 *) (data + funct_area); + scr->objects[j].base_vars = (guint16 *) (data + scr->objects[j].variable_names_nr * 2 + SCRIPT_SELECTOR_OFFSET); + } + } + } + } + } +} + +void +reconstruct_clones(state_t *s, seg_manager_t *self) { + int i; + mem_obj_t *mobj; + + for (i = 0; i < self->heap_size; i++) + if (self->heap[i]) { + mobj = self->heap[i]; + switch (mobj->type) { + case MEM_OBJ_CLONES: { + int j; + clone_entry_t *seeker = mobj->data.clones.table; + + sciprintf("Free list: "); + for (j = mobj->data.clones.first_free; + j != HEAPENTRY_INVALID; + j = mobj->data.clones.table[j].next_free) { + sciprintf("%d ", j); + } + sciprintf("\n"); + + sciprintf("Entries w/zero vars: "); + for (j = 0; j < mobj->data.clones.max_entry; j++) { + if (mobj->data.clones.table[j].entry.variables == NULL) + sciprintf("%d ", j); + } + sciprintf("\n"); + + for (j = 0; j < mobj->data.clones.max_entry; j++) { + object_t *base_obj; + + if (!clone_entry_used(&mobj->data.clones, j)) { + seeker++; + continue; + } + base_obj = obj_get(s, seeker->entry.variables[SCRIPT_SPECIES_SELECTOR]); + if (!base_obj) { + sciprintf("Clone entry without a base class: %d\n", j); + seeker->entry.base = seeker->entry.base_obj = NULL; + seeker->entry.base_vars = seeker->entry.base_method = NULL; + continue; + } + seeker->entry.base = base_obj->base; + seeker->entry.base_obj = base_obj->base_obj; + seeker->entry.base_vars = base_obj->base_vars; + seeker->entry.base_method = base_obj->base_method; + + seeker++; + } + + break; + } + } + } +} + +int +_reset_graphics_input(state_t *s); + +song_iterator_t * +new_fast_forward_iterator(song_iterator_t *it, int delta); + +static +void reconstruct_sounds(state_t *s) { + song_t *seeker; + int it_type = s->resmgr->sci_version >= SCI_VERSION_01 ? + SCI_SONG_ITERATOR_TYPE_SCI1 + : SCI_SONG_ITERATOR_TYPE_SCI0; + + if (s->sound.songlib.lib) + seeker = *(s->sound.songlib.lib); + else { + song_lib_init(&s->sound.songlib); + seeker = NULL; + } + while (seeker) { + song_iterator_t *base, *ff; + int oldstatus; + song_iterator_message_t msg; + + base = ff = build_iterator(s, seeker->resource_num, it_type, seeker->handle); + if (seeker->restore_behavior == RESTORE_BEHAVIOR_CONTINUE) + ff = (song_iterator_t *) new_fast_forward_iterator(base, seeker->restore_time); + ff->init(ff); + + msg = songit_make_message(seeker->handle, SIMSG_SET_LOOPS(seeker->loops)); + songit_handle_message(&ff, msg); + msg = songit_make_message(seeker->handle, SIMSG_SET_HOLD(seeker->hold)); + songit_handle_message(&ff, msg); + + + oldstatus = seeker->status; + seeker->status = SOUND_STATUS_STOPPED; + seeker->it = ff; + sfx_song_set_status(&s->sound, seeker->handle, oldstatus); + seeker = seeker->next; + } + +} + +state_t * +gamestate_restore(state_t *s, char *dirname) { + FILE *fh; + int fd; + int i; + int read_eof = 0; + state_t *retval; + songlib_t temp; + + if (chdir(dirname)) { + sciprintf("Game state '%s' does not exist\n", dirname); + return NULL; + } + +/* + if (s->sound_server) { + if ((s->sound_server->restore)(s, dirname)) { + sciprintf("Restoring failed for the sound subsystem\n"); + return NULL; + } + } +*/ + + retval = (state_t *) sci_malloc(sizeof(state_t)); + + memset(retval, 0, sizeof(state_t)); + + retval->savegame_version = -1; + _global_save_state = retval; + retval->gfx_state = s->gfx_state; + + fh = fopen("state", "r" FO_TEXT); + if (!fh) { + free(retval); + return NULL; + } + + /* Backwards compatibility settings */ + retval->dyn_views = NULL; + retval->drop_views = NULL; + retval->port = NULL; + retval->save_dir_copy_buf = NULL; + + retval->sound_mute = s->sound_mute; + retval->sound_volume = s->sound_volume; + + %CFSMLREAD-ATOMIC state_t retval FROM fh ERRVAR read_eof; + + fclose(fh); + + if ((retval->savegame_version < FREESCI_MINIMUM_SAVEGAME_VERSION) || + (retval->savegame_version > FREESCI_CURRENT_SAVEGAME_VERSION)) { + + if (retval->savegame_version < FREESCI_MINIMUM_SAVEGAME_VERSION) + sciprintf("Old savegame version detected- can't load\n"); + else + sciprintf("Savegame version is %d- maximum supported is %0d\n", retval->savegame_version, FREESCI_CURRENT_SAVEGAME_VERSION); + + chdir(".."); + free(retval); + return NULL; + } + + sfx_exit(&s->sound); + _gamestate_unfrob(retval); + + /* Set exec stack base to zero */ + retval->execution_stack_base = 0; + retval->execution_stack_pos = 0; + + /* Now copy all current state information */ + /* Graphics and input state: */ + retval->animation_delay = s->animation_delay; + retval->animation_granularity = s->animation_granularity; + retval->gfx_state = s->gfx_state; + + retval->resmgr = s->resmgr; + + temp = retval->sound.songlib; + sfx_init(&retval->sound, retval->resmgr, s->sfx_init_flags); + retval->sfx_init_flags = s->sfx_init_flags; + song_lib_free(retval->sound.songlib); + retval->sound.songlib = temp; + + _reset_graphics_input(retval); + reconstruct_stack(retval); + reconstruct_scripts(retval, &retval->seg_manager); + reconstruct_clones(retval, &retval->seg_manager); + retval->game_obj = s->game_obj; + retval->script_000 = &retval->seg_manager.heap[script_get_segment(s, 0, SCRIPT_GET_DONT_LOAD)]->data.script; + retval->gc_countdown = GC_INTERVAL - 1; + retval->save_dir_copy = make_reg(s->sys_strings_segment, SYS_STRING_SAVEDIR); + retval->save_dir_edit_offset = 0; + retval->sys_strings_segment = find_unique_seg_by_type(&retval->seg_manager, MEM_OBJ_SYS_STRINGS); + retval->sys_strings = &(((mem_obj_t *)(GET_SEGMENT(retval->seg_manager, retval->sys_strings_segment, MEM_OBJ_SYS_STRINGS)))->data.sys_strings); + sys_strings_restore(retval->sys_strings, s->sys_strings); + + /* Time state: */ + sci_get_current_time(&(retval->last_wait_time)); + retval->game_start_time.tv_sec = time(NULL) - retval->game_time; + retval->game_start_time.tv_usec = 0; + + /* File IO state: */ + retval->file_handles_nr = 2; + retval->file_handles = (FILE **)sci_calloc(2, sizeof(FILE *)); + + /* static parser information: */ + retval->parser_rules = s->parser_rules; + retval->parser_words_nr = s->parser_words_nr; + retval->parser_words = s->parser_words; + retval->parser_suffices_nr = s->parser_suffices_nr; + retval->parser_suffices = s->parser_suffices; + retval->parser_branches_nr = s->parser_branches_nr; + retval->parser_branches = s->parser_branches; + + /* static VM/Kernel information: */ + retval->selector_names_nr = s->selector_names_nr; + retval->selector_names = s->selector_names; + retval->kernel_names_nr = s->kernel_names_nr; + retval->kernel_names = s->kernel_names; + retval->kfunct_table = s->kfunct_table; + retval->kfunct_nr = s->kfunct_nr; + retval->opcodes = s->opcodes; + + memcpy(&(retval->selector_map), &(s->selector_map), sizeof(selector_map_t)); + + retval->max_version = retval->version; + retval->min_version = retval->version; + retval->parser_base = make_reg(s->sys_strings_segment, SYS_STRING_PARSER_BASE); + + /* Copy breakpoint information from current game instance */ + retval->have_bp = s->have_bp; + retval->bp_list = s->bp_list; + + retval->debug_mode = s->debug_mode; + + retval->resource_dir = s->resource_dir; + retval->work_dir = s->work_dir; + retval->kernel_opt_flags = 0; + retval->have_mouse_flag = s->have_mouse_flag; + + retval->successor = NULL; + retval->pic_priority_table = (int*)gfxop_get_pic_metainfo(retval->gfx_state); + retval->game_name = sci_strdup(obj_get_name(retval, retval->game_obj)); + + retval->sound.it = NULL; + retval->sound.flags = s->sound.flags; + retval->sound.song = NULL; + retval->sound.suspended = s->sound.suspended; + retval->sound.debug = s->sound.debug; + reconstruct_sounds(retval); + + chdir (".."); + + return retval; +} |