fix many little bugs, release 0.1

[umpf.git] / int.c

diff --git a/int.c b/int.c
index 60c40d502356c74e94a0080dda1ba1a46c3c42f5..d5a39bfadc8f58d06a81c16a4196a7a802799df2 100644 (file)
--- a/int.c
+++ b/int.c
@@ -42,6 +42,18 @@ bye(int code, char* msg, ...)
         exit(code);
 }
 
+static void
+set_modif_flag(int var, int flag)
+{
+       var_tab[var].modif = flag;
+}
+
+static int
+get_modif_flag(int var)
+{
+       return var_tab[var].modif;
+}
+
 void
 free_string(char* c)
 {
@@ -52,49 +64,47 @@ free_string(char* c)
 static void
 clear_var(int var)
 {
-       if ((var_tab[var] != NULL))
-               free_string(var_tab[var]);
+       if ((var_tab[var].value != NULL))
+               free_string(var_tab[var].value);
+       var_tab[var].modif = 0;
 }
 
 static void
 set_var(int var, char* value)
 {
        clear_var(var);
-       var_tab[var] = xstrdup(value);
+       var_tab[var].modif = 1;
+       var_tab[var].value = xstrdup(value);
 }
 
 void
 set_cur_mail_length_var(int len, struct list* hash)
 {
-       char* buf;
        struct variable* pv;
+       char buf[INT_TO_STRING_LEN];
 
        pv = get_var_struct(INT_VAR_MAIL_LEN, VAR_INTERN, hash);
 
        if (! pv) /* user is not interested */
                return;
 
-       buf = xmalloc(INT_TO_STRING_LEN);
        sprintf(buf,"%d", len);
        set_var(pv->varcode, buf);
-       free_string(buf);
 }
 
 static void
 set_exit_code_var(int code, struct list* hash)
 {
-       char* buf;
        struct variable* pv;
+       char buf[INT_TO_STRING_LEN];
 
        pv = get_var_struct(INT_VAR_LAST_EXIT, VAR_INTERN, hash);
 
        if (! pv) /* user is not interested */
                return;
 
-       buf = xmalloc(INT_TO_STRING_LEN);
        sprintf(buf,"%d", code);
        set_var(pv->varcode, buf);
-       free_string(buf);
 }
 
 static void
@@ -114,7 +124,15 @@ get_var(int var)
 {
        if (var < 0)
                return xstrdup(const_tab[-var]);
-       return xstrdup(var_tab[var]);
+       return xstrdup(var_tab[var].value);
+}
+
+static char*
+get_var_nc(int var)
+{
+       if (var < 0)
+               return const_tab[-var];
+       return var_tab[var].value;
 }
 
 static int 
@@ -158,7 +176,7 @@ fold(const char* value, int taken)
        int i;
        char* ret; 
        int len = strlen(value);
-       int newlines[len / 78 + 5];
+       int newlines[len / 40 + 5];
        int newl = 0;
        int curr_ws = -1;
        int pos = 0;
@@ -191,9 +209,9 @@ fold(const char* value, int taken)
                if(i != newlines[newl_done])
                        ret[pos++] = value[i];
                else {
-                       newl++;
+                       newl_done++;
                        ret[pos++] = '\n';
-                       ret[pos++] = ' ';
+                       ret[pos++] = '\t';
                }
        }
        return ret;
@@ -242,23 +260,23 @@ modify_headers(struct list* headers, struct list* hash)
                if (!pv)
                        continue;
                u = unfold(p->value);
-               value = get_var(pv->varcode);
+               value = get_var_nc(pv->varcode);
                if (strcmp(u, value)){
-                       pv->modified = 0;
+                       set_modif_flag(pv->varcode, 0);
                        free_string(p->value);
                        p->value = fold(value,
                                 strlen(p->name) + 2);
                }
                free_string(u);
