// list.c
typedef struct list list;
struct node {
    struct node *prev;
    int val;
    struct node *jump;
    struct node *next;
};
typedef struct node node;
node *newnode();
node *append(node *n);
node *prepend(node *n);
void erase(node *n);
int pop(node *n);
// op.c
void doop(node *n);
node *link(node *n);

#include <stdlib.h>
#include "bf.h"

node *newnode() {
    node *n = malloc(sizeof(node));
    n->prev = n->next = 0;
    n->jump = n->val = 0;
    return n;
}

node *append(node *n) {
    n->next = newnode();
    n->next->prev = n;
    return n->next;
}

node *prepend(node *n) {
    n->prev = newnode();
    n->prev->next = n;
    return n->prev;
}

void erase(node *n) {
    node *m;
    while (n->prev)
        n = n->prev;
    while (n->next) {
        m = n->next;
        free(n);
        n = m;
    }
}

int pop(node *n) {
    int ret;
    if (n->prev)
        n->prev->next = n->next;
    if (n->next)
        n->next->prev = n->prev;
    ret = n->val;
    free(n);
    return ret;
}

#include <stdio.h>
#include "bf.h"

#define LSEEK       '<'
#define RSEEK       '>'
#define INCREMENT   '+'
#define DECREMENT   '-'
#define STDOUT      '.'
#define STDIN       ','
#define LBRACKET    '['
#define RBRACKET    ']'

char mem[30000] = { 0 };
char *ptr = mem;

void doop(node *n) {
    node *m = n;
    while (m) {
        switch (m->val) {
            case LSEEK:
                ptr--;
                break;
            case RSEEK:
                ptr++;
                break;
            case INCREMENT:
                (*ptr)++;
                break;
            case DECREMENT:
                (*ptr)--;
                break;
            case STDOUT:
                printf("%c", *ptr);
                fflush(stdout);
                break;
            case STDIN:
                *ptr = getchar();
                break;
            case LBRACKET:
                if (!*ptr)
                    m = m->jump;
                break;
            case RBRACKET:
                if (*ptr)
                    m = m->jump;
                break;
        }
        m = m->next;
    }
}

node *link(node *n) {
    node *m = n;
    node *links = newnode();
    while (m) {
        switch (m->val) {
            case LBRACKET:
                if (links->jump)
                    links = append(links);
                links->jump = m;
                break;
            case RBRACKET:
                m->jump = links->jump;
                links->jump->jump = m;
                if (links->prev) {
                    links = links->prev;
                    pop(links->next);
                }
                break;
        }
        m = m->next;
    }
    erase(links);
    return n;
}

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include "bf.h"

int run = 1;

void quit(int val) {
    run = 0;
}

int main(int argc, char** argv) {
    signal(SIGINT, quit);
    int c;
    node *text, *text_start;
    if (argc > 1) {
        printf("%sn", argv[1]);
        FILE *f = fopen(argv[1], "r");
        if (f == NULL) return 1;
        text = text_start = newnode();
        while ((c = fgetc(f)) != EOF) {
            if (text->val)
                text = append(text);
            text->val = c;
        }
        doop(link(text_start));
        erase(text_start);
        run = 0;
    }
    while (run) {
        text = text_start = newnode();
        while ((c = getchar()) != 'n') {
            if (text->val)
                text = append(text);
            text->val = c;
        }
        doop(link(text_start));
        erase(text_start);
    }
    return 0;
}