#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef enum { STR, ADD, MUL, MUA, LOP, PNZ, PUT, GET, RTN } op_t;
typedef struct { int size; void *obj; } seq_t;
typedef struct _op {
void *code;
int16_t offset;
int16_t val;
int16_t opt;
seq_t loop;
} Op;
typedef struct _vm {
char* ptr;
char data[31000];
seq_t ops;
} Vm;
#define op_at(x,y) ((Op*)((x)->obj))[y]
static void op_push_back( seq_t *ops, const Op *item )
{
ops->size += 1;
if (ops->obj == NULL) {
ops
->obj
= malloc (sizeof(Op
)); } else {
ops
->obj
= realloc (ops
->obj
, sizeof(Op
)*ops
->size
); }
op_at(ops,ops->size - 1) = *item;
}
static void op_delete( seq_t *ops )
{
if(ops->obj != NULL) {
for(int i=0;i<ops->size;i++)
op_delete(&op_at(ops,i).loop);
ops->obj = NULL;
}
}
static void** eval(Vm *self, seq_t *ops)
{
static const void* const jump[] = { &&PROC_STR, &&PROC_ADD, &&PROC_MUL, &&PROC_MUA,
&&PROC_LOP, &&PROC_PNZ, &&PROC_PUT, &&PROC_GET,
&&PROC_RTN};
if(self == NULL) return (void**)jump;
char *pos = self->ptr;
Op *op=&op_at(ops,0);
goto *op->code;
#define NEXT_PROC goto *(++op)->code;
PROC_STR:
pos[op->offset] = op->val;
NEXT_PROC;
PROC_ADD:
pos[op->offset] += op->val;
NEXT_PROC;
PROC_MUL:
if (op->val == 1) pos[op->offset] = pos[op->opt];
else if (op->val == -1) pos[op->offset] = -pos[op->opt];
else pos[op->offset] = op->val * pos[op->opt];
NEXT_PROC;
PROC_MUA:
if (op->val == 1) pos[op->offset] += pos[op->opt];
else if (op->val == -1) pos[op->offset] -= pos[op->opt];
else pos[op->offset] += op->val * pos[op->opt];
NEXT_PROC;
PROC_LOP:
self->ptr = pos + op->opt;
while(*self->ptr) {
eval(self, &op->loop);
self->ptr += op->offset;
}
pos = self->ptr;
NEXT_PROC;
PROC_PNZ:
pos += op->opt;
while(*pos) pos += op->offset;
NEXT_PROC;
PROC_PUT:
printf("%c", pos
[op
->offset
]); /*fflush(stdout);*/
NEXT_PROC;
PROC_GET:
pos
[op
->offset
] = getc(stdin
); NEXT_PROC;
PROC_RTN:
self->ptr = pos;
return (void**)jump;
}
static void append_str (seq_t *ops, int16_t dst, int16_t val, void **table) {
bool done = false;
for (int i = ops->size; --i >= 0;) {
Op *it = &op_at(ops,i);
if (it->offset == dst && (it->code == table[STR] || it->code == table[ADD]
|| it->code == table[MUL] || it->code == table[MUA])) {
it->code = table[STR];
it->val = val;
it->opt = 0;
done = true;
break;
} else if (it->code == table[LOP] || it->code == table[PNZ]) {
if (dst == 0 && val == 0)
done = true;
break;
} else if (it->offset == dst || (it->opt == dst
&& (it->code == table[MUL] || it->code == table[MUA]))) {
break;
}
}
if (!done) {
Op op = { table[STR], dst, val, 0, { 0, NULL } };
op_push_back ( ops, &op );
}
}
static void append_add (seq_t *ops, int16_t dst, int16_t val, void **table) {
bool done = false;
for (int i = ops->size; --i >= 0;) {
Op *it = &op_at(ops,i);
if (it->code == table[LOP] || it->code == table[PNZ]) {
if (dst == 0) {
Op op = {table[STR], dst, val, 0, { 0, NULL } };
op_push_back ( ops, &op );
done = true;
}
break;
} else if (it->offset == dst) {
if (it->code == table[STR] || it->code == table[ADD]) {
it->val += val;
done = true;
}
break;
} else if (it->opt == dst &&
(it->code == table[MUL] || it->code == table[MUA])) {
break;
}
}
if (!done) {
Op op = { table[ADD], dst, val, 0, { 0, NULL } };
op_push_back ( ops, &op );
}
}
static void append_mua (seq_t *ops, int16_t dst, int16_t val, int16_t src, void **table) {
bool done = false;
for (int i = ops->size; --i >= 0;) {
Op *it = &op_at(ops,i);
if (it->code == table[LOP] || it->code == table[PNZ]) {
if (dst == 0) {
Op op = { table[MUL], dst, val, src, { 0, NULL } };
op_push_back ( ops, &op );
done = true;
}
break;
} else if (it->offset == dst && it->opt == src
&& (it->code == table[MUL] || it->code == table[MUA])) {
it->val += val;
done = true;
break;
} else if (it->code == table[STR] && it->offset == dst && it->val == 0) {
it->code = table[MUL];
it->val = val;
it->opt = src;
done = true;
break;
} else if (it->offset == dst || it->offset == src) {
break;
}
}
if (!done) {
Op op = { table[MUA], dst, val, src, { 0, NULL } };
op_push_back ( ops, &op );
}
}
static void append (seq_t *ops, op_t opc, int16_t dst, int16_t val,
int16_t src, seq_t *loop, void **table) {
Op op = { table[opc], dst, val, src, { loop?loop->size:0, loop?loop->obj:NULL } };
op_push_back ( ops, &op );
}
static seq_t parse( const char *text, const size_t len, int *it )
{
void** tbl = eval( NULL, NULL );
seq_t ops = { 0, NULL };
int pos = 0;
while ((size_t)*it < len) {
switch (text[(*it)++]) {
case '+': append_add( &ops, pos, 1, tbl); break;
case '-': append_add( &ops, pos, -1, tbl); break;
case '>': pos++; break;
case '<': pos--; break;
case '.': append( &ops, PUT, pos, 0, 0, NULL, tbl); break;
case ',': append( &ops, GET, pos, 0, 0, NULL, tbl); break;
case '[': {
int iter = *it;
char ch = text[iter++];
while (ch=='+' || ch=='-' ||
(ch!='>' && ch!='<' && ch!='.' && ch!='.' && ch!='[' && ch!=']'))
ch = text[iter++];
if (ch==']') {
append_str( &ops, pos, 0, tbl);
*it = iter;
break;
}
int ost = 0;
iter = *it;
ch = text[iter++];
while (ch=='>' || ch=='<' ||
(ch!='+' && ch!='-' && ch!='.' && ch!='.' && ch!='[' && ch!=']')) {
if (ch=='>') ost+=1; else if (ch=='<') ost-=1;
ch = text[iter++];
}
if (ch == ']') {
append( &ops, PNZ, ost, 0, pos, NULL, tbl);
*it = iter;
pos = 0;
break;
}
seq_t loop = parse(text,len,it);
op_t opc = MUA;
for (int i=0; i<loop.size; i++) {
Op *op = &op_at(&loop,i);
if (op->code == tbl[MUL] || op->code == tbl[MUA]) {
int j = loop.size;
while (--j >= 0) {
if (op_at(&loop,j).offset == op->opt)
break;
}
if (j >= 0) {
opc = LOP;
break;
}
} else if (op->code == tbl[STR]) {
if (op->offset == 0 && op->val == 0) {
opc = LOP;
break;
}
} else if (op->code == tbl[RTN]) {
if (op->offset != 0) {
opc = LOP;
break;
}
} else if (op->code != tbl[ADD]) {
opc = LOP;
break;
}
}
if (opc == MUA) {
int shrink = 0;
for (int i=0; i<loop.size; i++) {
Op *op = &op_at(&loop,i);
if (shrink != 0)
op_at(&loop,i-shrink) = *op;
if (op->code == tbl[ADD]) {
if (op->offset != 0 || op->val != -1)
append_mua (&ops, op->offset+pos, op->val, pos, tbl);
shrink++;
}
}
if (shrink != 0) loop.size -= shrink;
if (loop.size > 1) {
op_at(&loop,loop.size).code = tbl[RTN];
op_at(&loop,loop.size).offset = op_at(&loop,loop.size-1).offset;
op_at(&loop,loop.size-1).code = tbl[STR];
op_at(&loop,loop.size-1).offset = 0;
op_at(&loop,loop.size-1).val = 0;
loop.size += 1;
opc = LOP;
} else
append_str(&ops, pos, 0, tbl);
}
if (opc == LOP) {
ost = 0;
if (op_at(&loop,loop.size-1).code == tbl[RTN]) {
ost = op_at(&loop,loop.size-1).offset;
}
append(&ops, opc, ost, 0, pos, &loop, tbl );
pos = 0;
}
}
break;
case ']':
append( &ops, RTN, pos, 0, 0, NULL, tbl);
return ops;
}
}
append( &ops, RTN, 0, 0, 0, NULL, tbl);
return ops;
}
static void vminit(Vm *self, char *text, const size_t len)
{
int it = 0;
self->ops = parse(text, len, &it);
}
static void run(Vm *self)
{
memset( self
->data
, 0, sizeof(self
->data
)); self->ptr = self->data + 1000;
eval(self, &self->ops);
}
static char* read_file (const char* filename, size_t *length){
FILE
*stream
= fopen(filename
, "r"); fseek(stream
, 0, SEEK_END
); char* text
= (char*) malloc(*length
); if (fread(text
, *length
, 1, stream
) == 0) puts("read error"); return text;
}
int main(int argc, char** argv){
size_t length;
char *text;
if(argc<=1) {
text
= (char*) malloc (1000000); length
= fread (text
, 1, 1000000, stdin
); } else {
text = read_file(argv[1], &length);
}
Vm vm;
vminit(&vm, text, length);
run(&vm);
op_delete(&vm.ops);
return 0;
}
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


