script = { transformation ";" } ;
transformation = [ T_IDENTIFIER "." ] T_IDENTIFIER "(" transformation_args ")" ;
transformation_args = [ literal { "," literal } ] ;
literal = T_INTEGER | T_FLOATING | T_STRING | T_IDENTIFIER ;

struct ast_position {
    uint32_t row;
    uint32_t col;
};
enum ast_literal_type {
    L_INTEGER,
    L_FLOATING,
    L_STRING,
    L_IDENTIFIER
};
struct ast_literal {
    enum ast_literal_type type;
    char * value;
    struct ast_position pos;
};
struct ast_transformation_args {
    struct ast_literal argument;
    struct ast_transformation_args * next;
};
struct ast_transformation {
    char * module;
    char * name;
    struct ast_transformation_args * args;
    struct ast_position pos;
};
struct ast_script {
    struct ast_transformation transformation;
    struct ast_script * next;
};

file
    : script YYEOF  { *result = ast_script_reverse($1); }
    ;
script
    : /* empty */               { $$ = NULL; }
    | script transformation ';' { $$ = ast_script_new($2, $1); }
    ;
transformation
    : T_IDENTIFIER '(' transformation_args ')'                  {
        $$ = ast_transformation_create(NULL, $1, ast_transformation_args_reverse($3),
                ast_position_create(@$.first_line, @$.first_column));
    }
    | T_IDENTIFIER '.' T_IDENTIFIER '(' transformation_args ')' {
        $$ = ast_transformation_create($1, $3, ast_transformation_args_reverse($5),
                ast_position_create(@$.first_line, @$.first_column));
    }
    ;
transformation_args
    : /* empty */               { $$ = NULL; }
    | transformation_args_req   { $$ = $1; }
    ;
transformation_args_req
    : literal                               { $$ = ast_transformation_args_new($1, NULL); }
    | transformation_args_req ',' literal   { $$ = ast_transformation_args_new($3, $1); }
    ;
literal
    : T_INTEGER     { $$ = ast_literal_create(L_INTEGER, $1, ast_position_create(@$.first_line, @$.first_column)); }
    | T_FLOATING    { $$ = ast_literal_create(L_FLOATING, $1, ast_position_create(@$.first_line, @$.first_column)); }
    | T_STRING      { $$ = ast_literal_create(L_STRING, $1, ast_position_create(@$.first_line, @$.first_column)); }
    | T_IDENTIFIER  { $$ = ast_literal_create(L_IDENTIFIER, $1, ast_position_create(@$.first_line, @$.first_column)); }
    ;

%parse-param {struct ast_script ** result} {char ** error}
%{
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "ast.h"
int yylex(void);
void yyerror(struct ast_script ** result, char ** error, const char * str);
%}
%code requires {
#include "ast.h"
}
%union {
    struct ast_script * script;
    struct ast_transformation transformation;
    struct ast_transformation_args * transformation_args;
    struct ast_literal literal;
    char * token;
}
%token T_IDENTIFIER T_INTEGER T_FLOATING T_STRING
%type<script> script
%type<transformation> transformation
%type<transformation_args> transformation_args
%type<literal> literal
%type<token> T_IDENTIFIER T_INTEGER T_FLOATING T_STRING
%%
file
    : script YYEOF  { *result = ast_script_reverse($1); }
    ;
script
    : /* empty */               { $$ = NULL; }
    | script transformation ';' { $$ = ast_script_new($2, $1); }
    ;
transformation
    : T_IDENTIFIER '(' transformation_args ')'                  {
        $$ = ast_transformation_create(NULL, $1, ast_transformation_args_reverse($3),
                ast_position_create(@$.first_line, @$.first_column));
    }
    | T_IDENTIFIER '.' T_IDENTIFIER '(' transformation_args ')' {
        $$ = ast_transformation_create($1, $3, ast_transformation_args_reverse($5),
                ast_position_create(@$.first_line, @$.first_column));
    }
    ;
transformation_args
    : /* empty */               { $$ = NULL; }
    | transformation_args_req   { $$ = $1; }
    ;
