From: Adam Dickmeiss <adam@indexdata.dk>
Date: Thu, 9 Feb 1995 13:07:14 +0000 (+0000)
Subject: Nodes are freed now. Many bugs fixed.
X-Git-Url: http://sru.miketaylor.org.uk/cgi-bin?a=commitdiff_plain;h=332f815feae8b1614c42b0a436f2ab0276d817d8;p=egate.git

Nodes are freed now. Many bugs fixed.
---

diff --git a/fml/fml.c b/fml/fml.c
index 5690b56..9a2c6ca 100644
--- a/fml/fml.c
+++ b/fml/fml.c
@@ -2,7 +2,10 @@
  * FML interpreter. Europagate, 1995
  *
  * $Log: fml.c,v $
- * Revision 1.3  1995/02/07 16:09:23  adam
+ * Revision 1.4  1995/02/09 13:07:14  adam
+ * Nodes are freed now. Many bugs fixed.
+ *
+ * Revision 1.3  1995/02/07  16:09:23  adam
  * The \ character is no longer INCLUDED when terminating a token.
  * Major changes in tokenization routines. Bug fixes in expressions
  * with lists (fml_sub0).
@@ -33,6 +36,12 @@ static void default_err_handle (int no)
     fprintf (stderr, "Error: %d\n", no);
 }
 
+static struct fml_node *fml_sub0 (Fml fml, struct fml_node *list);
+static struct fml_node *fml_sub1 (Fml fml, struct fml_node **lp,
+                                  struct token *tp);
+static struct fml_node *fml_sub2 (Fml fml, struct fml_node **lp,
+                                  struct token *tp);
+
 static struct fml_node *fml_exec_space (Fml fml, struct fml_node **lp, 
                                         struct token *tp);
 static struct fml_node *fml_exec_nl (Fml fml, struct fml_node **lp, 
@@ -41,10 +50,6 @@ static struct fml_node *fml_exec_incr (Fml fml, struct fml_node **lp,
                                        struct token *tp);
 static struct fml_node *fml_exec_decr (Fml fml, struct fml_node **lp, 
                                        struct token *tp);
-#if 0
-static struct fml_node *fml_sub_bad (Fml fml, struct fml_node *list);
-#endif
-static struct fml_node *fml_sub0 (Fml fml, struct fml_node *list);
 
 static struct fml_node *fml_exec_plus (Fml fml, struct fml_node *l,
                                        struct fml_node *r);
@@ -196,7 +201,7 @@ static void pop_handler (struct fml_sym_info *info)
     switch (info->kind)
     {
     case FML_VAR:
-/* fml_node_delete (fml_pop_handler, info->body); */
+        fml_node_delete (fml_pop_handler, info->body);
         break;
     }
 }