typedef enum { STR, ADD, MUL, MUA, LOP, PNZ, PUT, GET, RTN } op_t;

typedef struct { int size; void *obj; } seq_t;

typedef struct _op {
    void *code;
    int16_t offset;
    int16_t val;
    int16_t opt;
    seq_t loop;
} Op;

typedef struct _vm {
    char* ptr;
    char data[31000];
    seq_t ops;
} Vm;

#define op_at(x,y) ((Op*)((x)->obj))[y]

static void op_push_back( seq_t *ops, const Op *item )
{
    ops->size += 1;
    if (ops->obj == NULL) {
        ops->obj = malloc (sizeof(Op));
    } else {
        ops->obj = realloc (ops->obj, sizeof(Op)*ops->size);
    }
    op_at(ops,ops->size - 1) = *item;
}

static void op_delete( seq_t *ops )
{
    if(ops->obj != NULL) {
        for(int i=0;i<ops->size;i++)
            op_delete(&op_at(ops,i).loop);
        free(ops->obj);
        ops->obj = NULL;
    }
}

static void** eval(Vm *self, seq_t *ops)
{
    static const void* const jump[] = { &&PROC_STR, &&PROC_ADD, &&PROC_MUL, &&PROC_MUA,
                                        &&PROC_LOP, &&PROC_PNZ, &&PROC_PUT, &&PROC_GET,
                                        &&PROC_RTN};
    if(self == NULL) return (void**)jump;

    char *pos = self->ptr;
    Op *op=&op_at(ops,0);

    goto *op->code;
#define NEXT_PROC goto *(++op)->code;

PROC_STR:
    pos[op->offset] = op->val;
    NEXT_PROC;

PROC_ADD:
    pos[op->offset] += op->val;
    NEXT_PROC;

PROC_MUL:
    if (op->val == 1) pos[op->offset] = pos[op->opt];
    else if (op->val == -1) pos[op->offset] = -pos[op->opt];
    else pos[op->offset] = op->val * pos[op->opt];
    NEXT_PROC;

PROC_MUA:
    if (op->val == 1) pos[op->offset] += pos[op->opt];
    else if (op->val == -1) pos[op->offset] -= pos[op->opt];
    else pos[op->offset] += op->val * pos[op->opt];
    NEXT_PROC;

PROC_LOP:
    self->ptr = pos + op->opt;
    while(*self->ptr) {
        eval(self, &op->loop);
        self->ptr += op->offset;
    }
    pos = self->ptr;
    NEXT_PROC;

PROC_PNZ:
    pos += op->opt;
    while(*pos) pos += op->offset;
    NEXT_PROC;

PROC_PUT:
    printf("%c", pos[op->offset]);
    /*fflush(stdout);*/
    NEXT_PROC;

PROC_GET:
    pos[op->offset] = getc(stdin);
    NEXT_PROC;

PROC_RTN:
    self->ptr = pos;
    return (void**)jump;
}

