quakeforge/libs/gib/gib_process.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 <string.h>
#include <ctype.h>
#include <stdlib.h>

#include "QF/va.h"
#include "QF/dstring.h"
#include "QF/cbuf.h"
#include "QF/cvar.h"
#include "QF/gib_buffer.h"
#include "QF/gib_parse.h"
#include "QF/gib_vars.h"
#include "QF/gib_process.h"
#include "QF/gib_builtin.h"

#include "exp.h"

static int
GIB_Process_Variable (dstring_t *token, unsigned int *i)
{
	hashtab_t *one = GIB_DATA(cbuf_active)->locals, *two = GIB_DATA(cbuf_active)->globals;
	unsigned int n = *i, j, k, start = *i, index = 0, len, len2;
	gib_var_t *var = 0;
	cvar_t *cvar;
	char c;
	const char *str;

	(*i)++;
	if (token->str[*i] == '{') {
		if ((c = GIB_Parse_Match_Brace (token->str, i))) {
			GIB_Error ("Parse", "Could not find match for %c.", c);
			return -1;
		}
		n += 2;
		len = 1;
	} else {
		for (; isalnum((byte) token->str[*i]) || token->str[*i] == '_'; (*i)++);
		if (token->str[*i] == '[') {
			if ((c = GIB_Parse_Match_Index (token->str, i))) {
				GIB_Error ("Parse", "Could not find match for %c.", c);
				return -1;
			} else
				(*i)++;
		}
		n++;
		len = 0;
	}
	c = token->str[*i];
	token->str[*i] = 0;

	for (k = n; token->str[n]; n++)
		if (token->str[n] == '$' || token->str[n] == '#')
			if (GIB_Process_Variable (token, &n))
				return -1;
	index = 0;
	if (n && token->str[n-1] == ']')
		for (j = n-1; j; j--)
			if (token->str[j] == '[') {
				index = atoi (token->str+j+1);
				token->str[j] = 0;
			}
	if ((var = GIB_Var_Get (one, two, token->str+k)) && index < var->size && var->array[index]) {
		if (token->str[start] == '#')
			str = va("%u", var->size - index);
		else
			str = var->array[index]->str;
	} else if (token->str[start] == '#')
		str = "0";
	else if ((cvar = Cvar_FindVar (token->str+k)))
		str = cvar->string;
	else
		str = "";
	token->str[n] = c;
	len += n-start;
	len2 = strlen (str);
	dstring_replace (token, start, len, str, len2);
	*i = start + len2 - 1;
	return 0;
}

int
GIB_Process_Math (struct dstring_s *token, unsigned int i)
{
	double value;
	
	value = EXP_Evaluate (token->str+i);
	if (EXP_ERROR) {
		GIB_Error ("math", "Expression \"%s\" caused an error:\n%s", token->str, EXP_GetErrorMsg());
		return -1;
	} else {
		token->str[i] = 0;
		token->size = i+1;
		dasprintf (token, "%.10g", value);
	}
	return 0;
}

int
GIB_Process_Embedded (gib_tree_t *node, cbuf_args_t *args)
{
	unsigned int n, j;
	gib_var_t *var;
	cvar_t *cvar;
	gib_tree_t *cur;
	unsigned int index, prev = 0;
	const char *str = node->str;
	
	for (cur = node->children; cur; cur = cur->next) {
		if (cur->start > prev)
			dstring_appendsubstr (args->argv[args->argc-1], str+prev, cur->start - prev);
		prev = cur->end;
		if (!cur->str) {
			struct gib_dsarray_s *retvals = GIB_DATA(cbuf_active)->stack.values+GIB_DATA(cbuf_active)->stack.p-1;
			if (retvals->size != 1) {
				if (!*args->argv[args->argc-1]->str)
					args->argc--;
				for (j = 0; j < retvals->size; j++) {
					Cbuf_ArgsAdd (args, retvals->dstrs[j]->str);
					args->argm[args->argc-1] = node;
				}
				if (str[prev] && retvals->size) // Still more stuff left?
					Cbuf_ArgsAdd (args, "");
			} else
				dstring_appendstr (args->argv[args->argc-1], retvals->dstrs[0]->str);
			GIB_Buffer_Pop_Sstack (cbuf_active);
		} else if (cur->flags & TREE_P_EMBED) {
			n = args->argv[args->argc-1]->size-1;
			if (cur->delim == '$')
				dstring_appendstr (args->argv[args->argc-1], "${");
			else
				dstring_appendstr (args->argv[args->argc-1], "#{");
			dstring_appendstr (args->argv[args->argc-1], cur->str);
			dstring_appendstr (args->argv[args->argc-1], "}");
			if (GIB_Process_Variable (args->argv[args->argc-1], &n))
				return -1;
		} else if ((var = GIB_Var_Get_Complex (&GIB_DATA(cbuf_active)->locals, &GIB_DATA(cbuf_active)->globals, (char *)cur->str, &index, false))) {
			if (cur->delim == '$')
				dstring_appendstr (args->argv[args->argc-1], var->array[index]->str);
			else
				dasprintf (args->argv[args->argc-1], "%u", var->size - index);
		} else if (cur->delim == '#')
			dstring_appendstr (args->argv[args->argc-1], "0");
		else if ((cvar = Cvar_FindVar (cur->str)))
			dstring_appendstr (args->argv[args->argc-1], cvar->string);
	}
	if (str[prev])
		dstring_appendstr (args->argv[args->argc-1], str+prev);
	return 0;
}

void
GIB_Process_Escapes (char *str)
{
	int i, j;
	char c;
	for (i = 0, j = 0; str[i]; j++) {
		if (str[i] == '\\') {
			i++;
			if (isdigit ((byte) str[i]) &&
			    isdigit ((byte) str[i+1]) &&
			    isdigit ((byte) str[i+2])) {
					unsigned int num;
					if ((num = 100 * (str[i] - '0') + 10 * (str[i+1] - '0') + (str[i+2] - '0')) <= 255) {
						c = (char) num;
						i += 3;
					} else
						c = '\\';
			} else switch (str[i++]) {
					case 'n':
						c = '\n';
						break;
					case 't':
						c = '\t';
						break;
					case 'r':
						c = '\r';
						break;
					case '\"':
						c = '"';
						break;
					case '\\':
						c = '\\';
						break;
					default:
						c = '\\';
						i--;
						break;
			}
			str[j] = c;
		} else
			str[j] = str[i++];
	}
	str[j] = 0;
}