transformation_args_req
    : literal                               { $$ = ast_transformation_args_new($1, NULL); }
    | transformation_args_req ',' literal   { $$ = ast_transformation_args_new($3, $1); }
    ;
literal
    : T_INTEGER     { $$ = ast_literal_create(L_INTEGER, $1, ast_position_create(@$.first_line, @$.first_column)); }
    | T_FLOATING    { $$ = ast_literal_create(L_FLOATING, $1, ast_position_create(@$.first_line, @$.first_column)); }
    | T_STRING      { $$ = ast_literal_create(L_STRING, $1, ast_position_create(@$.first_line, @$.first_column)); }
    | T_IDENTIFIER  { $$ = ast_literal_create(L_IDENTIFIER, $1, ast_position_create(@$.first_line, @$.first_column)); }
    ;
%%
void yyerror(struct ast_script ** result, char ** error, const char * str) {
    free(*error);
    *error = malloc(strlen(str) + 56);
    sprintf(*error, "at %d:%d: %s", yylloc.first_line, yylloc.first_column, str);
}

%option noyywrap noinput nounput
%{
#include <string.h>
#include "parser.h"
#include "util.h"
extern YYLTYPE yylloc;
int fileno(FILE *stream);
void update_yylloc() {
    size_t i;
    yylloc.first_line = yylloc.last_line;
    yylloc.first_column = yylloc.last_column;
    for (i = 0; i < yyleng; ++i) {
        switch (yytext[i]) {
        case '\n':
            ++yylloc.last_line;
            yylloc.last_column = 1;
            break;
        default:
            ++yylloc.last_column;
        }
    }
}
%}
S [ \b\n\t\f\r]
W [a-zA-Z_]
D [0-9]
I {W}({W}|{D})*
%%
{S}         update_yylloc();
#.*$        update_yylloc();
{I}         update_yylloc(); yylval.token = strdup(yytext); return T_IDENTIFIER;
{D}+                update_yylloc(); yylval.token = strdup(yytext); return T_INTEGER;
{D}*\.{D}+          update_yylloc(); yylval.token = strdup(yytext); return T_FLOATING;
"(\\.|[^"\\])*"   update_yylloc(); yylval.token = strdup(yytext); return T_STRING;
.           update_yylloc(); return yytext[0];

/* interpreter.h */
#include "ast.h"
struct interpreter_ids;
struct interpreter {
    const char * modules_prefix;
    const struct ast_script * script;
    struct interpreter_ids * identifiers;
};
struct interpreter interpreter_create(const struct ast_script * script);
void interpreter_discard(struct interpreter interpreter);
const char * interpreter_process_script(struct interpreter * interpreter);
const char * interpreter_run(const struct interpreter interpreter, struct image * image);
/* interpreter.c */
struct interpreter_ids {
    const char * module;
    const char * name;
    void * handle;
    void * symbol;
    struct interpreter_ids * next;
};

const char * interpreter_load_symbol(struct interpreter * interpreter, const char * module, const char * name) {
    static char * error = NULL;
    void * handle;
    void * symbol;
    if (interpreter_ids_lookup(interpreter->identifiers, module, name)) {
        return NULL;
    }
    if (strset(&error, interpreter_load_module(*interpreter, &handle, module))) {
        return error;
    }
    if (strset(&error, interpreter_do_load_symbol(&symbol, handle, name))) {
        dlclose(handle);
        return error;
    }
    interpreter->identifiers = interpreter_ids_new(module, name, handle, symbol, interpreter->identifiers);
    return NULL;
}

