path: root/lib/parser.c

/*
 *
 * Interpreteur de ligne de commande
 *
 */
#include <stdio.h>
#include <limits.h>
#ifdef HAVE_CONFIG_H
#include "config.h"
#else
#define _(x) x
#endif
#include "exceptions.h"
#include "parser.h"
#include "pile.h"


typedef unsigned char op_t;

typedef struct operator_t {
	op_t op;
	int pri, func;
} operator_t;

static op_t pile_operators[PILEOP_MAX];
static int pile_nestedcall[PILECALL_MAX];

static int pileop_pos = 0, pilecall_pos = 0;

/* La liste des opérateurs reconnus par le parser */

static operator_t operators[] = {
	{',', 0, OP_NEST},
	{'+', 2, OP_PLUS},
	{'-', 2, OP_MOINS},
	{'*', 3, OP_MUL},
	{'/', 3, OP_DIV},
	{'%', 3, OP_MOD},
	{'^', 4, OP_EXP},
	{'+' + 128, 5, OP_PLUS_UNARY},
	{'-' + 128, 5, OP_MOINS_UNARY},
	{'=', 1, OP_ASSIGN},
	{'(', 6, OP_FUNC_CALL},
	{'(' + 128, 6, OP_LPAREN},
	{255, -1, -1}
};




/* Fonction interne: convertit un operateur en sa structure */

static operator_t get_op(op_t op)
{
	int i;

	for (i = 0; operators[i].op != 255; i++) {
		if (operators[i].op == op)
			return operators[i];
	}

	return operators[i];
}

/* Fonctions internes de lectures sur la structure */

static int get_pri(op_t op)
{
	return get_op(op).pri;
}

static int get_func(op_t op)
{
	return get_op(op).func;
}

/* Focntions internes d'empilement / dépilement */

static op_t get_last_op(void)
{
	if (pileop_pos)
		return pile_operators[pileop_pos - 1];
	else
		return -1;
}

static op_t pop_op(void)
{
	if (pileop_pos)
		return pile_operators[--pileop_pos];
	return -1;
}

static void push_op(op_t op)
{
	if (pileop_pos != PILEOP_MAX)
		pile_operators[pileop_pos++] = op;
	else
		exception(1, _("Too many nested operators in expression.\n"));

}

static int pop_call(void)
{
	if (pilecall_pos)
		return pile_nestedcall[--pilecall_pos];
	return -1;
}

static void increment_call(void)
{
	if (pilecall_pos) {
		if (pile_nestedcall[pilecall_pos - 1] != -1)
			pile_nestedcall[pilecall_pos - 1]++;
	}
}

static int get_last_call(void)
{
	if (pilecall_pos)
		return pile_nestedcall[pilecall_pos - 1];
	return -1;
}

static void push_call(int call)
{
	if (pilecall_pos != PILECALL_MAX)
		pile_nestedcall[pilecall_pos++] = call;
	else
		exception(1, _("Too many nested functions calls in expression.\n"));
}

/* Cette fonction lit un "mot" sur la chaine line et renvoit le nouveau pointeur */

static char *getword(char *line, char *p)
{
	char o = 0, *d = line, instring = 0, gotbslash = 0;

	do {
		if (instring) {
			o = *(p++) = *line;
			if (!gotbslash) {
				switch (instring) {
				case 1:
					if (*line == '\'') {
						instring = 0;
					}
					break;
				case 2:
					if (*line == '"') {
						instring = 0;
					}
					break;
				}
				if (*line == '\\')
					gotbslash = 1;
			} else {
				gotbslash = 0;
			}
		} else {
			if (*(line) == '\'') {
				o = *(p++) = *line;
				instring = 1;
			} else if (*(line) == '"') {
				o = *(p++) = *line;
				instring = 2;
			} else {
				if (*(line) != ' ' && *(line) != '\t') {
					o = *(p++) = *line;
				} else if (d != line) {
					*p = '\0';
					return line;
				}
			}
		}
		line++;
	}
	while (((*line) && (*line != ')')
		&& (*line != ';') && (get_func(*line) == -1)
		&& (get_func(o) == -1)) || (instring));
	*p = '\0';
	return line;
}

/* Cette fonction va parcourir une chaine afin d'appeler les fonction push_pile() et act_pile() */

void parse_line(char *line)
{
	char buffer[BUFSIZ], imm[BUFSIZ], *d = line;
	op_t op;
	static int got_unary = 128, nbrargs;

	sprintf(buffer, "Read line '%s'", line);
	pushcontext(buffer);

	while ((*line) && !(global_error)) {
		line = getword(line, buffer);
		sprintf(imm, "Analysing word '%s' at position %i", buffer, line - d);
		pushcontext(imm);
		if (get_func(buffer[0]) != -1) {
			/* Le mot lu est un operateur, on agit sur la pile */
			buffer[0] += got_unary;
			if (got_unary) {
			}
			if (get_pri(buffer[0]) == -1) {
				if (got_unary) {
					exception(1, _("Invalid unary operator"));
				} else {
					exception(1, _("Invalid binary operator"));
				}
			}
			while ((get_pri(get_last_op()) >= get_pri(buffer[0]))
			       && ((get_last_op() & 127) != '(')) {
				act_pile(get_func(pop_op()));
				got_unary = 0;
			}
			if (buffer[0] == '(') {
				push_call(0);
			}
			if (buffer[0] == ',') {
				increment_call();
			} else
				push_op(buffer[0]);
			got_unary = 128;
		} else if ((buffer[0] == ';') || (buffer[0] == ')')) {
			/* Le mot lut est un opérateur spécial, on vide la pile */
			switch (buffer[0]) {
			case ';':
				/* Equivalent a fin de ligne */
				while (pileop_pos) {
					op = pop_op();
					if (op == '(')
						exception(1, _("Parse error: too much left parenthesis"));
					act_pile(get_func(op));
				}
				popcontext();
				popcontext();
				return;
			case ')':
				/* Fin de parenthese (Appel de fonction ou expression mathématique) */
				while (1) {
					if (!pileop_pos)
						exception(1, _("Parse error: too much right parenthesis"));
					op = pop_op();
					if (((op & 127) == '('))
						break;
					if (((op & 127) == '['))
						exception(1, _("Parse error: enclosure mismatch"));
					act_pile(get_func(op));
				}
				if (op == '(') {
					nbrargs = pop_call();
					push_pile_int(nbrargs);
					act_pile(get_func(op));
				}
				got_unary = 0;
				break;
			}
		} else if (((buffer[0] >= 'A') && (buffer[0] <= 'Z'))
			   || ((buffer[0] >= 'a') && (buffer[0] <= 'z'))
			   || ((buffer[0] >= '0') && (buffer[0] <= '9'))
			   || (buffer[0] == '_') || (buffer[0] == '"')
			   || (buffer[0] == '\'') || (buffer[0] == '.')
			   || (buffer[0] == '#') || (buffer[0] == '?')) {
			/* Dans tous les autres cas, on a reçu un symbole, on le pose sur la pile */
			push_pile(buffer);
			got_unary = 0;
			if (!get_last_call())
				increment_call();
		} else if (buffer[0]) {
			exception(1, _("Invalid character"));
		}
		popcontext();
	}
	popcontext();
}