@@ -274,7 +279,6 @@ static void fml_cmd_lex (struct fml_node **np, struct token *tp)
     if (*cp == tp->escape_char)
     {
         tp->kind = 'e';
-        tp->after_char = '\0';
         cp++;
         if (*cp == '\0')
         {
@@ -287,30 +291,13 @@ static void fml_cmd_lex (struct fml_node **np, struct token *tp)
     else
     {
         tp->kind = 't';
-        tp->after_char = ' ';
     }
     while (*cp)
     {
         if (*cp == tp->escape_char)
         {
             *dst = '\0';
-#if 0
-            if (cp[1] == '\0')
-            {
-                tp->after_char = ' ';
-                break;
-            }
-#endif
-#if 0
-            if (tp->kind == 'e')
-            {
-                cp++;
-                if (! *cp)
-                    break;
-            }
-#endif
             tp->offset = cp - tp->atombuf;
-            tp->after_char = '\0';
             return ;
         }
         *dst++ = *cp++;
@@ -320,72 +307,81 @@ static void fml_cmd_lex (struct fml_node **np, struct token *tp)
     *np = (*np)->p[1];
 }
 
-static struct fml_node *fml_lex_list (Fml fml, struct token *tp)
-{
-    struct fml_node *fn;
-
-    if (tp->kind == 'g')
-        return tp->sub;
-    fn = fml_node_alloc (fml);
-    fn->is_atom = 1;
-    fn->p[0] = tp->atom;
-    return fn;
-}
-
 static struct fml_node *fml_exec_group (struct fml_node *list, Fml fml);
 
-static void fml_lr_values (struct fml_node *l, int *left_val,
+static void fml_lr_values (Fml fml, struct fml_node *l, int *left_val,
                            struct fml_node *r, int *right_val)
 {
-    if (l->is_atom)
+    if (l && l->is_atom)
         *left_val = fml_atom_val (l->p[0]);
     else
         *left_val = 0;
-    if (r->is_atom)
+    if (r && r->is_atom)
         *right_val = fml_atom_val (r->p[0]);
     else
         *right_val = 0;
+    fml_node_delete (fml, l);
+    fml_node_delete (fml, r);
 }
 
 static struct fml_node *fml_exec_and (Fml fml, struct fml_node *l,
                                       struct fml_node *r)
 {
     if (l && r)
+    {
+        fml_node_delete (fml, l);
         return r;
-    else
-        return NULL;
+    }
+    fml_node_delete (fml, l);
+    fml_node_delete (fml, r);
+    return NULL;
 }
 
 static struct fml_node *fml_exec_or (Fml fml, struct fml_node *l,
                                       struct fml_node *r)
 {
-    if (l)
-        return l;
-    return r;
+    if (r)
+    {
+        fml_node_delete (fml, l);
+        return r;
+    }
+    return l;
 }
 
 static struct fml_node *fml_exec_indx (Fml fml, struct fml_node *l,
                                        struct fml_node *r)
 {
     struct fml_node *list = l;
+    struct fml_node *fn;
     int indx;
 
     if (!l || !r || !r->is_atom)
+    {
+        fml_node_delete (fml, l);
+        fml_node_delete (fml, r);
         return NULL;
+    }
     indx = fml_atom_val (r->p[0]);
+    fml_node_delete (fml, r);
     while (--indx >= 1 && list)
         list = list->p[1];
     if (!list)
-        return NULL;
-    if (list->is_atom)
+        fn = NULL;
+    else if (list->is_atom)
     {
-        struct fml_node *fn = fml_node_alloc (fml);
+        fn = fml_node_alloc (fml);
         fn->is_atom = 1;
         fn->p[0] = list->p[0];
-        return fn;
+        list->is_atom = 0;
+        list->p[0] = NULL;
     }
     else
-        return list->p[0];
+    {
+        fn = list->p[0];
+        list->p[0] = NULL;
+    }
+    fml_node_delete (fml, l);
+    return fn;
 }
 
 static struct fml_node *fml_exec_plus (Fml fml, struct fml_node *l,
@@ -395,7 +391,7 @@ static struct fml_node *fml_exec_plus (Fml fml, struct fml_node *l,
     char arg[20];
     struct fml_node *fn;
 
-    fml_lr_values (l, &left_val, r, &right_val);
+    fml_lr_values (fml, l, &left_val, r, &right_val);
     sprintf (arg, "%d", left_val + right_val);
     fn = fml_node_alloc (fml);
     fn->is_atom = 1;
@@ -410,7 +406,7 @@ static struct fml_node *fml_exec_minus (Fml fml, struct fml_node *l,
     char arg[20];
     struct fml_node *fn;
 
-    fml_lr_values (l, &left_val, r, &right_val);
+    fml_lr_values (fml, l, &left_val, r, &right_val);
     sprintf (arg, "%d", left_val - right_val);
     fn = fml_node_alloc (fml);
     fn->is_atom = 1;
@@ -424,7 +420,7 @@ static struct fml_node *fml_exec_gt (Fml fml, struct fml_node *l,
 {
     int left_val, right_val;
     struct fml_node *fn;
-    fml_lr_values (l, &left_val, r, &right_val);
+    fml_lr_values (fml, l, &left_val, r, &right_val);
     if (left_val > right_val)
     {
         fn = fml_node_alloc (fml);
@@ -442,7 +438,7 @@ static struct fml_node *fml_exec_lt (Fml fml, struct fml_node *l,
 {
     int left_val, right_val;
     struct fml_node *fn;
-    fml_lr_values (l, &left_val, r, &right_val);
+    fml_lr_values (fml, l, &left_val, r, &right_val);
     if (left_val < right_val)
     {
         fn = fml_node_alloc (fml);
@@ -459,7 +455,7 @@ static struct fml_node *fml_exec_eq (Fml fml, struct fml_node *l,
 {
     int left_val, right_val;
     struct fml_node *fn;
-    fml_lr_values (l, &left_val, r, &right_val);
+    fml_lr_values (fml, l, &left_val, r, &right_val);
     if (left_val == right_val)
     {
         fn = fml_node_alloc (fml);
@@ -476,7 +472,7 @@ static struct fml_node *fml_exec_ne (Fml fml, struct fml_node *l,
 {
     int left_val, right_val;
     struct fml_node *fn;
-    fml_lr_values (l, &left_val, r, &right_val);
+    fml_lr_values (fml, l, &left_val, r, &right_val);
     if (left_val != right_val)
     {
         fn = fml_node_alloc (fml);
@@ -493,7 +489,7 @@ static struct fml_node *fml_exec_le (Fml fml, struct fml_node *l,
 {
     int left_val, right_val;
     struct fml_node *fn;
-    fml_lr_values (l, &left_val, r, &right_val);
+    fml_lr_values (fml, l, &left_val, r, &right_val);
     if (left_val <= right_val)
     {
         fn = fml_node_alloc (fml);
@@ -510,7 +506,7 @@ static struct fml_node *fml_exec_ge (Fml fml, struct fml_node *l,
 {
     int left_val, right_val;
     struct fml_node *fn;
-    fml_lr_values (l, &left_val, r, &right_val);
+    fml_lr_values (fml, l, &left_val, r, &right_val);
     if (left_val >= right_val)
     {
         fn = fml_node_alloc (fml);
@@ -597,37 +593,41 @@ static struct fml_node *fml_exec_prefix (struct fml_sym_info *info, Fml fml,
     struct fml_node *return_value;
     static char arg[128];
 
-    if (fml->debug)
+    if (fml->debug & 1)
     {
         pr_indent (1);
         printf ("exec_prefix ");
     }
     fml_sym_push (fml->sym_tab);
+    fml_cmd_lex (lp, tp);
     for (fn = info->args; fn; fn = fn->p[1])
     {
-        fml_cmd_lex (lp, tp);
 
         assert (fn->is_atom);
         fml_atom_strx (fn->p[0], arg, 127);
-        if (fml->debug)
+        if (fml->debug & 1)
         {
-            
             pr_indent (1);
             printf ("%s=", arg);
         }
         arg_info = fml_sym_add_local (fml->sym_tab, arg);
         arg_info->kind = FML_VAR;
-        arg_info->body = fml_lex_list (fml, tp);
-        if (arg_info->body)
-            arg_info->body = fml_sub0 (fml, arg_info->body);
-        if (fml->debug)
+
+        if (tp->kind == 'g')
+        {
+            arg_info->body = fml_sub0 (fml, tp->sub);
+            fml_cmd_lex (lp, tp);
+        }
+        else
+            arg_info->body = fml_sub2 (fml, lp, tp);
+        if (fml->debug & 1)
         {
             fml_pr_list (arg_info->body);
             pr_indent (-1);
         }
     }
     return_value = fml_exec_group (info->body, fml);
-    if (fml->debug)
+    if (fml->debug & 1)
     {
         pr_indent(0);
         pr_indent (-1);
@@ -657,9 +657,6 @@ static void fml_emit (struct fml_node *list)
     }
 }
 
-static struct fml_node *fml_sub1 (Fml fml, struct fml_node **lp,
-                                  struct token *tp);
-
 
 static struct fml_node *fml_sub2 (Fml fml, struct fml_node **lp,
                                   struct token *tp)
@@ -673,12 +670,11 @@ static struct fml_node *fml_sub2 (Fml fml, struct fml_node **lp,
         switch (info->kind)
         {
         case FML_VAR:
-            fn = info->body;
+            fn = fml_node_copy (fml, info->body);           
             fml_cmd_lex (lp, tp);
             break;
         case FML_PREFIX:
             fn = fml_exec_prefix (info, fml, lp, tp);
-            fml_cmd_lex (lp, tp);
             break;
         case FML_CPREFIX:
             fn = (*info->prefix) (fml, lp, tp);
@@ -712,7 +708,7 @@ static struct fml_node *fml_sub2 (Fml fml, struct fml_node **lp,
 static struct fml_node *fml_sub1 (Fml fml, struct fml_node **lp,
                                   struct token *tp)
 {
-    struct fml_node *f1, *f2;
+    struct fml_node *f1, *f2, *fn;
     struct fml_sym_info *info;
 
     f1 = fml_sub2 (fml, lp, tp);
@@ -728,7 +724,8 @@ static struct fml_node *fml_sub1 (Fml fml, struct fml_node **lp,
         {
             fml_cmd_lex (lp, tp);
             f2 = fml_sub2 (fml, lp, tp);
-            f1 = (*info->binary) (fml, f1, f2);
+            fn = (*info->binary) (fml, f1, f2);
+            f1 = fn;
             continue;
         }
         else if (info->kind == FML_BINARY)
@@ -736,7 +733,7 @@ static struct fml_node *fml_sub1 (Fml fml, struct fml_node **lp,
             struct fml_sym_info *arg_info;
             char arg[127];
 
-            if (fml->debug)
+            if (fml->debug & 1)
             {
                 pr_indent (1);
                 printf ("exec binary %s", tp->tokenbuf);
@@ -749,7 +746,7 @@ static struct fml_node *fml_sub1 (Fml fml, struct fml_node **lp,
             arg_info = fml_sym_add_local (fml->sym_tab, arg);
             arg_info->kind = FML_VAR;
             arg_info->body = f1;
-            if (fml->debug)
+            if (fml->debug & 1)
             {
                 printf (" left=");
                 fml_pr_list (f1);
@@ -759,7 +756,7 @@ static struct fml_node *fml_sub1 (Fml fml, struct fml_node **lp,
             arg_info = fml_sym_add_local (fml->sym_tab, arg);
             arg_info->kind = FML_VAR;
             arg_info->body = f2;
-            if (fml->debug)
+            if (fml->debug & 1)
             {
                 printf (" right=");
                 fml_pr_list (f2);
@@ -767,7 +764,7 @@ static struct fml_node *fml_sub1 (Fml fml, struct fml_node **lp,
             }
             f1 = fml_exec_group (info->body, fml);
             fml_do_pop (fml);
-            if (fml->debug)
+            if (fml->debug & 1)
             {
                 pr_indent (0);
                 pr_indent (-1);
@@ -811,6 +808,8 @@ static struct fml_node *fml_sub0 (Fml fml, struct fml_node *list)
     struct token token;
     struct fml_node *fn, *fn0, *fn1;
 
+    if (!list)
+        return NULL;
     fml_init_token (&token, fml);
     assert (list);
     fml_cmd_lex (&list, &token);
@@ -839,7 +838,6 @@ static struct fml_node *fml_sub0 (Fml fml, struct fml_node *list)
 }
 #endif
 
-
 static struct fml_node *fml_exec_foreach (struct fml_sym_info *info, Fml fml,
                                           struct fml_node **lp,
                                           struct token *tp)
@@ -858,35 +856,35 @@ static struct fml_node *fml_exec_foreach (struct fml_sym_info *info, Fml fml,
         info_var->body = NULL;
         info_var->kind = FML_VAR;
     }
-    if (fml->debug)
+    else
+    {
+        fml_node_delete (fml, info->body);
+        info->body = NULL;
+    }
+    if (fml->debug & 1)
     {
         pr_indent (1);
         printf ("[foreach %s ", tp->tokenbuf);
     }
     fml_cmd_lex (lp, tp);
-
-    fn = fml_lex_list (fml, tp);
-    if (fn)
-        fn = fml_sub0 (fml, fn);
+    assert (tp->kind == 'g');
+    fn = fml_sub0 (fml, tp->sub);
  
     fml_cmd_lex (lp, tp);
-
-    body = fml_lex_list (fml, tp);
+    assert (tp->kind == 'g');
+    body = tp->sub;
  
     while (fn)
     {
+        struct fml_node *fn1;
+
+        fn1 = fn->p[1];
+        fn->p[1] = NULL;
         if (fn->is_atom)
-        {
-            struct fml_node *fn1;
-            fn1 = fml_node_alloc (fml);
-            fn1->is_atom=1;
-            fn1->p[0] = fn->p[0];
-            info_var->body = fn1;
-        }
+            info_var->body = fn;
         else
             info_var->body = fn->p[0];
-
-        if (fml->debug)
+        if (fml->debug & 1)
         {
             pr_indent (1);
             printf ("[foreach loop var=");
@@ -896,9 +894,11 @@ static struct fml_node *fml_exec_foreach (struct fml_sym_info *info, Fml fml,
         rv = fml_exec_group (body, fml);
         if (rv)
             return_value = rv;
-        fn = fn->p[1];
+        fml_node_delete (fml, fn);
+        fn = fn1;
     }
-    if (fml->debug)
+    info_var->body = NULL;
+    if (fml->debug & 1)
         pr_indent (-1);
     return return_value;
 }
@@ -910,14 +910,13 @@ static struct fml_node *fml_exec_if (struct fml_sym_info *info, Fml fml,
     struct fml_node *rv, *return_value = NULL;
 
     fml_cmd_lex (lp, tp);
-    fn = fml_lex_list (fml, tp);
-    if (fn)
-        fn = fml_sub0 (fml, fn);
+    assert (tp->kind == 'g');
+    fn = fml_sub0 (fml, tp->sub);
     fml_cmd_lex (lp, tp);
+    assert (tp->kind == 'g');
     if (fn)
     {
-        body = fml_lex_list (fml, tp);
-        rv = fml_exec_group (body, fml);
+        rv = fml_exec_group (tp->sub, fml);
         if (rv)
             return_value = rv;
     }
@@ -928,16 +927,18 @@ static struct fml_node *fml_exec_if (struct fml_sym_info *info, Fml fml,
         if (info->kind == FML_ELSE)
         {
             fml_cmd_lex (lp, tp);
-            body = fml_lex_list (fml, tp);
-            fml_cmd_lex (lp, tp);
+            assert (tp->kind == 'g');
+            body = tp->sub;
             if (!fn)
             {
                 rv = fml_exec_group (body, fml);
                 if (rv)
                     return_value = rv;
             }
+            fml_cmd_lex (lp, tp);
         }
     }
+    fml_node_delete (fml, fn);
     return return_value;
 }
 
@@ -948,10 +949,13 @@ static struct fml_node *fml_exec_while (struct fml_sym_info *info, Fml fml,
     struct fml_node *return_value = NULL;
 
     fml_cmd_lex (lp, tp);
-    fn = fml_lex_list (fml, tp);
+    assert (tp->kind == 'g');
+    fn = tp->sub;
 
     fml_cmd_lex (lp, tp);
-    body = fml_lex_list (fml, tp);
+    assert (tp->kind == 'g');
+    body = tp->sub;
+    assert (tp->sub);
     while (1)
     {
         struct fml_node *fn_expr;
@@ -961,6 +965,7 @@ static struct fml_node *fml_exec_while (struct fml_sym_info *info, Fml fml,
         fn_expr = fml_sub0 (fml, fn);
         if (!fn_expr)
             break;
+        fml_node_delete (fml, fn_expr);
         rv = fml_exec_group (body, fml);
         if (rv)
             return_value = rv;
@@ -973,7 +978,7 @@ static void fml_exec_set (struct fml_sym_info *info, Fml fml,
 {
     struct fml_node *fn;
     struct fml_sym_info *info_var;
-
+    
     fml_cmd_lex (lp, tp);
     info_var = fml_sym_lookup_local (fml->sym_tab, tp->tokenbuf);
     if (!info_var)
@@ -981,19 +986,24 @@ static void fml_exec_set (struct fml_sym_info *info, Fml fml,
         info_var = fml_sym_add_local (fml->sym_tab, tp->tokenbuf);
         info_var->body = NULL;
     }
-    if (fml->debug)
+    if (fml->debug & 1)
     {
         pr_indent (1);
         printf ("set %s ", tp->tokenbuf);
     }
     info_var->kind = FML_VAR;
     fml_cmd_lex (lp, tp);
-    fn = fml_lex_list (fml, tp);
-    assert (fn);
-    if (fn)
-        fn = fml_sub0 (fml, fn);
+
+    if (tp->kind == 'g')
+    {
+        fn = fml_sub0 (fml, tp->sub);
+        fml_cmd_lex (lp, tp);
+    }
+    else
+        fn = fml_sub2 (fml, lp, tp);
+    fml_node_delete (fml, info_var->body); 
     info_var->body = fn;
-    if (fml->debug)
+    if (fml->debug & 1)
     {
         fml_pr_list (info_var->body);
         pr_indent (-1);
@@ -1006,6 +1016,7 @@ static void fml_emit_expr (Fml fml, struct fml_node **lp, struct token *tp)
 
     fn = fml_sub1 (fml, lp, tp);
     fml_emit (fn);
+    fml_node_delete (fml, fn);
 }
 
 static struct fml_node *fml_exec_group (struct fml_node *list, Fml fml)
@@ -1089,28 +1100,14 @@ static struct fml_node *fml_exec_group (struct fml_node *list, Fml fml)
                     assert (token.kind == 'g');
                     info->body = token.sub;
                     break;
-#if 0
-                case FML_PREFIX:
-                    after_char = token.after_char;
-                    fml_exec_prefix (info, fml, &list, &token);
-                    if (after_char)
-                        putchar (after_char);
-                    break;
-                case FML_VAR:
-                    fml_emit (info->body);
-                    if (token.after_char)
-                        putchar (token.after_char);
-                    break;
-#endif
                 case FML_VAR:
                 case FML_PREFIX:
                 case FML_CPREFIX:
                     if (token.separate && !first)
-                    {
                         putchar (' ');
-                    }
                     first = 1;
                     fml_emit_expr (fml, &list, &token);
+                    fml_node_stat (fml);
                     continue;
                 case FML_FOREACH:
                     rv = fml_exec_foreach (info, fml, &list, &token);
@@ -1124,7 +1121,8 @@ static struct fml_node *fml_exec_group (struct fml_node *list, Fml fml)
                     continue;
                 case FML_SET:
                     fml_exec_set (info, fml, &list, &token);
-                    break;
+                    fml_node_stat (fml);
+                    continue;
                 case FML_WHILE:
                     rv = fml_exec_while (info, fml, &list, &token);
                     if (rv)
@@ -1132,17 +1130,22 @@ static struct fml_node *fml_exec_group (struct fml_node *list, Fml fml)
                     break;
                 case FML_RETURN:
                     fml_cmd_lex (&list, &token);
-                    return_value = fml_lex_list (fml, &token);
-                    if (return_value)
-                        return_value = fml_sub0 (fml, return_value);
-                    if (fml->debug)
+
+                    if (token.kind == 'g')
+                    {
+                        return_value = fml_sub0 (fml, token.sub);
+                        fml_cmd_lex (&list, &token);
+                    }
+                    else
+                        return_value = fml_sub2 (fml, &list, &token);
+                    if (fml->debug & 1)
                     {
                         pr_indent (1);
                         printf ("return of:");
                         fml_pr_list (return_value);
                         pr_indent (-1);
                     }
-                    break;
+                    continue;
                 default:
                     printf ("unknown token: `%s'", token.tokenbuf);
                     fml_cmd_lex (&list, &token);
@@ -1161,6 +1164,7 @@ static struct fml_node *fml_exec_group (struct fml_node *list, Fml fml)
                 putchar (' ');
             first = 0;
             fml_emit_expr (fml, &list, &token);
+            fml_node_stat (fml);
             continue;
         }
         fml_cmd_lex (&list, &token);
@@ -1171,8 +1175,9 @@ static struct fml_node *fml_exec_group (struct fml_node *list, Fml fml)
 
 void fml_exec (Fml fml)
 {
+    fml_node_stat (fml);
     fml_exec_group (fml->list, fml);
-    if (fml->debug)
+    if (fml->debug & 1)
         printf ("\n");
 }
 
diff --git a/fml/fmlmem.c b/fml/fmlmem.c
index 65c1650..7d12da0 100644
--- a/fml/fmlmem.c
+++ b/fml/fmlmem.c
@@ -2,7 +2,10 @@
  * FML interpreter. Europagate, 1995
  *
  * $Log: fmlmem.c,v $
- * Revision 1.2  1995/02/06 15:23:26  adam
+ * Revision 1.3  1995/02/09 13:07:15  adam
+ * Nodes are freed now. Many bugs fixed.
+ *
+ * Revision 1.2  1995/02/06  15:23:26  adam
  * Added some more relational operators (le,ne,ge). Added increment
  * and decrement operators. Function index changed, so that first
  * element is 1 - not 0. Function fml_atom_val edited.
@@ -22,6 +25,9 @@
 #define FML_ATOM_CHUNK 1024
 #define FML_NODE_CHUNK 1024
 
+static int no_nodes = 0;
+static int no_atoms = 0;
+
 struct fml_node *fml_node_alloc (Fml fml)
 {
     struct fml_node *n;
@@ -44,6 +50,7 @@ struct fml_node *fml_node_alloc (Fml fml)
     fml->node_free_list = n->p[1];
     n->p[0] = n->p[1] = NULL;
     n->is_atom = 0;
+    no_nodes++;
     return n;
 }
 
@@ -67,6 +74,7 @@ static struct fml_atom *atom_malloc (Fml fml)
     }
     fa = fml->atom_free_list;
     fml->atom_free_list = fa->next;
+    no_atoms++;
     return fa;
 }
 
@@ -74,6 +82,7 @@ static void atom_delete (Fml fml, struct fml_atom *a)
 {
     a->next = fml->atom_free_list;
     fml->atom_free_list = a;
+    no_atoms--;
 }
 
 static struct fml_atom *atom_copy (Fml fml, struct fml_atom *a)
@@ -83,7 +92,7 @@ static struct fml_atom *atom_copy (Fml fml, struct fml_atom *a)
     a0 = a1 = atom_malloc (fml);
     while (a)
     {
-        memcpy (&a1->buf, &a->buf, FML_ATOM_CHUNK);
+        memcpy (&a1->buf, &a->buf, FML_ATOM_BUF);
         if (!a->next)
             break;
         a = a->next;
@@ -186,6 +195,7 @@ void fml_node_delete (Fml fml, struct fml_node *fn)
         
         fn->p[1] = fml->node_free_list;
         fml->node_free_list = fn;
+        no_nodes--;
 
         fn = f1;
     }
@@ -214,3 +224,9 @@ struct fml_node *fml_node_copy (Fml fml, struct fml_node *fn)
     }
     return fn0;
 }
+
+void fml_node_stat (Fml fml)
+{
+    if (fml->debug & 2)
+        printf ("<<node=%d, atom=%d>>", no_nodes, no_atoms);
+}
diff --git a/fml/fmlp.h b/fml/fmlp.h
index 5431986..8af3fcc 100644
--- a/fml/fmlp.h
+++ b/fml/fmlp.h
@@ -2,7 +2,10 @@
  * FML interpreter. Europagate, 1995
  *
  * $Log: fmlp.h,v $
- * Revision 1.2  1995/02/07 16:09:23  adam
+ * Revision 1.3  1995/02/09 13:07:15  adam
+ * Nodes are freed now. Many bugs fixed.
+ *
+ * Revision 1.2  1995/02/07  16:09:23  adam
  * The \ character is no longer INCLUDED when terminating a token.
  * Major changes in tokenization routines. Bug fixes in expressions
  * with lists (fml_sub0).
@@ -42,7 +45,6 @@ struct fml_node *fml_node_copy (Fml fml, struct fml_node *fn);
 struct token {
     int             kind;
     int             separate;
-    int             after_char;
     int             maxbuf;
     int             offset;
     char            *atombuf;
@@ -77,6 +79,7 @@ void fml_sym_push (struct fml_sym_tab *tab);
 void fml_sym_pop (struct fml_sym_tab *tab, void(*ph)(struct fml_sym_info *i));
 
 void fml_pr_list (struct fml_node *p);
+void fml_node_stat (Fml fml);
 
 #define FML_FUNC     1
 #define FML_IF       2
diff --git a/fml/fmltest.c b/fml/fmltest.c
index 1947ba2..6c07b3a 100644
--- a/fml/fmltest.c
+++ b/fml/fmltest.c
@@ -2,7 +2,10 @@
  * FML interpreter. Europagate, 1995
  *
  * $Log: fmltest.c,v $
- * Revision 1.2  1995/02/07 16:09:24  adam
+ * Revision 1.3  1995/02/09 13:07:15  adam
+ * Nodes are freed now. Many bugs fixed.
+ *
+ * Revision 1.2  1995/02/07  16:09:24  adam
  * The \ character is no longer INCLUDED when terminating a token.
  * Major changes in tokenization routines. Bug fixes in expressions
  * with lists (fml_sub0).
@@ -35,7 +38,9 @@ int main (int argc, char **argv)
         if (**argv == '-')
         {
             if (argv[0][1] == 'd')
-                fml->debug = 1;
+                fml->debug |= 1;
+            else if (argv[0][1] == 'm')
+                fml->debug |= 2;
             else
             {
                 fprintf (stderr, "uknown option `%s'\n", *argv);
diff --git a/fml/lists.fml b/fml/lists.fml
index 346628a..217179e 100644
--- a/fml/lists.fml
+++ b/fml/lists.fml
@@ -1,9 +1,9 @@
 # FML list inspection
 #
-# $Id: lists.fml,v 1.1 1995/02/07 16:09:24 adam Exp $
+# $Id: lists.fml,v 1.2 1995/02/09 13:07:15 adam Exp $
 \set months {Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec}
 \set days   {31  28  31  30  31  30  31  31  30  31  30  31}
-\foreach m \months
+\foreach m {\months}
   {Month: \m\n}
 \set i 1
 Number of days in every month:\n
diff --git a/fml/tempo.fml b/fml/tempo.fml
index a323912..e2e9ac8 100644
--- a/fml/tempo.fml
+++ b/fml/tempo.fml
@@ -1,6 +1,6 @@
 # FML tempo test
 #
-# $Id: tempo.fml,v 1.1 1995/02/06 13:48:09 adam Exp $
+# $Id: tempo.fml,v 1.2 1995/02/09 13:07:16 adam Exp $
 \set x 1 
 \set max 10000 
-\while {\x \lt 10000} {\set x {\x \plus 1}}
+\while {\x \lt \max} {\incr \x}