const char * interpreter_do_load_module(void ** handle, const char * filename) {
    if (!(*handle = dlopen(filename, RTLD_NOW | RTLD_LOCAL | RTLD_DEEPBIND))) {
        return dlerror();
    }
    return NULL;
}
const char * interpreter_load_module(const struct interpreter interpreter, void ** handle, const char * module) {
    size_t prefix_length, module_length;
    static char * error = NULL;
    char * filename;
    if (!module) {
        return strset(&error, interpreter_do_load_module(handle, NULL));
    }
    prefix_length = strlen(interpreter.modules_prefix);
    module_length = strlen(module);
    filename = malloc(sizeof(char) * (prefix_length + module_length + 4));
    sprintf(filename, "%s%s.so", interpreter.modules_prefix, module);
    if (!strset(&error, interpreter_do_load_module(handle, filename))) {
        free(filename);
        return NULL;
    }
    sprintf(filename, "%s%s", interpreter.modules_prefix, module);
    if (!interpreter_do_load_module(handle, filename)) {
        free(filename);
        return NULL;
    }
    free(filename);
    return error;
}
const char * interpreter_do_load_symbol(void ** symbol, void * handle, const char * name) {
    dlerror();
    *symbol = dlsym(handle, name);
    return dlerror();
}

typedef const char * (* transformation_function)(struct image * image, uint32_t argc, const struct value * argv);

struct value {
    enum {
        V_INTEGER,
        V_FLOATING,
        V_STRING,
        V_IDENTIFIER
    } type;
    union {
        int64_t integer;
        double floating;
        char * string;
        void * identifier;
    } value;
};
struct value value_from_integer(int64_t value);
struct value value_from_floating(double value);
struct value value_from_string(const char * value);
struct value value_from_identifier(void * value);
void value_discard(struct value value);
bool value_is_integer(struct value value);
bool value_is_floating(struct value value);
bool value_is_string(struct value value);
bool value_is_identifier(struct value value);
int64_t value_to_integer(struct value value);
double value_to_floating(struct value value);
const char * value_to_string(struct value value);
void * value_to_identifier(struct value value);

args = interpreter_collect_args(interpreter, &argc, transformation);
*((void **) (&transformation_function)) = interpreter_ids_lookup(
    interpreter.identifiers,
    transformation.module,
    transformation.name
)->symbol;
transformation_error = transformation_function(image, argc, args);
interpreter_delete_args(argc, args);

uint32_t interpreter_count_args(const struct ast_transformation_args * transformation_args) {
    uint32_t count = 0;
    for (; transformation_args; transformation_args = transformation_args->next) {
        ++count;
    }
    return count;
}
struct value interpreter_parse_string_value(const char * value) {
    size_t value_length = strlen(value);
    size_t i, j;
    char * result = malloc(sizeof(char) * (value_length - 1));
    struct value result_value;
    for (i = 1, j = 0; i < value_length - 1; ++i, ++j) {
        if (value[i] == '\\') {
            ++i;
        }
        result[j] = value[i];
    }
    result[j++] = '\0';
    result_value = value_from_string(result);
    free(result);
    return result_value;
}
struct value *
interpreter_collect_args(const struct interpreter interpreter, uint32_t * argc, const struct ast_transformation transformation) {
    struct value * args = malloc(sizeof(struct value) * (*argc = interpreter_count_args(transformation.args)));
    const struct ast_transformation_args * next = transformation.args;
    uint32_t i;
    for (i = 0; next; next = next->next, ++i) {
        switch (next->argument.type) {
        case L_INTEGER:
            args[i].type = V_INTEGER;
            sscanf(next->argument.value, "%ld", &(args[i].value.integer));
            break;
        case L_FLOATING:
            args[i].type = V_FLOATING;
            sscanf(next->argument.value, "%lf", &(args[i].value.floating));
            break;
        case L_STRING:
            args[i] = interpreter_parse_string_value(next->argument.value);
            break;
        case L_IDENTIFIER:
            args[i] = value_from_identifier(interpreter_ids_lookup(
                interpreter.identifiers,
                transformation.module,
                next->argument.value
            )->symbol);
            break;
        default: /* fallback */
            args[i].type = V_IDENTIFIER;
            args[i].value.identifier = NULL;
        }
    }
    return args;
}

struct __attribute__((packed)) bmp_header {
    char     bfType[2];
    uint32_t bfSize;
    uint32_t bfReserved;
    uint32_t bfOffBits;
    uint32_t biSize;
    int32_t  biWidth;
    int32_t  biHeight;
    uint16_t biPlanes;
    uint16_t biBitCount;
    uint32_t biCompression;
    uint32_t biSizeImage;
    int32_t  biXPelsPerMeter;
    int32_t  biYPelsPerMeter;
    uint32_t biClrUsed;
    uint32_t biClrImportant;
};
struct bmp_pixel;
struct bmp_image {
    struct bmp_header header;
    struct bmp_pixel * bitmap;
};

