forked from github/server
478 lines
10 KiB
C
478 lines
10 KiB
C
/* vi: set ts=2:
|
|
+-------------------+ Christian Schlittchen <corwin@amber.kn-bremen.de>
|
|
| | Enno Rehling <enno@eressea.de>
|
|
| Eressea PBEM host | Katja Zedel <katze@felidae.kn-bremen.de>
|
|
| (c) 1998 - 2003 | Henning Peters <faroul@beyond.kn-bremen.de>
|
|
| | Ingo Wilken <Ingo.Wilken@informatik.uni-oldenburg.de>
|
|
+-------------------+ Stefan Reich <reich@halbling.de>
|
|
|
|
This program may not be used, modified or distributed
|
|
without prior permission by the authors of Eressea.
|
|
*/
|
|
#include <platform.h>
|
|
|
|
#include "translation.h"
|
|
|
|
#include "bsdstring.h"
|
|
#include "critbit.h"
|
|
#include "log.h"
|
|
|
|
/* libc includes */
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
|
|
/**
|
|
** simple operand stack
|
|
**/
|
|
|
|
typedef struct opstack {
|
|
variant *begin;
|
|
variant *top;
|
|
int size;
|
|
} opstack;
|
|
|
|
variant opstack_pop(opstack ** stackp)
|
|
{
|
|
opstack *stack = *stackp;
|
|
|
|
assert(stack);
|
|
assert(stack->top > stack->begin);
|
|
return *(--stack->top);
|
|
}
|
|
|
|
void opstack_push(opstack ** stackp, variant data)
|
|
{
|
|
opstack *stack = *stackp;
|
|
if (stack == NULL) {
|
|
stack = (opstack *) malloc(sizeof(opstack));
|
|
stack->size = 1;
|
|
stack->begin = malloc(sizeof(variant) * stack->size);
|
|
stack->top = stack->begin;
|
|
*stackp = stack;
|
|
}
|
|
if (stack->top - stack->begin == stack->size) {
|
|
size_t pos = stack->top - stack->begin;
|
|
stack->size += stack->size;
|
|
stack->begin = realloc(stack->begin, sizeof(variant) * stack->size);
|
|
stack->top = stack->begin + pos;
|
|
}
|
|
*stack->top++ = data;
|
|
}
|
|
|
|
/**
|
|
** static buffer malloc
|
|
**/
|
|
|
|
#define BBUFSIZE 128*1024
|
|
static struct {
|
|
char *begin;
|
|
char *end;
|
|
char *last;
|
|
char *current;
|
|
} buffer;
|
|
|
|
char *balloc(size_t size)
|
|
{
|
|
static int init = 0; /* STATIC_XCALL: used across calls */
|
|
if (!init) {
|
|
init = 1;
|
|
buffer.current = buffer.begin = malloc(BBUFSIZE);
|
|
buffer.end = buffer.begin + BBUFSIZE;
|
|
}
|
|
if (buffer.current + size > buffer.end) {
|
|
/* out of memory! */
|
|
return NULL;
|
|
}
|
|
buffer.last = buffer.current;
|
|
buffer.current += size;
|
|
return buffer.last;
|
|
}
|
|
|
|
void bfree(char *c)
|
|
/* only release this memory if it was part of the last allocation
|
|
* that's a joke, but who cares.
|
|
*/
|
|
{
|
|
if (c >= buffer.last && c < buffer.current)
|
|
buffer.current = c;
|
|
}
|
|
|
|
void brelease(void)
|
|
{
|
|
buffer.last = buffer.current = buffer.begin;
|
|
}
|
|
|
|
/**
|
|
** constant values
|
|
**/
|
|
|
|
typedef struct variable {
|
|
struct variable *next;
|
|
const char *symbol;
|
|
variant value;
|
|
} variable;
|
|
|
|
static variable *variables;
|
|
|
|
static void free_variables(void)
|
|
{
|
|
variables = NULL;
|
|
}
|
|
|
|
static void add_variable(const char *symbol, variant value)
|
|
{
|
|
variable *var = (variable *) balloc(sizeof(variable));
|
|
|
|
var->value = value;
|
|
var->symbol = symbol;
|
|
|
|
var->next = variables;
|
|
variables = var;
|
|
}
|
|
|
|
static variable *find_variable(const char *symbol)
|
|
{
|
|
variable *var = variables;
|
|
while (var) {
|
|
if (!strcmp(var->symbol, symbol))
|
|
break;
|
|
var = var->next;
|
|
}
|
|
return var;
|
|
}
|
|
|
|
/**
|
|
** constant values
|
|
**/
|
|
|
|
static struct critbit_tree functions = { 0 };
|
|
|
|
static void free_functions(void)
|
|
{
|
|
cb_clear(&functions);
|
|
functions.root = 0;
|
|
}
|
|
|
|
void add_function(const char *symbol, evalfun parse)
|
|
{
|
|
char buffer[64];
|
|
size_t len = strlen(symbol);
|
|
|
|
assert(len+1+sizeof(parse)<=sizeof(buffer));
|
|
cb_new_kv(symbol, &parse, sizeof(parse), buffer);
|
|
cb_insert(&functions, buffer, len+1+sizeof(parse));
|
|
}
|
|
|
|
static evalfun find_function(const char *symbol)
|
|
{
|
|
const void * matches;
|
|
if (cb_find_prefix(&functions, symbol, strlen(symbol)+1, &matches, 1, 0)) {
|
|
evalfun result;
|
|
cb_get_kv(matches, &result, sizeof(result));
|
|
return result;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static const char *parse(opstack **, const char *in, const void *);
|
|
/* static const char * sample = "\"enno and $bool($if($eq($i,0),\"noone else\",\"$i other people\"))\""; */
|
|
|
|
static const char *parse_symbol(opstack ** stack, const char *in,
|
|
const void *userdata)
|
|
/* in is the symbol name and following text, starting after the $
|
|
* result goes on the stack
|
|
*/
|
|
{
|
|
boolean braces = false;
|
|
char symbol[32];
|
|
char *cp = symbol; /* current position */
|
|
|
|
if (*in == '{') {
|
|
braces = true;
|
|
++in;
|
|
}
|
|
while (isalnum(*in) || *in == '.')
|
|
*cp++ = *in++;
|
|
*cp = '\0';
|
|
/* symbol will now contain the symbol name */
|
|
if (*in == '(') {
|
|
/* it's a function we need to parse, start by reading the parameters */
|
|
evalfun foo;
|
|
|
|
while (*in != ')') {
|
|
in = parse(stack, ++in, userdata); /* will push the result on the stack */
|
|
if (in == NULL)
|
|
return NULL;
|
|
}
|
|
++in;
|
|
foo = find_function(symbol);
|
|
if (foo == NULL) {
|
|
log_error(("parser does not know about \"%s\" function.\n", symbol));
|
|
return NULL;
|
|
}
|
|
foo(stack, userdata); /* will pop parameters from stack (reverse order!) and push the result */
|
|
} else {
|
|
variable *var = find_variable(symbol);
|
|
if (braces && *in == '}') {
|
|
++in;
|
|
}
|
|
/* it's a constant (variable is a misnomer, but heck, const was taken;)) */
|
|
if (var == NULL) {
|
|
log_error(("parser does not know about \"%s\" variable.\n", symbol));
|
|
return NULL;
|
|
}
|
|
opush(stack, var->value);
|
|
}
|
|
return in;
|
|
}
|
|
|
|
#define TOKENSIZE 4096
|
|
static const char *parse_string(opstack ** stack, const char *in,
|
|
const void *userdata)
|
|
{ /* (char*) -> char* */
|
|
char *c;
|
|
char *buffer = balloc(TOKENSIZE);
|
|
size_t size = TOKENSIZE - 1;
|
|
const char *ic = in;
|
|
char *oc = buffer;
|
|
/* mode flags */
|
|
boolean f_escape = false;
|
|
boolean bDone = false;
|
|
variant var;
|
|
|
|
while (*ic && !bDone) {
|
|
if (f_escape) {
|
|
f_escape = false;
|
|
switch (*ic) {
|
|
case 'n':
|
|
if (size > 0) {
|
|
*oc++ = '\n';
|
|
--size;
|
|
}
|
|
break;
|
|
case 't':
|
|
if (size > 0) {
|
|
*oc++ = '\t';
|
|
--size;
|
|
}
|
|
break;
|
|
default:
|
|
if (size > 0) {
|
|
*oc++ = *ic++;
|
|
--size;
|
|
}
|
|
}
|
|
} else {
|
|
int ch = (unsigned char)(*ic);
|
|
int bytes;
|
|
|
|
switch (ch) {
|
|
case '\\':
|
|
f_escape = true;
|
|
++ic;
|
|
break;
|
|
case '"':
|
|
bDone = true;
|
|
++ic;
|
|
break;
|
|
case '$':
|
|
ic = parse_symbol(stack, ++ic, userdata);
|
|
if (ic == NULL)
|
|
return NULL;
|
|
c = (char *)opop_v(stack);
|
|
bytes = (int)strlcpy(oc, c, size);
|
|
if (bytes < (int)size)
|
|
oc += bytes;
|
|
else
|
|
oc += size;
|
|
bfree(c);
|
|
break;
|
|
default:
|
|
if (size > 0) {
|
|
*oc++ = *ic++;
|
|
--size;
|
|
} else
|
|
++ic;
|
|
}
|
|
}
|
|
}
|
|
*oc++ = '\0';
|
|
bfree(oc);
|
|
var.v = buffer;
|
|
opush(stack, var);
|
|
return ic;
|
|
}
|
|
|
|
static const char *parse_int(opstack ** stack, const char *in)
|
|
{
|
|
int k = 0;
|
|
int vz = 1;
|
|
boolean ok = false;
|
|
variant var;
|
|
do {
|
|
switch (*in) {
|
|
case '+':
|
|
++in;
|
|
break;
|
|
case '-':
|
|
++in;
|
|
vz = vz * -1;
|
|
break;
|
|
default:
|
|
ok = true;
|
|
}
|
|
} while (!ok);
|
|
while (isdigit(*(unsigned char *)in)) {
|
|
k = k * 10 + (*in++) - '0';
|
|
}
|
|
var.i = k * vz;
|
|
opush(stack, var);
|
|
return in;
|
|
}
|
|
|
|
static const char *parse(opstack ** stack, const char *inn,
|
|
const void *userdata)
|
|
{
|
|
const char *b = inn;
|
|
while (*b) {
|
|
switch (*b) {
|
|
case '"':
|
|
return parse_string(stack, ++b, userdata);
|
|
break;
|
|
case '$':
|
|
return parse_symbol(stack, ++b, userdata);
|
|
break;
|
|
default:
|
|
if (isdigit(*(unsigned char *)b) || *b == '-' || *b == '+') {
|
|
return parse_int(stack, b);
|
|
} else
|
|
++b;
|
|
}
|
|
}
|
|
log_error(("could not parse \"%s\". Probably invalid message syntax.", inn));
|
|
return NULL;
|
|
}
|
|
|
|
const char *translate(const char *format, const void *userdata,
|
|
const char *vars, variant args[])
|
|
{
|
|
int i = 0;
|
|
const char *ic = vars;
|
|
char symbol[32];
|
|
char *oc = symbol;
|
|
opstack *stack = NULL;
|
|
const char *rv;
|
|
|
|
brelease();
|
|
free_variables();
|
|
|
|
assert(format);
|
|
assert(*ic == 0 || isalnum(*ic));
|
|
while (*ic) {
|
|
*oc++ = *ic++;
|
|
if (!isalnum(*ic)) {
|
|
variant x = args[i++];
|
|
*oc = '\0';
|
|
oc = symbol;
|
|
add_variable(strcpy(balloc(strlen(symbol) + 1), symbol), x);
|
|
while (*ic && !isalnum(*ic))
|
|
++ic;
|
|
}
|
|
}
|
|
|
|
if (format[0] == '"') {
|
|
rv = parse(&stack, format, userdata);
|
|
} else {
|
|
rv = parse_string(&stack, format, userdata);
|
|
}
|
|
if (rv != NULL) {
|
|
if (rv[0]) {
|
|
log_error(("residual data after parsing: %s\n", rv));
|
|
}
|
|
rv = (const char *)opop(&stack).v;
|
|
free(stack->begin);
|
|
free(stack);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
static void eval_lt(opstack ** stack, const void *userdata)
|
|
{ /* (int, int) -> int */
|
|
int a = opop_i(stack);
|
|
int b = opop_i(stack);
|
|
int rval = (b < a) ? 1 : 0;
|
|
opush_i(stack, rval);
|
|
unused(userdata);
|
|
}
|
|
|
|
static void eval_eq(opstack ** stack, const void *userdata)
|
|
{ /* (int, int) -> int */
|
|
int a = opop_i(stack);
|
|
int b = opop_i(stack);
|
|
int rval = (a == b) ? 1 : 0;
|
|
opush_i(stack, rval);
|
|
unused(userdata);
|
|
}
|
|
|
|
static void eval_add(opstack ** stack, const void *userdata)
|
|
{ /* (int, int) -> int */
|
|
int a = opop_i(stack);
|
|
int b = opop_i(stack);
|
|
opush_i(stack, a + b);
|
|
unused(userdata);
|
|
}
|
|
|
|
static void eval_isnull(opstack ** stack, const void *userdata)
|
|
{ /* (int, int) -> int */
|
|
void *a = opop_v(stack);
|
|
opush_i(stack, (a == NULL) ? 1 : 0);
|
|
unused(userdata);
|
|
}
|
|
|
|
static void eval_if(opstack ** stack, const void *userdata)
|
|
{ /* (int, int) -> int */
|
|
void *a = opop_v(stack);
|
|
void *b = opop_v(stack);
|
|
int cond = opop_i(stack);
|
|
opush_v(stack, cond ? b : a);
|
|
unused(userdata);
|
|
}
|
|
|
|
static void eval_strlen(opstack ** stack, const void *userdata)
|
|
{ /* string -> int */
|
|
const char *c = (const char *)opop_v(stack);
|
|
opush_i(stack, c ? (int)strlen(c) : 0);
|
|
unused(userdata);
|
|
}
|
|
|
|
#include "base36.h"
|
|
static void eval_int(opstack ** stack, const void *userdata)
|
|
{
|
|
int i = opop_i(stack);
|
|
const char *c = itoa10(i);
|
|
size_t len = strlen(c);
|
|
variant var;
|
|
|
|
var.v = strcpy(balloc(len + 1), c);
|
|
opush(stack, var);
|
|
}
|
|
|
|
void translation_init(void)
|
|
{
|
|
add_function("lt", &eval_lt);
|
|
add_function("eq", &eval_eq);
|
|
add_function("int", &eval_int);
|
|
add_function("add", &eval_add);
|
|
add_function("strlen", &eval_strlen);
|
|
add_function("if", &eval_if);
|
|
add_function("isnull", &eval_isnull);
|
|
}
|
|
|
|
void translation_done(void)
|
|
{
|
|
free_functions();
|
|
free(buffer.begin);
|
|
}
|