-               free_string(value);
        }
 
        // find new headers 
        for (i = 0; i < HASHSIZE; i++){
                LIST_FOREACH(pv, hash + i){
-                       if (pv->type == VAR_HEADER && pv->modified){
-                               pv->modified = 0;
+                       if (pv->type == VAR_HEADER && 
+                               get_modif_flag(pv->varcode)){
 
+                               set_modif_flag(pv->varcode, 0);
                                p = xmalloc(sizeof(struct hlist));
                                p->name = xstrdup(pv->name);
                                p->value = get_var(pv->varcode);
@@ -344,8 +362,8 @@ destroy_email(struct email em)
 static void
 do_string_ternary_op(struct code* p)
 {
-       char* l = get_var(p->u.tpop.l);
-       char* r = get_var(p->u.tpop.r);
+       char* l = get_var_nc(p->u.tpop.l);
+       char* r = get_var_nc(p->u.tpop.r);
        char* result;
 
        switch(p->opcode) {
@@ -363,18 +381,18 @@ do_string_ternary_op(struct code* p)
                default:
                        break;
        };
-
+       free_string(result);
        set_var(p->u.tpop.res, result); 
 }
 
 static void
 do_num_ternary_op(struct code* p)
 {
-       int l, r, res;
+       int l = 0, r = 0, res;
        char* result = xmalloc(INT_TO_STRING_LEN);
 
-       sscanf(get_var(p->u.tpop.l),"%d", &l);
-       sscanf(get_var(p->u.tpop.r),"%d", &r);
+       sscanf(get_var_nc(p->u.tpop.l),"%d", &l);
+       sscanf(get_var_nc(p->u.tpop.r),"%d", &r);
 
        switch(p->opcode) {
                case OPC_GT:
@@ -421,13 +439,14 @@ do_num_ternary_op(struct code* p)
        }
 
        sprintf(result, "%d", res);
+       free_string(result);
        set_var(p->u.tpop.res, result);
 }
 
 static int
 eval_cond(int var)
 {
-       char* val = get_var(var);
+       char* val = get_var_nc(var);
        int v;
 
        if (! val)
@@ -476,7 +495,8 @@ send_mail(char* where, int copy, struct list* hash)
                dup(pd[0]);     
                close(pd[0]);
                //FIXME From?
-               res = execl("/usr/lib/sendmail", "sendmail", where, NULL);
+               execl("/usr/lib/sendmail", "sendmail", where, NULL);
+               exit(1);
        }
        close(pd[0]);
        write_email_to_fd(pd[1], &em); 
@@ -533,7 +553,8 @@ pipe_to(char* program, struct email* em)
                close(pd_out[1]);
                close(pd_in[1]);
                close(pd_out[0]);
-               res = execl("/bin/sh", "sh", "-c", program, NULL);
+               execl("/bin/sh", "sh", "-c", program, NULL);
+               exit(1);
        }
        close(pd_in[0]);
        close(pd_out[1]);
@@ -556,8 +577,11 @@ pipe_to(char* program, struct email* em)
                                break;
                        write(fd, buf, r);
                }
-               if (pfd[0].revents & POLLHUP)
+               if (pfd[0].revents & POLLHUP) {
+                       if (e)
+                               free_string(e);
                        break;
+               }
 
                if (nfds < 2)
                        continue;
@@ -690,29 +714,29 @@ interp(struct list* ins, struct list* hash)
        char* result;
        int v;
 
-       LIST_FOREACH(p, ins) {
+       p = (void*) ins->head.next; 
+       while ((struct node*) p != &ins->head) {
        switch (p->opcode) {
                case OPC_SET:
-                       result = get_var(p->u.set.r);
+                       result = get_var_nc(p->u.set.r);
                        set_var(p->u.set.l, result);
-                       free_string(result);
                        break;  
                case OPC_JUMP:
                        p = p->u.jump.target;
-                       continue;
-                       break;
+                       continue;       
                case OPC_JUMP_IF:
-                       if (eval_cond(p->u.jump_if.cond))
+                       if (eval_cond(p->u.jump_if.cond)) {
                                p = p->u.jump_if.target;
-                       continue;
+                               continue;       
+                       }
                        break;
                case OPC_JUMP_UNLESS:
-                       if (!eval_cond(p->u.jump_unless.cond))
+                       if (!eval_cond(p->u.jump_unless.cond)) {
                                p = p->u.jump_unless.target;
-                       continue;
+                               continue;       
+                       }
                        break;
                case OPC_NOP:
-                       continue;
                        break;
                case OPC_GT:
                case OPC_LT:
@@ -731,7 +755,7 @@ interp(struct list* ins, struct list* hash)
                        break;
                case OPC_NOT:
                        result = xmalloc(INT_TO_STRING_LEN);
-                       sscanf(get_var(p->u.dpop.par),"%d", &v);
+                       sscanf(get_var_nc(p->u.dpop.par),"%d", &v);
                        sprintf(result, "%d", !v);
                        set_var(p->u.dpop.res, result);
                        free_string(result);
@@ -742,23 +766,25 @@ interp(struct list* ins, struct list* hash)
                        do_string_ternary_op(p);
                        break;
                case OPC_PIPE:
-                       do_pipe(get_var(p->u.arrow.what), hash);
+                       do_pipe(get_var_nc(p->u.arrow.what), hash);
                        break;
                case OPC_FILTER:
-                       do_filter(get_var(p->u.arrow.what), hash);
+                       do_filter(get_var_nc(p->u.arrow.what), hash);
                        break;
                case OPC_MAIL:
-                       send_mail(get_var(p->u.arrow.what), 
+                       send_mail(get_var_nc(p->u.arrow.what), 
                                p->u.arrow.copy, hash);
                        break;
                case OPC_DELIVER:
-                       deliver(get_var(p->u.arrow.what), 
+                       deliver(get_var_nc(p->u.arrow.what), 
                                p->u.arrow.copy, hash);
                        break;
                case OPC_DISCARD:
                        bye(0, NULL);
                        break;
-       }}
+       }
+               p = (void*) ((struct node*) p)->next;
+       }
        deliver(default_mailbox, 0, hash);
 }
 
@@ -770,7 +796,7 @@ print_vars(struct list* hash)
 
        for (i=0; i<HASHSIZE; i++){
                LIST_FOREACH(p, hash + i)
-                       printf("%s=%s\n",p->name, get_var(p->varcode));
+                       printf("%s=%s\n",p->name, get_var_nc(p->varcode));
        }
 }
 
@@ -788,7 +814,7 @@ save_current_headers(struct list* hash)
                u = unfold(p->value);
                set_var(pv->varcode, u);
                free_string(u);
-               pv->modified = 0;
+               set_modif_flag(pv->varcode, 0);
                p->have_var = 1;
        }
 }