quakeforge/tools/qfcc/source/qfprogs.c

276 lines
5.2 KiB
C
Raw Normal View History

/*
#FILENAME#
#DESCRIPTION#
Copyright (C) 2001 #AUTHOR#
Author: #AUTHOR#
Date: #DATE#
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:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
static __attribute__ ((unused)) const char rcsid[] =
"$Id$";
#include <getopt.h>
#include <stdlib.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef HAVE_IO_H
# include <io.h>
#endif
#include <string.h>
#include <getopt.h>
#include <sys/types.h>
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#else
# include <sys/fcntl.h>
#endif
2002-08-09 04:06:17 +00:00
#include <sys/stat.h>
#include <fcntl.h>
#include "QF/cmd.h"
#include "QF/cvar.h"
#include "QF/hash.h"
#include "QF/pr_comp.h"
#include "QF/progs.h"
#include "QF/quakeio.h"
#include "QF/sys.h"
#include "QF/va.h"
#include "QF/zone.h"
#include "qfprogs.h"
2003-04-23 20:10:51 +00:00
int sorted = 0;
int verbosity = 0;
static const struct option long_options[] = {
{"disassemble", no_argument, 0, 'd'},
{"globals", no_argument, 0, 'g'},
{"strings", no_argument, 0, 's'},
2002-06-09 16:28:19 +00:00
{"fields", no_argument, 0, 'f'},
{"functions", no_argument, 0, 'F'},
2002-09-07 06:47:16 +00:00
{"lines", no_argument, 0, 'l'},
{"modules", no_argument, 0, 'M'},
{"path", required_argument, 0, 'P'},
2002-10-16 17:31:15 +00:00
{"verbose", no_argument, 0, 'v'},
2003-04-23 20:10:51 +00:00
{"numeric", no_argument, 0, 'n'},
{NULL, 0, NULL, 0},
};
static edict_t *edicts;
static int num_edicts;
static int reserved_edicts = 1;
static progs_t pr;
static void *membase;
static int memsize = 1024*1024;
static const char *source_path = "";
2002-10-16 17:31:15 +00:00
static hashtab_t *func_tab;
static QFile *
2002-06-11 17:24:37 +00:00
open_file (const char *path, int *len)
{
QFile *file = Qopen (path, "rbz");
2002-06-11 17:24:37 +00:00
if (!file)
2002-06-11 17:24:37 +00:00
return 0;
*len = Qfilesize (file);
return file;
2002-06-11 17:24:37 +00:00
}
static void
file_error (progs_t *pr, const char *name)
{
perror (name);
}
2002-06-11 17:24:37 +00:00
static void *
load_file (progs_t *pr, const char *name)
{
QFile *file;
2002-06-11 17:24:37 +00:00
int size;
void *sym;
file = open_file (name, &size);
if (!file) {
file = open_file (va ("%s.gz", name), &size);
if (!file)
return 0;
2002-06-11 17:24:37 +00:00
}
sym = malloc (size);
Qread (file, sym, size);
return sym;
}
static void *
allocate_progs_mem (progs_t *pr, int size)
{
return malloc (size);
}
static void
free_progs_mem (progs_t *pr, void *mem)
{
free (mem);
}
static unsigned long
func_hash (void *func, void *unused)
{
return ((dfunction_t *) func)->first_statement;
}
static int
func_compare (void *f1, void *f2, void *unused)
{
return ((dfunction_t *) f1)->first_statement
== ((dfunction_t *) f2)->first_statement;
}
dfunction_t *
func_find (int st_ofs)
{
dfunction_t f;
f.first_statement = st_ofs;
return Hash_FindElement (func_tab, &f);
}
static void
init_qf (void)
{
Cvar_Init_Hash ();
Cmd_Init_Hash ();
Cvar_Init ();
Sys_Init_Cvars ();
Cmd_Init ();
membase = malloc (memsize);
Memory_Init (membase, memsize);
2002-10-16 17:31:15 +00:00
Cvar_Get ("pr_debug", va ("%d", verbosity), 0, 0, "");
Cvar_Get ("pr_source_path", source_path, 0, 0, "");
PR_Init_Cvars ();
PR_Init ();
pr.edicts = &edicts;
pr.num_edicts = &num_edicts;
pr.reserved_edicts = &reserved_edicts;
pr.file_error = file_error;
2002-06-11 17:24:37 +00:00
pr.load_file = load_file;
pr.allocate_progs_mem = allocate_progs_mem;
pr.free_progs_mem = free_progs_mem;
func_tab = Hash_NewTable (1021, 0, 0, 0);
Hash_SetHashCompare (func_tab, func_hash, func_compare);
}
static int
load_progs (const char *name)
{
QFile *file;
int i, size;
file = open_file (name, &size);
if (!file) {
perror (name);
return 0;
}
Hash_FlushTable (func_tab);
pr.progs_name = name;
PR_LoadProgsFile (&pr, file, size, 1, 0);
Qclose (file);
if (!pr.progs)
return 0;
PR_LoadStrings (&pr);
for (i = 0; i < pr.progs->numfunctions; i++) {
if (pr.pr_functions[i].first_statement > 0)// don't bother with builtins
Hash_AddElement (func_tab, &pr.pr_functions[i]);
}
2002-06-11 17:24:37 +00:00
PR_LoadDebug (&pr);
return 1;
}
int
main (int argc, char **argv)
{
int c;
void (*func)(progs_t *pr) = dump_globals;
while ((c = getopt_long (argc, argv,
2003-04-23 20:10:51 +00:00
"dgsfFlMP:vn", long_options, 0)) != EOF) {
switch (c) {
case 'd':
func = disassemble_progs;
break;
case 'g':
func = dump_globals;
break;
case 's':
func = dump_strings;
break;
2002-06-09 16:28:19 +00:00
case 'f':
func = dump_fields;
break;
case 'F':
func = dump_functions;
break;
2002-09-07 06:47:16 +00:00
case 'l':
func = dump_lines;
break;
case 'M':
func = dump_modules;
break;
case 'P':
source_path = strdup (optarg);
2003-03-13 17:31:01 +00:00
break;
2002-10-16 17:31:15 +00:00
case 'v':
verbosity++;
break;
2003-04-23 20:10:51 +00:00
case 'n':
sorted = 1;
break;
default:
return 1;
}
}
2002-10-16 17:31:15 +00:00
init_qf ();
while (optind < argc) {
if (!load_progs (argv[optind++]))
return 1;
func (&pr);
}
return 0;
}