static void append_str (seq_t *ops, int16_t dst, int16_t val, void **table) {
    bool done = false;
    for (int i = ops->size; --i >= 0;) {
        Op *it = &op_at(ops,i);
        if (it->offset == dst && (it->code == table[STR] || it->code == table[ADD]
                    || it->code == table[MUL] || it->code == table[MUA])) {
            it->code = table[STR];
            it->val = val;
            it->opt = 0;
            done = true;
            break;
        } else if (it->code == table[LOP] || it->code == table[PNZ]) {
            if (dst == 0 && val == 0)
                done = true;
            break;
        } else if (it->offset == dst || (it->opt == dst
                && (it->code == table[MUL] || it->code == table[MUA]))) {
            break;
        }
    }
    if (!done) {
        Op op = { table[STR], dst, val, 0, { 0, NULL } };
        op_push_back ( ops, &op );
    }
}

static void append_add (seq_t *ops, int16_t dst, int16_t val, void **table) {
    bool done = false;
    for (int i = ops->size; --i >= 0;) {
        Op *it = &op_at(ops,i);
        if (it->code == table[LOP] || it->code == table[PNZ]) {
            if (dst == 0) {
                Op op = {table[STR], dst, val, 0, { 0, NULL } };
                op_push_back ( ops, &op );
                done = true;
            }
            break;
        } else if (it->offset == dst) {
            if (it->code == table[STR] || it->code == table[ADD]) {
                it->val += val;
                done = true;
            }
            break;
        } else if (it->opt == dst &&
                (it->code == table[MUL] || it->code == table[MUA])) {
            break;
        }
    }
    if (!done) {
        Op op = { table[ADD], dst, val, 0, { 0, NULL } };
        op_push_back ( ops, &op );
    }
}

