First.start

1 files changed, 309 insertions, 0 deletions

diff --git a/lib/parser.c b/lib/parser.c
new file mode 100644
index 0000000..a2947e6
--- /dev/null
+++ b/lib/parser.c
@@ -0,0 +1,309 @@
+#include <stdio.h>
+#include <limits.h>
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#else
+#define _(x) x
+void exception(int, char *);
+#endif
+#include "global.h"
+#include "parser.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;
+
+static operator_t operators[] = {
+        {',', 0, OP_NEST},
+	{'+', 2, OP_PLUS},
+	{'-', 2, OP_MOINS},
+	{'*', 3, OP_MUL},
+	{'/', 3, OP_DIV},
+	{'+' + 128, 4, OP_PLUS_UNARY},
+	{'-' + 128, 4, OP_MOINS_UNARY},
+	{'(', 5, OP_FUNC_CALL},
+	{'(' + 128, 5, OP_LPAREN},
+	{'[', 5, OP_DECAL},
+	{'[' + 128, 5, OP_DIRECT},
+	{255, -1, -1}
+};
+
+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];
+}
+
+static int get_pri(op_t op)
+{
+	return get_op(op).pri;
+}
+
+static int get_func(op_t op)
+{
+	return get_op(op).func;
+}
+
+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"));
+}
+
+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) != ' ') {
+					o = *(p++) = *line;
+				} else if (d != line) {
+					*p = '\0';
+					return line;
+				}
+			}
+		}
+		line++;
+	} while (((*line) && (*line != ')') && (*line != ']') && (*line != ';') && (get_func(*line) == -1)
+		 && (get_func(o) == -1)) || (instring));
+	*p = '\0';
+	return line;
+}
+
+void parse_line(char *line)
+{
+	char buffer[BUFSIZ], imm[BUFSIZ];
+	op_t op;
+	int got_unary = 128, nbrargs;
+
+	while (*line) {
+		line = getword(line, buffer);
+		if (get_func(buffer[0]) != -1) {
+			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) != '(') && ((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] == ')') || (buffer[0] == ']')) {
+			switch (buffer[0]) {
+			case ';':
+				while (pileop_pos) {
+					op = pop_op();
+					if (op == '(')
+						exception(-1, _("Parse error: too much left parenthesis"));
+					act_pile(get_func(op));
+				}
+				break;
+			case ')':
+				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();
+                                        sprintf(imm, "%i", nbrargs);
+                                        push_pile(imm);
+                                        act_pile(get_func(op));
+                                }
+				got_unary = 0;
+				break;
+			case ']':
+				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));
+				}
+                                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] == '\'')) {
+			push_pile(buffer);
+			got_unary = 0;
+			if (!get_last_call()) increment_call();
+		} else if (buffer[0]) {
+			exception(-1, _("Invalid character"));
+		}
+	}
+}
+
+#ifndef HAVE_CONFIG_H
+
+void exception(int level, char *msg)
+{
+	fprintf(stderr, "%s\n", msg);
+	exit(level);
+}
+
+void push_pile(char *word)
+{
+	printf("%s ", word);
+}
+
+void act_pile(int func)
+{
+	char op;
+
+	switch (func) {
+	case OP_PLUS:
+		op = '+';
+		break;
+	case OP_MOINS:
+		op = '-';
+		break;
+	case OP_DIV:
+		op = '/';
+		break;
+	case OP_MUL:
+		op = '*';
+		break;
+	case OP_PLUS_UNARY:
+		op = '\0';
+		break;
+	case OP_MOINS_UNARY:
+		op = '|';
+		break;
+        case OP_FUNC_CALL:
+                op = '@';
+                break;
+	case OP_DECAL:
+		op = '[';
+		break;
+	case OP_DIRECT:
+		op = '{';
+		break;
+	}
+	printf("%c ", op);
+}
+
+void main(void)
+{
+	parse_line("ADD R18, R20, 39;");
+	printf("\n\n"); fflush(stdout);
+	parse_line("MOV R31, Bidule[48 + R12];");
+	printf("\n\n"); fflush(stdout);
+	parse_line("MOV R12, [R3];");
+	printf("\n\n"); fflush(stdout);
+	parse_line("MOV R22, Truc[(3+2)*8];");
+	printf("\n\n"); fflush(stdout);
+	parse_line("Trucmuche DB \"Test de chaîne complète avec des opérateurs comme le + et le - ...\"");
+	printf("\n\n"); fflush(stdout);
+}
+
+#endif