271 lines
6.3 KiB
C
271 lines
6.3 KiB
C
/*
|
|
#FILENAME#
|
|
|
|
#DESCRIPTION#
|
|
|
|
Copyright (C) 2002 #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 <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdarg.h>
|
|
|
|
#include "QF/sys.h"
|
|
#include "QF/dstring.h"
|
|
#include "QF/cbuf.h"
|
|
#include "QF/hash.h"
|
|
#include "QF/gib_parse.h"
|
|
#include "QF/gib_buffer.h"
|
|
#include "QF/gib_tree.h"
|
|
#include "QF/gib_vars.h"
|
|
#include "QF/gib_execute.h"
|
|
|
|
void
|
|
GIB_Buffer_Construct (struct cbuf_s *cbuf)
|
|
{
|
|
cbuf->data = calloc (1, sizeof (gib_buffer_data_t));
|
|
GIB_DATA (cbuf)->arg_composite = dstring_newstr ();
|
|
GIB_DATA (cbuf)->globals = gib_globals;
|
|
cbuf->strict = true;
|
|
}
|
|
|
|
void
|
|
GIB_Buffer_Destruct (struct cbuf_s *cbuf)
|
|
{
|
|
gib_buffer_data_t *g = GIB_DATA(cbuf);
|
|
unsigned int i, j;
|
|
|
|
dstring_delete (g->arg_composite);
|
|
if (g->locals)
|
|
Hash_DelTable (g->locals);
|
|
if (g->program)
|
|
GIB_Tree_Unref (&g->program);
|
|
if (g->script && !(--g->script->refs)) {
|
|
free ((void *)g->script->text);
|
|
free ((void *)g->script->file);
|
|
free (g->script);
|
|
}
|
|
for (i = 0; i < g->stack.size; i++) {
|
|
for (j = 0; j < g->stack.values[i].realsize; j++)
|
|
dstring_delete (g->stack.values[i].dstrs[j]);
|
|
if (g->stack.values[i].dstrs)
|
|
free (g->stack.values[i].dstrs);
|
|
}
|
|
if (g->stack.values)
|
|
free (g->stack.values);
|
|
free (cbuf->data);
|
|
}
|
|
|
|
void
|
|
GIB_Buffer_Reset (struct cbuf_s *cbuf)
|
|
{
|
|
gib_buffer_data_t *g = GIB_DATA(cbuf);
|
|
|
|
if (g->locals)
|
|
Hash_FlushTable (g->locals);
|
|
g->globals = gib_globals;
|
|
if (g->program)
|
|
GIB_Tree_Unref (&g->program);
|
|
if (g->script && !(--g->script->refs)) {
|
|
free ((void *) g->script->text);
|
|
free ((void *) g->script->file);
|
|
free (g->script);
|
|
}
|
|
g->script = 0;
|
|
g->stack.p = 0;
|
|
g->waitret = g->done = false;
|
|
|
|
}
|
|
|
|
void
|
|
GIB_Buffer_Set_Program (cbuf_t *cbuf, gib_tree_t *program)
|
|
{
|
|
GIB_DATA(cbuf)->program = program;
|
|
}
|
|
|
|
static unsigned int
|
|
GIB_Buffer_Get_Line_Num (const char *program, unsigned int pos)
|
|
{
|
|
unsigned int i, line;
|
|
for (i = 0, line = 1; i < pos; i++)
|
|
if (program[i] == '\n')
|
|
line++;
|
|
return line;
|
|
}
|
|
|
|
void
|
|
GIB_Buffer_Add (cbuf_t *cbuf, const char *str)
|
|
{
|
|
gib_buffer_data_t *g = GIB_DATA (cbuf);
|
|
gib_tree_t **save, *cur;
|
|
|
|
if (g->program) {
|
|
for (cur = g->program; cur->next; cur = cur->next);
|
|
save = &cur->next;
|
|
} else
|
|
save = &g->program;
|
|
if (!(*save = GIB_Parse_Lines (str, 0, TREE_NORMAL)))
|
|
Sys_Printf (
|
|
"-----------------\n"
|
|
"|GIB Parse Error|\n"
|
|
"-----------------\n"
|
|
"Parse error while adding text to GIB buffer.\n"
|
|
"Line %u: %s\n", GIB_Buffer_Get_Line_Num (str, GIB_Parse_ErrorPos()), GIB_Parse_ErrorMsg()
|
|
);
|
|
}
|
|
|
|
void
|
|
GIB_Buffer_Insert (cbuf_t *cbuf, const char *str)
|
|
{
|
|
gib_buffer_data_t *g = GIB_DATA (cbuf);
|
|
gib_tree_t *lines, *cur;
|
|
|
|
if ((lines = GIB_Parse_Lines (str, 0, TREE_NORMAL))) {
|
|
for (cur = lines; cur; cur = cur->next);
|
|
//if (g->ip) { // This buffer is already running!
|
|
|
|
GIB_Tree_Unref (&g->program);
|
|
cur->next = g->program;
|
|
g->program = lines;
|
|
} else
|
|
Sys_Printf (
|
|
"-----------------\n"
|
|
"|GIB Parse Error|\n"
|
|
"-----------------\n"
|
|
"Parse error while inserting text into GIB buffer.\n"
|
|
"Line %u: %s\n", GIB_Buffer_Get_Line_Num (str, GIB_Parse_ErrorPos()), GIB_Parse_ErrorMsg()
|
|
);
|
|
}
|
|
|
|
void
|
|
GIB_Buffer_Push_Sstack (struct cbuf_s *cbuf)
|
|
{
|
|
gib_buffer_data_t *g = GIB_DATA(cbuf);
|
|
if (++g->stack.p > g->stack.size) {
|
|
g->stack.values = realloc(g->stack.values, sizeof (struct gib_dsarray_s) * g->stack.p);
|
|
g->stack.values[g->stack.p-1].dstrs = 0;
|
|
g->stack.values[g->stack.p-1].size = g->stack.values[g->stack.p-1].realsize = 0;
|
|
g->stack.size = g->stack.p;
|
|
}
|
|
g->stack.values[g->stack.p-1].size = 0;
|
|
}
|
|
|
|
void
|
|
GIB_Buffer_Pop_Sstack (struct cbuf_s *cbuf)
|
|
{
|
|
GIB_DATA(cbuf)->stack.p--;
|
|
}
|
|
|
|
dstring_t *
|
|
GIB_Buffer_Dsarray_Get (struct cbuf_s *cbuf)
|
|
{
|
|
struct gib_dsarray_s *vals = GIB_DATA(cbuf)->stack.values+GIB_DATA(cbuf)->stack.p-1;
|
|
if (++vals->size > vals->realsize) {
|
|
vals->dstrs = realloc (vals->dstrs, sizeof (dstring_t *) * vals->size);
|
|
vals->dstrs[vals->size-1] = dstring_newstr ();
|
|
vals->realsize = vals->size;
|
|
} else
|
|
dstring_clearstr (vals->dstrs[vals->size-1]);
|
|
return vals->dstrs[vals->size-1];
|
|
}
|
|
|
|
|
|
static int
|
|
GIB_Buffer_Get_Line_Info (cbuf_t *cbuf, char **line)
|
|
{
|
|
const char *text;
|
|
unsigned int ofs, i, start, linenum;
|
|
|
|
// Do we have a copy of the original program this buffer comes from?
|
|
if (GIB_DATA(cbuf)->script) {
|
|
text = GIB_DATA(cbuf)->script->text;
|
|
for (ofs = GIB_DATA(cbuf)->ip->start, start = 0, i = 0, linenum = 1; i <= ofs; i++)
|
|
if (text[i] == '\n') {
|
|
start = i+1;
|
|
linenum++;
|
|
}
|
|
while (text[i] != '\n')
|
|
i++;
|
|
*line = malloc (i - start + 1);
|
|
memcpy (*line, text+start, i - start);
|
|
(*line)[i-start] = 0;
|
|
return linenum;
|
|
} else {
|
|
*line = strdup (GIB_DATA(cbuf)->ip->str);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
void
|
|
GIB_Buffer_Error (cbuf_t *cbuf, const char *type, const char *fmt, va_list args)
|
|
{
|
|
char *line;
|
|
int linenum;
|
|
dstring_t *message = dstring_newstr();
|
|
dvsprintf (message, fmt, args);
|
|
va_end (args);
|
|
Sys_Printf ( "---------------------\n"
|
|
"|GIB Execution Error|\n"
|
|
"---------------------\n"
|
|
"Type: %s\n",
|
|
type
|
|
);
|
|
if ((linenum = GIB_Buffer_Get_Line_Info (cbuf, &line)) != -1)
|
|
Sys_Printf ( "%s:%i: %s\n"
|
|
"-->%s\n",
|
|
GIB_DATA(cbuf)->script->file,
|
|
linenum,
|
|
message->str,
|
|
line
|
|
);
|
|
else
|
|
Sys_Printf ( "%s\n"
|
|
"-->%s\n",
|
|
message->str,
|
|
line
|
|
);
|
|
cbuf->state = CBUF_STATE_ERROR;
|
|
dstring_delete (message);
|
|
free (line);
|
|
}
|
|
|
|
|
|
cbuf_interpreter_t gib_interp = {
|
|
GIB_Buffer_Construct,
|
|
GIB_Buffer_Destruct,
|
|
GIB_Buffer_Reset,
|
|
GIB_Buffer_Add,
|
|
GIB_Buffer_Insert,
|
|
GIB_Execute,
|
|
GIB_Execute,
|
|
};
|