static void append_mua (seq_t *ops, int16_t dst, int16_t val, int16_t src, void **table) {
    bool done = false;
    for (int i = ops->size; --i >= 0;) {
        Op *it = &op_at(ops,i);
        if (it->code == table[LOP] || it->code == table[PNZ]) {
            if (dst == 0) {
                Op op = { table[MUL], dst, val, src, { 0, NULL } };
                op_push_back ( ops, &op );
                done = true;
            }
            break;
        } else if (it->offset == dst && it->opt == src
                && (it->code == table[MUL] || it->code == table[MUA])) {
            it->val += val;
            done = true;
            break;
        } else if (it->code == table[STR] && it->offset == dst && it->val == 0) {
            it->code = table[MUL];
            it->val = val;
            it->opt = src;
            done = true;
            break;
        } else if (it->offset == dst || it->offset == src) {
            break;
        }
    }
    if (!done) {
        Op op = { table[MUA], dst, val, src, { 0, NULL } };
        op_push_back ( ops, &op );
    }
}

static void append (seq_t *ops, op_t opc, int16_t dst, int16_t val,
        int16_t src, seq_t *loop, void **table) {
    Op op = { table[opc], dst, val, src, { loop?loop->size:0, loop?loop->obj:NULL } };
    op_push_back ( ops, &op );
}