const char * bmp_image_read(struct bmp_image * image, FILE * file) {
    int32_t row, rowOffset;
    size_t read_count = fread(&(image->header), sizeof(struct bmp_header), 1, file);
    if (read_count < 1) {
        return "cannot read BMP file";
    }
    /* Check file type signature */
    if (image->header.bfType[0] != 'B' || image->header.bfType[1] != 'M') {
        return "invalid BMP file";
    }
    if ((image->header.biSizeImage         /* Check size if biSizeImage != 0 */
     && (image->header.bfSize != image->header.bfOffBits + image->header.biSizeImage))
     || (image->header.biPlanes != 1)      /* Check biPlanes */
     || (image->header.biBitCount != 24)   /* Check pixel bits count, only 24 is supported */
     || (image->header.biCompression != 0) /* Check biCompression, only 0 is supported */
    ) {
        return "invalid BMP file";
    }
    /* Check file size */
    if (fseek(file, 0L, SEEK_END)) {
        return strerror(errno);
    }
    if (ftell(file) != image->header.bfSize) {
        return strerror(errno);
    }
    /* Go to bitmap */
    if (fseek(file, image->header.bfOffBits, SEEK_SET)) {
        return strerror(errno);
    }
    image->bitmap = malloc(sizeof(struct bmp_pixel) * image->header.biWidth * image->header.biHeight);
    rowOffset = image->header.biWidth % 4;
    for (row = image->header.biHeight - 1; row >= 0; --row) {
        read_count = fread(image->bitmap + row * image->header.biWidth, sizeof(struct bmp_pixel), image->header.biWidth, file);
        if (read_count < image->header.biWidth) {
            free(image->bitmap);
            return "cannot read BMP file";
        }
        if (fseek(file, rowOffset, SEEK_CUR)) {
            free(image->bitmap);
            return strerror(errno);
        }
    }
    return NULL;
}
const char * bmp_image_write(const struct bmp_image image, FILE * file) {
    static uint8_t offsetBuffer[] = { 0, 0, 0 };
    int32_t row, rowOffset;
    if (fwrite(&(image.header), sizeof(struct bmp_header), 1, file) < 1) {
        return "cannot write file";
    }
    rowOffset = image.header.biWidth % 4;
    for (row = image.header.biHeight - 1; row >= 0; --row) {
        if (fwrite(image.bitmap + row * image.header.biWidth,
            sizeof(struct bmp_pixel), image.header.biWidth, file) < image.header.biWidth) {
            return strerror(errno);
        }
        if (fwrite(offsetBuffer, 1, rowOffset, file) < rowOffset) {
            return strerror(errno);
        }
    }
    return NULL;
}

struct pixel {
    uint8_t red;
    uint8_t green;
    uint8_t blue;
};
struct image {
    uint32_t width;
    uint32_t height;
    struct pixel * pixels;
};

typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
  int first_line;
  int first_column;
  int last_line;
  int last_column;
};

struct ast_position {
    uint32_t row;
    uint32_t col;
};
struct ast_literal {
    enum ast_literal_type type;
    char * value;
    struct ast_position pos;
};
struct ast_transformation {
    char * module;
    char * name;
    struct ast_transformation_args * args;
    struct ast_position pos;
};

typedef struct pixel (* blur_function)(uint32_t x, uint32_t y, const struct image image);
const char * do_(struct image * image, uint32_t argc, struct value * args) {
    blur_function map_function;
    if (argc < 1 || !value_is_identifier(args[0])) {
        return "blur type (blur, dilate or erode) is required as first argument";
    }
    *((void **) &map_function) = value_to_identifier(args[0]);
    if (map_function != blur && map_function != dilate && map_function != erode) {
        return "wrong blur type, only blur, dilate or erode are allowed";
    }
    do_blur(*image, map_function);
    return NULL;
}