void
OpenJournal (void)
{
DWORD start_seed;
#if CREATE_JOURNAL
if (create_journal)
{
if (journal_fh = copen (journal_buf, MEMORY_STREAM, STREAM_WRITE))
{
start_seed = SeedRandomNumbers ();
cwrite ((PBYTE)&start_seed, sizeof (start_seed), 1, journal_fh);
}
}
else
#endif /* CREATE_JOURNAL */
{
uio_Stream *fp;
if (fp = res_OpenResFile ("starcon.jnl", "rb"))
{
ReadResFile (journal_buf, 1, sizeof (journal_buf), fp);
res_CloseResFile (fp);
if (journal_fh = copen (journal_buf, MEMORY_STREAM, STREAM_READ))
{
OldArrowInput = ArrowInput;
ArrowInput = DemoInput;
PlayerInput[0] = PlayerInput[1] = DemoInput;
FlushInput ();
cread ((PBYTE)&start_seed, sizeof (start_seed), 1, journal_fh);
TFB_SeedRandom (start_seed);
}
}
}
}
void Lexer::lex() {
// Use the read to fetch the values.
// loop on each char, and add the found
// symbols to the end of queue.
char c = _stream->read();
switch (c) {
case '#':
lcomment();
break;
case ' ':
case '\t':
case '\n':
case '\r':
case '\f':
case '\b':
space();
break;
//string
case '"':
case '`':
case '\'':
string();
break;
case '~':
character();
break;
//compound.
case '[':
case '(':
case '{':
copen();
break;
case ']':
case ')':
case '}':
cclose();
break;
case 0:
_has = false;
break;
default: // word fetch until the next space.
if (c >= 32 && c <= 126)
word();
}
}
bool SIFLoader::LoadHeader(const char *filename)
{
CFILE *fp;
uint32_t magick;
ClearIndex();
if (fFP) cclose(fFP);
fp = fFP = copen(filename, "rb");
if (!fp)
{
NX_ERR("SIFLoader::LoadHeader: failed to open file '%s'\n", filename);
return 1;
}
if ((magick = cgetl(fp)) != SIF_MAGICK)
{
NX_ERR("SIFLoader::LoadHeader: magick check failed--this isn't a SIF file or is wrong version?\n");
NX_ERR(" (expected %08x, got %08x)\n", SIF_MAGICK, magick);
return 1;
}
int nsections = cgetc(fp);
NX_LOG("SIFLoader::LoadHeader: read index of %d sections\n", nsections);
for(int i=0;i<nsections;i++)
{
SIFIndexEntry *entry = new SIFIndexEntry;
entry->type = cgetc(fp); // section type
entry->foffset = cgetl(fp); // absolute offset in file
entry->length = cgetl(fp); // length of section data
entry->data = NULL; // we won't load it until asked
fIndex.AddItem(entry);
//NX_LOG(" - Sect%02d @ %04x\n", entry->type, entry->foffset);
}
// ..leave file handle open, its ok
return 0;
}
static void
run(svsem_t *sem, int n, int verbose)
{
int i, rst;
char buf[255];
for (i = 0; i < n; i++) {
sprintf(buf, "/tmp/file.%d", i);
svsem_wait(sem);
if (copen(buf, O_CREAT, 0600, &rst) == -1) {
MMSG("");
} else if (verbose) {
printf("%d %d: %d %s\n", getpid(), i, rst, buf);
}
usleep(100);
}
}
int
openat32(int fd, char *path, int fmode, int cmode)
{
return (copen(fd, path, OPENMODE32(fmode), cmode));
}
int
creat32(char *fname, int cmode)
{
return (copen(AT_FDCWD, fname, CREATMODE32, cmode));
}
/*
* Open and Creat for 32-bit compatibility on 64-bit kernel
*/
int
open32(char *fname, int fmode, int cmode)
{
return (copen(AT_FDCWD, fname, OPENMODE32(fmode), cmode));
}
int
creat64(char *fname, int cmode)
{
return (copen(AT_FDCWD, fname, CREATMODE64, cmode));
}
int main(int argc, char **argv)
{
cfile out_cfh, ref_cfh, ver_cfh;
int out_fh;
int optr;
char *src_file = NULL;
char *trg_file = NULL;
char *patch_name = NULL;
unsigned long patch_id = 0;
signed long encode_result=0;
int err;
unsigned long sample_rate=0;
unsigned long seed_len = 0;
unsigned long hash_size = 0;
// unsigned int patch_compressor = 0;
unsigned int patch_to_stdout = 0;
#define DUMP_USAGE(exit_code) \
print_usage("differ", "src_file trg_file [patch_file|or to stdout]", help_opts, exit_code);
while((optr = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
switch(optr) {
case OVERSION:
print_version("differ"); exit(0);
case OUSAGE:
case OHELP:
DUMP_USAGE(0);
case OVERBOSE:
global_verbosity++; break;
case OSAMPLE:
sample_rate = atol(optarg);
if(sample_rate == 0 || sample_rate > MAX_SAMPLE_RATE) DUMP_USAGE(EXIT_USAGE);
break;
case OSEED:
seed_len = atol(optarg);
if(seed_len == 0 || seed_len > MAX_SEED_LEN) DUMP_USAGE(EXIT_USAGE);
break;
case OHASH:
hash_size = atol(optarg);
if(hash_size == 0 || hash_size > MAX_HASH_SIZE) DUMP_USAGE(EXIT_USAGE);
break;
case OSTDOUT:
patch_to_stdout = 1; break;
case 'f':
patch_format = optarg; break;
default:
v0printf("invalid arg- %s\n", argv[optind]);
DUMP_USAGE(EXIT_USAGE);
}
}
err = 0;
if( ((src_file = (char *)get_next_arg(argc,argv)) == NULL) ||
(err = copen(&ref_cfh, src_file, NO_COMPRESSOR, CFILE_RONLY)) != 0) {
if(src_file) {
if(err == MEM_ERROR) {
v0printf("alloc failure for src_file\n");
} else {
v0printf("Must specify an existing source file.\n");
}
exit(EXIT_USAGE);
}
DUMP_USAGE(EXIT_USAGE);
}
err = 0;
if( ((trg_file=(char *)get_next_arg(argc, argv)) == NULL) ||
(err = copen(&ver_cfh, trg_file, NO_COMPRESSOR, CFILE_RONLY)) != 0) {
if(trg_file) {
if(err == MEM_ERROR) {
v0printf("alloc failure for trg_file\n");
} else {
v0printf("Must specify an existing target file.\n");
}
exit(EXIT_USAGE);
}
DUMP_USAGE(EXIT_USAGE);
}
if(patch_to_stdout != 0) {
out_fh = 1;
} else {
if((patch_name = (char *)get_next_arg(argc, argv)) == NULL)
DUMP_USAGE(EXIT_USAGE);
if((out_fh = open(patch_name, O_WRONLY | O_TRUNC | O_CREAT, 0644))==-1) {
v0printf( "error creating patch file '%s' (open failed)\n", patch_name);
exit(1);
}
}
if (NULL!=get_next_arg(argc, argv)) {
DUMP_USAGE(EXIT_USAGE);
}
if(patch_format==NULL) {
patch_id = DEFAULT_PATCH_ID;
} else {
patch_id = check_for_format(patch_format, strlen(patch_format));
if(patch_id==0) {
v0printf( "Unknown format '%s'\n", patch_format);
exit(EXIT_FAILURE);
}
}
if(copen_dup_fd(&out_cfh, out_fh, 0, 0, NO_COMPRESSOR /* patch_compressor */, CFILE_WONLY)) {
v0printf("error allocing needed memory for output, exiting\n");
exit(EXIT_FAILURE);
}
v1printf("using patch format %lu\n", patch_id);
v1printf("using seed_len(%lu), sample_rate(%lu), hash_size(%lu)\n",
seed_len, sample_rate, hash_size);
v1printf("verbosity level(%u)\n", global_verbosity);
v1printf("initializing Command Buffer...\n");
encode_result = simple_difference(&ref_cfh, &ver_cfh, &out_cfh, patch_id, seed_len, sample_rate, hash_size);
v1printf("flushing and closing out file\n");
cclose(&out_cfh);
close(out_fh);
if(err) {
if(! patch_to_stdout) {
unlink(patch_name);
}
}
v1printf("encode_result=%ld\n", encode_result);
v1printf("exiting\n");
v1printf("closing reference file\n");
cclose(&ref_cfh);
v1printf("closing version file\n");
cclose(&ver_cfh);
close(out_fh);
check_return2(encode_result, "encoding result was nonzero")
return 0;
}
BOOLEAN
LoadGame (COUNT which_game, SUMMARY_DESC *SummPtr)
{
uio_Stream *in_fp;
char file[PATH_MAX];
char buf[256];
SUMMARY_DESC loc_sd;
GAME_STATE_FILE *fp;
DECODE_REF fh;
COUNT num_links;
STAR_DESC SD;
ACTIVITY Activity;
sprintf (file, "starcon2.%02u", which_game);
in_fp = res_OpenResFile (saveDir, file, "rb");
if (!in_fp)
return FALSE;
if (!LoadSummary (&loc_sd, in_fp))
{
log_add (log_Error, "Warning: Savegame is corrupt");
res_CloseResFile (in_fp);
return FALSE;
}
if (!SummPtr)
{
SummPtr = &loc_sd;
}
else
{ // only need summary for displaying to user
memcpy (SummPtr, &loc_sd, sizeof (*SummPtr));
res_CloseResFile (in_fp);
return TRUE;
}
// Crude check for big-endian/little-endian incompatibilities.
// year_index is suitable as it's a multi-byte value within
// a specific recognisable range.
if (SummPtr->year_index < START_YEAR ||
SummPtr->year_index >= START_YEAR +
YEARS_TO_KOHRAH_VICTORY + 1 /* Utwig intervention */ +
1 /* time to destroy all races, plenty */ +
25 /* for cheaters */)
{
log_add (log_Error, "Warning: Savegame corrupt or from "
"an incompatible platform.");
res_CloseResFile (in_fp);
return FALSE;
}
GlobData.SIS_state = SummPtr->SS;
if ((fh = copen (in_fp, FILE_STREAM, STREAM_READ)) == 0)
{
res_CloseResFile (in_fp);
return FALSE;
}
ReinitQueue (&GLOBAL (GameClock.event_q));
ReinitQueue (&GLOBAL (encounter_q));
ReinitQueue (&GLOBAL (ip_group_q));
ReinitQueue (&GLOBAL (npc_built_ship_q));
ReinitQueue (&GLOBAL (built_ship_q));
memset (&GLOBAL (GameState[0]), 0, sizeof (GLOBAL (GameState)));
Activity = GLOBAL (CurrentActivity);
LoadGameState (&GlobData.Game_state, fh);
NextActivity = GLOBAL (CurrentActivity);
GLOBAL (CurrentActivity) = Activity;
LoadRaceQueue (fh, &GLOBAL (avail_race_q));
// START_INTERPLANETARY is only set when saving from Homeworld
// encounter screen. When the game is loaded, the
// GenerateOrbitalFunction for the current star system will
// create the encounter anew and populate the npc queue.
if (!(NextActivity & START_INTERPLANETARY))
{
if (NextActivity & START_ENCOUNTER)
LoadShipQueue (fh, &GLOBAL (npc_built_ship_q));
else if (LOBYTE (NextActivity) == IN_INTERPLANETARY)
// XXX: Technically, this queue does not need to be
// saved/loaded at all. IP groups will be reloaded
// from group state files. But the original code did,
// and so will we until we can prove we do not need to.
LoadGroupQueue (fh, &GLOBAL (ip_group_q));
else
// XXX: The empty queue read is only needed to maintain
// the savegame compatibility
LoadEmptyQueue (fh);
}
LoadShipQueue (fh, &GLOBAL (built_ship_q));
// Load the game events (compressed)
cread_16 (fh, &num_links);
{
#ifdef DEBUG_LOAD
log_add (log_Debug, "EVENTS:");
#endif /* DEBUG_LOAD */
while (num_links--)
{
HEVENT hEvent;
EVENT *EventPtr;
hEvent = AllocEvent ();
LockEvent (hEvent, &EventPtr);
LoadEvent (EventPtr, fh);
#ifdef DEBUG_LOAD
log_add (log_Debug, "\t%u/%u/%u -- %u",
EventPtr->month_index,
EventPtr->day_index,
EventPtr->year_index,
EventPtr->func_index);
#endif /* DEBUG_LOAD */
UnlockEvent (hEvent);
PutEvent (hEvent);
}
}
// Load the encounters (black globes in HS/QS (compressed))
cread_16 (fh, &num_links);
{
while (num_links--)
{
HENCOUNTER hEncounter;
ENCOUNTER *EncounterPtr;
hEncounter = AllocEncounter ();
LockEncounter (hEncounter, &EncounterPtr);
LoadEncounter (EncounterPtr, fh);
UnlockEncounter (hEncounter);
PutEncounter (hEncounter);
}
}
// Copy the star info file from the compressed stream
fp = OpenStateFile (STARINFO_FILE, "wb");
if (fp)
{
DWORD flen;
cread_32 (fh, &flen);
while (flen)
{
COUNT num_bytes;
num_bytes = flen >= sizeof (buf) ? sizeof (buf) : (COUNT)flen;
cread (buf, num_bytes, 1, fh);
WriteStateFile (buf, num_bytes, 1, fp);
flen -= num_bytes;
}
CloseStateFile (fp);
}
// Copy the defined groupinfo file from the compressed stream
fp = OpenStateFile (DEFGRPINFO_FILE, "wb");
if (fp)
{
DWORD flen;
cread_32 (fh, &flen);
while (flen)
{
COUNT num_bytes;
num_bytes = flen >= sizeof (buf) ? sizeof (buf) : (COUNT)flen;
cread (buf, num_bytes, 1, fh);
WriteStateFile (buf, num_bytes, 1, fp);
flen -= num_bytes;
}
CloseStateFile (fp);
}
// Copy the random groupinfo file from the compressed stream
fp = OpenStateFile (RANDGRPINFO_FILE, "wb");
if (fp)
{
DWORD flen;
cread_32 (fh, &flen);
while (flen)
{
COUNT num_bytes;
num_bytes = flen >= sizeof (buf) ? sizeof (buf) : (COUNT)flen;
cread (buf, num_bytes, 1, fh);
WriteStateFile (buf, num_bytes, 1, fp);
flen -= num_bytes;
}
CloseStateFile (fp);
}
LoadStarDesc (&SD, fh);
cclose (fh);
res_CloseResFile (in_fp);
EncounterGroup = 0;
EncounterRace = -1;
ReinitQueue (&race_q[0]);
ReinitQueue (&race_q[1]);
CurStarDescPtr = FindStar (NULL, &SD.star_pt, 0, 0);
if (!(NextActivity & START_ENCOUNTER)
&& LOBYTE (NextActivity) == IN_INTERPLANETARY)
NextActivity |= START_INTERPLANETARY;
return TRUE;
}