static seq_t parse( const char *text, const size_t len, int *it )
{
    void** tbl = eval( NULL, NULL );

    seq_t ops = { 0, NULL };
    int pos = 0;
    while ((size_t)*it < len) {
        switch (text[(*it)++]) {
        case '+': append_add( &ops, pos, 1, tbl); break;
        case '-': append_add( &ops, pos, -1, tbl); break;
        case '>': pos++; break;
        case '<': pos--; break;
        case '.': append( &ops, PUT, pos, 0, 0, NULL, tbl); break;
        case ',': append( &ops, GET, pos, 0, 0, NULL, tbl); break;
        case '[': {
                int iter = *it;
                char ch = text[iter++];
                while (ch=='+' || ch=='-' ||
                    (ch!='>' && ch!='<' && ch!='.' && ch!='.' && ch!='[' && ch!=']'))
                    ch = text[iter++];
                if (ch==']') {
                    append_str( &ops, pos, 0, tbl);
                    *it = iter;
                    break;
                }

                int ost = 0;
                iter = *it;
                ch = text[iter++];
                while (ch=='>' || ch=='<' ||
                    (ch!='+' && ch!='-' && ch!='.' && ch!='.' && ch!='[' && ch!=']')) {
                    if (ch=='>') ost+=1; else if (ch=='<') ost-=1;
                    ch = text[iter++];
                }
                if (ch == ']') {
                    append( &ops, PNZ, ost, 0, pos, NULL, tbl);
                    *it = iter;
                    pos = 0;
                    break;
                }

                seq_t loop = parse(text,len,it);
                op_t opc = MUA;

                for (int i=0; i<loop.size; i++) {
                    Op *op = &op_at(&loop,i);
                    if (op->code == tbl[MUL] || op->code == tbl[MUA]) {
                        int j = loop.size;
                        while (--j >= 0) {
                            if (op_at(&loop,j).offset == op->opt)
                                break;
                        }
                        if (j >= 0) {
                            opc = LOP;
                            break;
                        }
                    } else if (op->code == tbl[STR]) {
                        if (op->offset == 0 && op->val == 0) {
                            opc = LOP;
                            break;
                        }
                    } else if (op->code == tbl[RTN]) {
                        if (op->offset != 0) {
                            opc = LOP;
                            break;
                        }
                    } else if (op->code != tbl[ADD]) {
                        opc = LOP;
                        break;
                    }
                }

                if (opc == MUA) {
                    int shrink = 0;
                    for (int i=0; i<loop.size; i++) {
                        Op *op = &op_at(&loop,i);
                        if (shrink != 0)
                            op_at(&loop,i-shrink) = *op;
                        if (op->code == tbl[ADD]) {
                            if (op->offset != 0 || op->val != -1)
                                append_mua (&ops, op->offset+pos, op->val, pos, tbl);
                            shrink++;
                        }
                    }

                    if (shrink != 0) loop.size -= shrink;
                    if (loop.size > 1) {
                        op_at(&loop,loop.size).code = tbl[RTN];
                        op_at(&loop,loop.size).offset = op_at(&loop,loop.size-1).offset;
                        op_at(&loop,loop.size-1).code = tbl[STR];
                        op_at(&loop,loop.size-1).offset = 0;
                        op_at(&loop,loop.size-1).val = 0;
                        loop.size += 1;
                        opc = LOP;
                    } else
                        append_str(&ops, pos, 0, tbl);
                }

                if (opc == LOP) {
                    ost = 0;
                    if (op_at(&loop,loop.size-1).code == tbl[RTN]) {
                        ost = op_at(&loop,loop.size-1).offset;
                    }
                    append(&ops, opc, ost, 0, pos, &loop, tbl );
                    pos = 0;
                }
            }
            break;
        case ']':
            append( &ops, RTN, pos, 0, 0, NULL, tbl);
            return ops;
        }
    }
    append( &ops, RTN, 0, 0, 0, NULL, tbl);
    return ops;
}

static void vminit(Vm *self, char *text, const size_t len)
{
    int it = 0;
    self->ops = parse(text, len, &it);
}

static void run(Vm *self)
{
    memset( self->data, 0, sizeof(self->data));
    self->ptr = self->data + 1000;
    eval(self, &self->ops);
}

static char* read_file (const char* filename, size_t *length){
    FILE *stream = fopen(filename, "r");
    fseek(stream, 0, SEEK_END);
    *length = ftell(stream);
    rewind(stream);
    char* text = (char*) malloc(*length);
    if (fread(text, *length, 1, stream) == 0) puts("read error");
    fclose(stream);
    return text;
}

int main(int argc, char** argv){
    size_t length;
    char *text;
    if(argc<=1) {
        text = (char*) malloc (1000000);
        length = fread (text, 1, 1000000, stdin);
    } else {
        text = read_file(argv[1], &length);
    }
    Vm vm;
    vminit(&vm, text, length);
    run(&vm);
    op_delete(&vm.ops);
    return 0;
}
