0.1.4

1 files changed, 236 insertions, 235 deletions

diff --git a/src/execute.c b/src/execute.c
index ffadc3c..b0a29cd 100644
--- a/src/execute.c
+++ b/src/execute.c
@@ -20,7 +20,7 @@
  *
  */
 
-/* $Id: execute.c,v 1.25 2005/10/05 16:06:11 timo Exp $ */
+/* $Id: execute.c,v 1.27 2005/10/14 13:23:20 timo Exp $ */
 
 #include "bbe.h"
 #include <stdlib.h>
@@ -35,21 +35,14 @@ static int delete_this_byte;
 /* tells if current block should be deleted */
 static int delete_this_block;
 
+/* tells if current block should be skipped */
+static int skip_this_block;
+
 /* tells if i or s commands are inserting bytes, meaningfull at end of the block */
 static int inserting;
 
 /* command list for write_w_command */
-static struct command *current_commands;
-
-/* commands to be executed at start of buffer */
-/* note J and L must be in every string becaus ethey affect the whole block */
-#define BLOCK_START_COMMANDS "DIJLFBN"
-
-/* commands to be executed for each byte  */
-#define BYTE_COMMANDS "acdirsywjplJL&|^~"
-
-/* commands to be executed at end of buffer  */
-#define BLOCK_END_COMMANDS "AJL"
+static struct command_list *current_byte_commands;
 
 /* most significant bit of byte */
 #define BYTE_MASK (1 << (sizeof(unsigned char) * 8 - 1))
