#include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <math.h>
 
 struct sf_machine {
     size_t cs_size;
     unsigned char *buf;
     unsigned char *dp;
     size_t buflen;
     unsigned char flags_hlt;
     unsigned char *ip_stack[1024]; /* stack for handling instruction pointer */
     unsigned char **ip; /* current position in ip_stack */
 };
 
 typedef enum {
     INT_HLT = 0,
     INT_PRT = 1,
     INT_PRTC = 2,
     INT_GETC = 3
 } interrupt_t;
 
 void sf_dump(struct sf_machine *sys, const char *pre_msg, const char *post_msg) {
     size_t i, highest_offset;
 
         for (i = (sys->buflen - 1); i; i--) {
                 if (sys->buf[i]) {
                         highest_offset = i + 1;
                         break;
                 }
         }
 
     printf("********************************\n");
     if (pre_msg) {
         printf("%s\n", pre_msg);
     }
     printf("IPI = %i (%c)\n", (*sys->ip)[0], (*sys->ip)[0]);
     printf("IPA = %i\n", (*sys->ip)[1]);
     printf("IP = %llu\n", (unsigned long long) (*sys->ip - sys->buf) - 1);
     printf("DP = %llu\n", (unsigned long long) (sys->dp - sys->buf) - 1);
         printf("Contents of the buffer:\n");
         for (i = (sys->cs_size + 1 + 1024); i < highest_offset; i++) {
                 if ((i % 18) == 0) {
                         printf("   ");
                 }
                 printf("%c%3i,", ' ', sys->buf[i]);
                 if (((i + 1) % 18) == 0) {
                         printf("\n");
                 }
         }
         if (((i + 1) % 18) != 0) {
                 printf("\n");
         }
 
         printf("\n");
     if (post_msg) {
         printf("%s\n", post_msg);
     }
 }
 
 int sys_loadimage(const char *filename, struct sf_machine *sys) {
     unsigned char tmpbuf;
     size_t fread_ret;
     FILE *fp;
 
     fp = fopen(filename, "r");
     if (!fp) {
         return(-1);
     }
 
     fread_ret = fread(&tmpbuf, 1, 1, fp);
     if (fread_ret != 1) {
         fclose(fp);
         return(-1);
     }
 
     sys->cs_size = pow(2, tmpbuf) * 1024;
     /*
      * 640K ought to be enough for anybody.
      */
     sys->buflen = 1 + sys->cs_size + 1024 + (640 * 1024);
     sys->buf = malloc(sys->buflen);
     if (!sys->buf) {
         fclose(fp);
         return(-1);
     }
 
     memset(sys->buf, 0, sys->buflen);
 
     sys->buf[0] = tmpbuf;
     sys->ip_stack[0] = sys->buf + 1;
     sys->ip = sys->ip_stack;
     sys->dp = sys->buf + 1 + sys->cs_size + 1024;
 
     sys->buf++;
     while (1) {
         fread_ret = fread(sys->buf, 1, 8192, fp);
         if (fread_ret <= 0) {
             break;
         }
         sys->buf += fread_ret;
     }
 
     sys->buf = *sys->ip - 1;
     sys->flags_hlt = 0;
 
     fclose(fp);
 
     if (fread_ret < 0) {
         return(-1);
     }
 
     return(0);
 }
 
 void call_int(struct sf_machine *sys, unsigned char interrupt) {
     switch ((interrupt_t) interrupt) {
         case INT_HLT:
             sys->flags_hlt = 1;
             break;
         case INT_PRT:
             printf("%s", sys->dp);
             break;
         case INT_PRTC:
             printf("%c", sys->dp[0]);
             break;
         case INT_GETC:
             sys->dp[0] = getchar();
             break;
     }
 
     return;
 }
 
 void sys_run(struct sf_machine *sys) {
     unsigned char *buf;
     unsigned char ipi, ipa;
     unsigned long iv, iv_loc;
     long test_depth;
 
     buf = sys->buf;
 
     while (1) {
         ipi = (*sys->ip)[0];
         ipa = (*sys->ip)[1];
 
         switch (ipi) {
             case '+':
                 (*sys->dp) += ipa;
                 break;
             case '-':
                 (*sys->dp) -= ipa;
                 break;
             case '>':
                 sys->dp += ipa;
                 break;
             case '<':
                 sys->dp -= ipa;
                 break;
             case '[':
                 if (!*sys->dp) {
                     /*
                      * If the value at (dp) is 0 then:
                      * Move IP to the matching close brace
                      * instruction
                      */
                     test_depth = 1;
                     while (test_depth) {
                         (*sys->ip)++;
                         if (**sys->ip == '[') {
                             test_depth++;
                         } else if (**sys->ip == ']') {
                             test_depth--;
                         }
                     }
                 }   
                 break;
             case ']':
                 if (*sys->dp) {
                     /*
                      * If the value at (dp) is non-zero then:
                      * Move IP to the matching open brace
                      * instruction.
                      */
                     test_depth = -1;
                     while (test_depth) {
                         (*sys->ip)--;
                         if(**sys->ip == '[') {
                             test_depth++;
                         } else if (**sys->ip == ']') {
                             test_depth--;
                         }
                     }
                 }
                 break;
             case '*':
                 iv_loc = sys->cs_size + 1 + (ipa * 4);
                 iv = sys->buf[iv_loc] << 24;
                 iv |= sys->buf[iv_loc + 1] << 16;
                 iv |= sys->buf[iv_loc + 2] << 8;
                 iv |= sys->buf[iv_loc + 3];
 
                 if (iv) {
                     sys->ip++;
                     *sys->ip = sys->buf + iv - 2;
                 } else {
                     call_int(sys, ipa);
                 }
                 break;
             case '!':
                 sys->ip--;
                 break;
             default:
                 sys->flags_hlt = 1;
                 break;
         }
 
         if (sys->flags_hlt) {
             break;
         }
 
         (*sys->ip) += 2;
     }
 
     return;
 }
 
 int main(int argc, char **argv) {
     struct sf_machine sf_sys;
     char *image_name;
     int retval;
 
     if (argc != 2) {
         fprintf(stderr, "Usage: sf <image>\n");
         return(EXIT_FAILURE);
     }
 
     image_name = argv[1];
 
     retval = sys_loadimage(image_name, &sf_sys);
     if (retval < 0) {
         fprintf(stderr, "Error loading image.\n");
         return(EXIT_FAILURE);
     }
 
     sys_run(&sf_sys);
 
     fprintf(stderr, "***** HALTED *****\n");
 
     sf_dump(&sf_sys, NULL, NULL);
 
     return(EXIT_SUCCESS);
 }