summaryrefslogtreecommitdiff
path: root/lib/parser.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/parser.c')
-rw-r--r--lib/parser.c295
1 files changed, 295 insertions, 0 deletions
diff --git a/lib/parser.c b/lib/parser.c
new file mode 100644
index 0000000..3f0c6ce
--- /dev/null
+++ b/lib/parser.c
@@ -0,0 +1,295 @@
+/*
+ *
+ * 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 != ']')
+ && (*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;
+ int got_unary = 128, nbrargs;
+
+ sprintf(buffer, "Read line '%s'", line);
+ pushcontext(buffer);
+
+ while (*line) {
+ 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 lut 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) != '(')
+ && ((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] == ']')) {
+ /* 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;
+ case ']':
+ /* Fin d'opérateur de décalage */
+ 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] == '\'') || (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();
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-29 07:31:28 +0000