@@ -63,7 +56,6 @@ byte_to_string(unsigned char byte,char format)
 {
     static char string[128];
     int i;
-    int j;
 
     switch(format)
     {
@@ -124,76 +116,75 @@ off_t_to_string(off_t number,char format)
 
 /* execute given commands */
 void
-execute_commands(struct command *c,char *command_letters)
+execute_commands(struct command_list *c)
 {
     register int i;
     unsigned char a,b;
     unsigned char *p;
     char *str;
 
+    if(skip_this_block) return;
     while(c != NULL)
     {
-        if(strchr(command_letters,c->letter) !=  NULL)
+        switch(c->letter)
         {
-            switch(c->letter)
-            {
-                case 'A':
-                case 'I':
-                    write_buffer(c->s1,c->s1_len);
-                    break;
-                case 'd':
-                    if(c->rpos || c->offset == in_buffer.block_offset) 
-                    {
-                        if(c->rpos < c->count)
-                        {
-                            delete_this_byte = 1;
-                            c->rpos++;
-                        } else
-                        {
-                            c->rpos = 0;
-                        }
-                    }
-                    break;
-                case 'D':
-                    if(c->offset == in_buffer.block_num || c->offset == 0) delete_this_block = 1;
-                    break;
-                case 'i':
-                    if(c->offset == in_buffer.block_offset && !c->rpos) 
-                    {
-                        c->rpos = 1;
-                        inserting = 1;
-                        break;
-                    } 
-                    if(c->rpos > 0 && c->rpos <= c->s1_len)
+            case 'A':
+            case 'I':
+                write_buffer(c->s1,c->s1_len);
+                break;
+            case 'd':
+                if(c->rpos || c->offset == in_buffer.block_offset) 
+                {
+                    if(c->rpos < c->count)
                     {
-                        if(c->rpos <= c->s1_len)
-                        {
-                            put_byte(c->s1[c->rpos - 1]);
-                            if(c->rpos < c->s1_len) inserting = 1;
-                        }
+                        delete_this_byte = 1;
                         c->rpos++;
+                    } else
+                    {
+                        c->rpos = 0;
                     }
+                }
+                break;
+            case 'D':
+                if(c->offset == in_buffer.block_num || c->offset == 0) delete_this_block = 1;
+                break;
+            case 'i':
+                if(c->offset == in_buffer.block_offset && !c->rpos) 
+                {
+                    c->rpos = 1;
+                    inserting = 1;
                     break;
-                case 'r':
-                    if(in_buffer.block_offset >= c->offset &&
-                       in_buffer.block_offset < c->offset + c->s1_len)
+                } 
+                if(c->rpos > 0 && c->rpos <= c->s1_len)
+                {
+                    if(c->rpos <= c->s1_len)
                     {
-                        put_byte(c->s1[in_buffer.block_offset - c->offset]);
+                        put_byte(c->s1[c->rpos - 1]);
+                        if(c->rpos < c->s1_len) inserting = 1;
                     }
-                    break;
-                case 's':
-                    if(c->rpos)
+                    c->rpos++;
+                }
+                break;
+            case 'r':
+                if(in_buffer.block_offset >= c->offset &&
+                        in_buffer.block_offset < c->offset + c->s1_len)
+                {
+                    put_byte(c->s1[in_buffer.block_offset - c->offset]);
+                }
+                break;
+            case 's':
+                if(c->rpos)
+                {
+                    if(c->rpos < c->s1_len && c->rpos < c->s2_len)
                     {
-                        if(c->rpos < c->s1_len && c->rpos < c->s2_len)
-                        {
-                            put_byte(c->s2[c->rpos]);
-                        } else if (c->rpos < c->s1_len && c->rpos >= c->s2_len)
-                        {
-                            delete_this_byte = 1;
-                        } else if(c->rpos >= c->s1_len && c->rpos < c->s2_len)
-                        {
-                            put_byte(c->s2[c->rpos]);
-                        } 
+                        put_byte(c->s2[c->rpos]);
+                    } else if (c->rpos < c->s1_len && c->rpos >= c->s2_len)
+                    {
+                        delete_this_byte = 1;
+                    } else if(c->rpos >= c->s1_len && c->rpos < c->s2_len)
+                    {
+                        put_byte(c->s2[c->rpos]);
+                    } 
 
                         if(c->rpos >= c->s1_len - 1 && c->rpos < c->s2_len - 1)
                         {
@@ -206,178 +197,179 @@ execute_commands(struct command *c,char *command_letters)
                             c->rpos = 0;
                         }
                         break;
-                    }
-                    if(delete_this_byte) break;
-                    p = out_buffer.write_pos;
-                    i = 0;
-                    while(*p == c->s1[i] && i < c->s1_len)
+                }
+                if(delete_this_byte) break;
+                p = out_buffer.write_pos;
+                i = 0;
+                while(*p == c->s1[i] && i < c->s1_len)
+                {
+                    if(p == out_buffer.write_pos) p = read_pos();
+                    if(p == block_end_pos() && c->s1_len - 1 > i) break;
+                    i++;
+                    p++;
+                }
+                if(i == c->s1_len) 
+                {
+                    if(c->s1_len > 1 || c->s2_len > 1) c->rpos = 1;
+                    if(c->s2_len) 
                     {
-                        if(p == out_buffer.write_pos) p = read_pos();
-                        if(p == block_end_pos() && c->s1_len - 1 > i) break;
-                        i++;
-                        p++;
-                    }
-                    if(i == c->s1_len) 
+                        put_byte(c->s2[0]);
+                        if(c->s1_len == 1 && c->s2_len > 1) inserting = 1;
+                    } else
                     {
-                        if(c->s1_len > 1 || c->s2_len > 1) c->rpos = 1;
-                        if(c->s2_len) 
-                        {
-                            put_byte(c->s2[0]);
-                            if(c->s1_len == 1 && c->s2_len > 1) inserting = 1;
-                        } else
-                        {
-                            delete_this_byte = 1;
-                        }
+                        delete_this_byte = 1;
                     }
-                    break;
-                case 'y':
-                    i = 0;
-                    while(c->s1[i] != *out_buffer.write_pos && i < c->s1_len) i++;
-                    if(c->s1[i] == *out_buffer.write_pos && i < c->s1_len) put_byte(c->s2[i]);
-                    break;
-                case 'c':
-                    switch(c->s1[0])
-                    {
-                        case 'A':                   // from ascii
-                            switch(c->s1[3])
-                            {
-                                case 'B':           // to bcd
-                                    if(c->rpos || (last_byte() && out_buffer.block_offset == 0))     // skip first nibble
-                                    {
-                                        c->rpos = 0;
-                                        if(last_byte())  // unless last byte of block
-                                        {
-                                            if(*out_buffer.write_pos >= '0' && *out_buffer.write_pos <= '9') 
-                                            {
-                                                a = *out_buffer.write_pos - '0';
-                                                a = (a << 4) & 0xf0;
-                                                b = 0x0f;
-                                                *out_buffer.write_pos = a | b;
-                                            }
-                                        }
-                                        break;
-                                    }
-                                    if(out_buffer.block_offset == 0 || delete_this_byte) break;
-                                    if((out_buffer.write_pos[-1] >= '0' && out_buffer.write_pos[-1] <= '9'))
+                }
+                break;
+            case 'y':
+                i = 0;
+                while(c->s1[i] != *out_buffer.write_pos && i < c->s1_len) i++;
+                if(c->s1[i] == *out_buffer.write_pos && i < c->s1_len) put_byte(c->s2[i]);
+                break;
+            case 'c':
+                switch(c->s1[0])
+                {
+                    case 'A':                   // from ascii
+                        switch(c->s1[3])
+                        {
+                            case 'B':           // to bcd
+                                if(c->rpos || (last_byte() && out_buffer.block_offset == 0))     // skip first nibble
+                                {
+                                    c->rpos = 0;
+                                    if(last_byte())  // unless last byte of block
                                     {
-                                        a = out_buffer.write_pos[-1] - '0';
-                                        a = (a << 4) & 0xf0;
-                                        if(*out_buffer.write_pos >= '0' && *out_buffer.write_pos <= '9')
-                                        {
-                                            b = *out_buffer.write_pos - '0';
-                                            b &= 0x0f;
-                                            delete_this_byte = 1;
-                                            c->rpos = 1;
-                                        } else
+                                        if(*out_buffer.write_pos >= '0' && *out_buffer.write_pos <= '9') 
                                         {
+                                            a = *out_buffer.write_pos - '0';
+                                            a = (a << 4) & 0xf0;
                                             b = 0x0f;
-                                            if(*out_buffer.write_pos == 'F' || *out_buffer.write_pos == 'f') delete_this_byte=1;
+                                            *out_buffer.write_pos = a | b;
                                         }
-                                        out_buffer.write_pos[-1] = a | b;
                                     }
                                     break;
-                            }
-                            break;
-                        case 'B':               // from bcd
-                            switch(c->s1[3])
-                            {
-                                case 'A':       // to ascii
-                                    if(((*out_buffer.write_pos >> 4) & 0x0f) <= 9 && 
-                                            ((*out_buffer.write_pos & 0x0f) <= 9 || (*out_buffer.write_pos & 0x0f) == 0x0f))
+                                }
+                                if(out_buffer.block_offset == 0 || delete_this_byte) break;
+                                if((out_buffer.write_pos[-1] >= '0' && out_buffer.write_pos[-1] <= '9'))
+                                {
+                                    a = out_buffer.write_pos[-1] - '0';
+                                    a = (a << 4) & 0xf0;
+                                    if(*out_buffer.write_pos >= '0' && *out_buffer.write_pos <= '9')
+                                    {
+                                        b = *out_buffer.write_pos - '0';
+                                        b &= 0x0f;
+                                        delete_this_byte = 1;
+                                        c->rpos = 1;
+                                    } else
                                     {
-                                        a = (*out_buffer.write_pos >> 4) & 0x0f;
-                                        b = *out_buffer.write_pos & 0x0f;
-                                        *out_buffer.write_pos = '0' + a;
-                                        if(!delete_this_byte) 
+                                        b = 0x0f;
+                                        if(*out_buffer.write_pos == 'F' || *out_buffer.write_pos == 'f') delete_this_byte=1;
+                                    }
+                                    out_buffer.write_pos[-1] = a | b;
+                                }
+                                break;
+                        }
+                        break;
+                    case 'B':               // from bcd
+                        switch(c->s1[3])
+                        {
+                            case 'A':       // to ascii
+                                if(((*out_buffer.write_pos >> 4) & 0x0f) <= 9 && 
+                                        ((*out_buffer.write_pos & 0x0f) <= 9 || (*out_buffer.write_pos & 0x0f) == 0x0f))
+                                {
+                                    a = (*out_buffer.write_pos >> 4) & 0x0f;
+                                    b = *out_buffer.write_pos & 0x0f;
+                                    *out_buffer.write_pos = '0' + a;
+                                    if(!delete_this_byte) 
+                                    {
+                                        write_next_byte();
+                                        if(b == 0x0f)
+                                        {
+                                            *out_buffer.write_pos = 'F';
+                                        } else
                                         {
-                                            write_next_byte();
-                                            if(b == 0x0f)
-                                            {
-                                                *out_buffer.write_pos = 'F';
-                                            } else
-                                            {
-                                                *out_buffer.write_pos = '0' + b;
-                                            }
+                                            *out_buffer.write_pos = '0' + b;
                                         }
                                     }
-                                    break;
-                            }
-                            break;
-                    }
-                    break;
-                case 'j':
-                    if(in_buffer.block_offset < c->count)
-                    {
-                        while(c->next != NULL) c = c->next;     // skip rest of commands
-                    }
-                    break;
-                case 'J':
-                    if(in_buffer.block_num <= c->count)
-                    {
-                        while(c->next != NULL) c = c->next;     // skip rest of commands
-                    }
-                    break;
-                case 'l':
-                    if(in_buffer.block_offset >= c->count)
-                    {
-                        while(c->next != NULL) c = c->next;     // skip rest of commands
-                    }
-                    break;
-                case 'L':
-                    if(in_buffer.block_num > c->count)
-                    {
-                        while(c->next != NULL) c = c->next;     // skip rest of commands
-                    }
-                    break;
-                case 'p':
-                    if (delete_this_byte) break;
-                    i = 0;
-                    a = *out_buffer.write_pos;
-                    while(i < c->s1_len)
-                    {
-                        str = byte_to_string(a,c->s1[i]);
-                        write_string(str);
-                        i++;
-                        if (i < c->s1_len) 
-                        {
-                            put_byte('-');
-                            write_next_byte();
+                                }
+                                break;
                         }
-                    }
-                    put_byte(' ');
-                    break;
-                case 'F':
-                    str = off_t_to_string(in_buffer.stream_offset + (off_t) (in_buffer.read_pos-in_buffer.buffer),c->s1[0]);
-                    write_string(str);
-                    put_byte(':');
-                    write_next_byte();
-                    break;
-                case 'B':
-                    str = off_t_to_string(in_buffer.block_num,c->s1[0]);
+                        break;
+                }
+                break;
+            case 'j':
+                if(in_buffer.block_offset < c->count)
+                {
+                    while(c->next != NULL) c = c->next;     // skip rest of commands
+                }
+                break;
+            case 'J':
+                if(in_buffer.block_num <= c->count)
+                {
+                    skip_this_block = 1;
+                    return;
+                }
+                break;
+            case 'l':
+                if(in_buffer.block_offset >= c->count)
+                {
+                    while(c->next != NULL) c = c->next;     // skip rest of commands
+                }
+                break;
+            case 'L':
+                if(in_buffer.block_num > c->count)
+                {
+                    skip_this_block = 1;
+                    return;
+                }
+                break;
+            case 'p':
+                if (delete_this_byte) break;
+                i = 0;
+                a = *out_buffer.write_pos;
+                while(i < c->s1_len)
+                {
+                    str = byte_to_string(a,c->s1[i]);
                     write_string(str);
-                    put_byte(':');
-                    write_next_byte();
-                    break;
-                case 'N':
-                    write_string(get_current_file());
-                    put_byte(':');
-                    write_next_byte();
-                    break;
-                case '&':
-                    put_byte(*out_buffer.write_pos & c->s1[0]);
-                    break;
-                case '|':
-                    put_byte(*out_buffer.write_pos | c->s1[0]);
-                    break;
-                case '^':
-                    put_byte(*out_buffer.write_pos ^ c->s1[0]);
-                    break;
-                case '~':
-                    put_byte(~*out_buffer.write_pos);
-                    break;
-                case 'w':
-                    break;
-            }
+                    i++;
+                    if (i < c->s1_len) 
+                    {
+                        put_byte('-');
+                        write_next_byte();
+                    }
+                }
+                put_byte(' ');
+                break;
+            case 'F':
+                str = off_t_to_string(in_buffer.stream_offset + (off_t) (in_buffer.read_pos-in_buffer.buffer),c->s1[0]);
+                write_string(str);
+                put_byte(':');
+                write_next_byte();
+                break;
+            case 'B':
+                str = off_t_to_string(in_buffer.block_num,c->s1[0]);
+                write_string(str);
+                put_byte(':');
+                write_next_byte();
+                break;
+            case 'N':
+                write_string(get_current_file());
+                put_byte(':');
+                write_next_byte();
+                break;
+            case '&':
+                put_byte(*out_buffer.write_pos & c->s1[0]);
+                break;
+            case '|':
+                put_byte(*out_buffer.write_pos | c->s1[0]);
+                break;
+            case '^':
+                put_byte(*out_buffer.write_pos ^ c->s1[0]);
+                break;
+            case '~':
+                put_byte(~*out_buffer.write_pos);
+                break;
+            case 'w':
+                break;
         }
         c = c->next;
     }
@@ -387,9 +379,9 @@ execute_commands(struct command *c,char *command_letters)
 void
 write_w_command(unsigned char *buf,size_t length)
 {
-    struct command *c;
+    struct command_list *c;
 
-    c = current_commands;
+    c = current_byte_commands;
 
     while(c != NULL)
     {
@@ -405,8 +397,12 @@ write_w_command(unsigned char *buf,size_t length)
 
 /* init_commands, initialize those wich need it, currently w - open file and rpos=0 for all */
 void
-init_commands(struct command *c)
+init_commands(struct commands *commands)
 {
+    struct command_list *c;
+
+    c = commands->byte;
+
     while(c != NULL)
     {
         switch(c->letter)
@@ -423,8 +419,12 @@ init_commands(struct command *c)
 
 /* close_commands, close those wich need it, currently w - close file */
 void
-close_commands(struct command *c)
+close_commands(struct commands *commands)
 {
+    struct command_list *c;
+
+    c = commands->byte;
+
     while(c != NULL)
     {
         switch(c->letter)
@@ -439,7 +439,7 @@ close_commands(struct command *c)
 
 /* reset the rpos counter for next block, in case block was shorter eg. delete count */
 inline void
-reset_rpos(struct command *c)
+reset_rpos(struct command_list *c)
 {
     while(c != NULL)
     {
@@ -452,18 +452,19 @@ reset_rpos(struct command *c)
 
 /* main execution loop */
 void
-execute_program(struct command *c)
+execute_program(struct commands *commands)
 {
     int block_end;
 
-    current_commands = c;
+    current_byte_commands = commands->byte;
 
     while(find_block())
     {
-        reset_rpos(c);
+        reset_rpos(commands->byte);
         delete_this_block = 0;
         out_buffer.block_offset = 0;
-        execute_commands(c,BLOCK_START_COMMANDS);
+        skip_this_block = 0;
+        execute_commands(commands->block_start);
         do
         {
             set_cycle_start();
@@ -471,14 +472,14 @@ execute_program(struct command *c)
             inserting = 0;
             block_end = last_byte();
             put_byte(read_byte());     // as default write current byte from input
-            execute_commands(c,BYTE_COMMANDS);
+            execute_commands(commands->byte);
             if(!delete_this_byte && !delete_this_block)
             {
                write_next_byte();           // advance the write pointer if byte is not marked for del
             }
             if(!block_end && !inserting) get_next_byte();
         } while (!block_end || inserting);
-        execute_commands(c,BLOCK_END_COMMANDS);
+        execute_commands(commands->block_end);
         flush_buffer();
     }
     close_output_stream();