BIPLAN.c

/* BIPLAN CR.1 (Byte coded Interpreted Programming Language)
      _____              _________________________
     |   | |            |_________________________|
     |   | |_______________||__________   \___||_________ |
   __|___|_|               ||          |__|   ||     |   ||
  /________|_______________||_________________||__   |   |D
    (O)                 |_________________________|__|___/|
                                           \ /            |
                                           (O)

  Giovanni Blu Mitolo 2017-2026 - gioscarab@gmail.com
  BIP bytecode interpreter

  NOTE: despite its .c extension this file may be compiled as C++ if required
  by the interface used. */

#pragma once
#include "BIPLAN.h"

/* BUFFERS ----------------------------------------------------------------- */
BP_VAR_T           bip_variables     [BP_VARIABLES];
BP_VAR_T           bip_for_variables [BP_FOR_VARIABLES];
uint8_t            bip_memory        [BP_MEM_SIZE];
char               bip_string        [BP_STRING_MAX];
char               bip_strings       [BP_STRINGS][BP_STRING_MAX];
struct bip_cycle_t bip_cycles        [BP_CYCLE_DEPTH];
struct bip_fun_t   bip_functions     [BP_FUN_DEPTH];
struct bip_def_t   bip_definitions   [BP_FUN_MAX];
struct bip_files_t bip_files         [BP_FILES_MAX];
struct bip_pipes_t bip_pipes         [BP_PIPES_MAX];
/* STATE ------------------------------------------------------------------- */
char              *bip_program_start  = NULL;
uint8_t            bip_fw_id          = 0;
int                bip_fn_id          = 0;
int                bip_arg_id         = 0;
bool               bip_ended          = false;
uint8_t            bip_return_type    = 0;
/* CALLBACKS --------------------------------------------------------------- */
bip_error_t        bip_error_fun      = NULL;
BPM_PRINT_T        bip_print_fun;
BPM_INPUT_T        bip_data_in_fun;
BPM_SERIAL_T       bip_serial_fun;

#define BP_READ_THEN_ABORT_IF_OUT_OF_BOUNDS(R, B, E) \
  DCD_NEXT; \
  R = bip_relation(); \
  if((R < 0) || (R >= B)) { bip_error(dcd_ptr, E); }

#define BP_GET_ID(V, B, L, E) \
  for(uint16_t i = 0, V = L; i < L; i++) \
    if(B[i].free) { \
      B[i].free = false; \
      V = i; \
      break; \
    } \
  if(V == L) bip_error(dcd_ptr, E);

/* SYSTEM CALL WITH 1 RELATION PARAMETER ----------------------------------- */

#define BP_SYS_RELATION(F, T, R) \
  if(dcd_current == BP_STRING) { \
    bip_read_string(bip_string); \
    for(uint16_t i = 0; bip_string[i] != 0; i++) \
      R = F(T, bip_string[i]); \
    BP_EMPTY_STRING; \
  } else if(bip_ignore(BP_STR_ADDR)) { \
    uint8_t id = *(dcd_ptr - 1) - BP_OFFSET; \
    for(uint16_t i = 0; bip_strings[id][i] != 0; i++) \
      R = F(T, bip_strings[id][i]); \
  }

/* SYSTEM CALL WITH 1 STRING PARAMETER ------------------------------------- */

#define BP_SYS_STRING(F, V) \
  DCD_NEXT; \
  if(bip_ignore(BP_STR_ADDR)) { \
    V = F(bip_strings[*(dcd_ptr - 1) - BP_OFFSET]); \
  } else if(dcd_current == BP_STRING) { \
    bip_read_string(bip_string); \
    V = F(bip_string); \
    BP_EMPTY_STRING; \
  } else if(dcd_current == BP_STR_ACC) \
    V = F(bip_strings[bip_access(dcd_current)]); \
  return V;

/* SYSTEM CALL WITH 1 STRING PARAMETER ------------------------------------- */

#define  BP_SYS_STRING_2(F, B) \
  BP_VAR_T bip_sys_str_2; \
  DCD_NEXT; \
  if(dcd_current == BP_STRING) { \
    bip_read_string(bip_string); \
    bip_sys_str_2 = bip_ignore(BP_COMMA) ? bip_relation() : 0; \
    F(B, bip_string, bip_sys_str_2); \
    BP_EMPTY_STRING; \
  } else if(bip_ignore(BP_STR_ADDR)) { \
    BP_VAR_T bip_sys_str_2_addr = *(dcd_ptr - 1) - BP_OFFSET; \
    bip_sys_str_2 = bip_ignore(BP_COMMA) ? bip_relation() : 0; \
    F(B, bip_strings[bip_sys_str_2_addr], bip_sys_str_2); \
  } else if(dcd_current == BP_STR_ACC) { \
    BP_VAR_T si = bip_access(BP_STR_ACC); \
    bip_sys_str_2 = bip_ignore(BP_COMMA) ? bip_relation() : 0; \
    if((si < 0) || (si >= BP_STRINGS)) \
      bip_error(dcd_ptr, BP_ERROR_STRING_GET); \
    F(B, bip_strings[si], bip_sys_str_2); \
  } else bip_error(dcd_ptr, BP_ERROR_SYMBOL); \

/* SYSTEM CALL WITH 2 EXPRESSION PARAMETER --------------------------------- */
#define BP_SYS_EXPRESSION_2(F) \
  BP_VAR_T bip_sys_exp = bip_expression(); \
  BP_EXPECT(BP_COMMA); \
  F(bip_sys_exp, bip_expression());

/* EMPTY STRING ------------------------------------------------------------ */
#define BP_EMPTY_STRING \
  for(BP_VAR_T emptstr = 0; emptstr < BP_STRING_MAX; emptstr++) \
    bip_string[emptstr] = 0;

/* EXPECT A CERTAIN CODE, OTHERWISE THROW ERROR ---------------------------- */
#define BP_EXPECT(C) \
  if(C != dcd_current) bip_error(dcd_ptr, BP_ERROR_SYMBOL); \
  else DCD_NEXT;

/* GET VARIABLE ------------------------------------------------------------ */
#define BP_GET_VARIABLE(N, V) \
  if(N >= 0 && N < BP_VARIABLES) { V =  bip_variables[N]; } \
  else { bip_error(dcd_ptr, BP_ERROR_VARIABLE_GET); }

/* SET VARIABLE ------------------------------------------------------------ */
#define BP_SET_VARIABLE(N, V) \
  if(N >= 0 && N < BP_VARIABLES) { bip_variables[N] = V; } \
  else { bip_error(dcd_ptr, BP_ERROR_VARIABLE_SET); }

/* INCREMENT VARIABLE ------------------------------------------------------ */
#define BP_INCREMENT_VARIABLE(N, V) \
  if(N >= 0 && N < BP_VARIABLES) { bip_variables[N] += V; } \
  else { bip_error(dcd_ptr, BP_ERROR_VARIABLE_SET); }

/* UNARY -- ++ ------------------------------------------------------------- */
#define BP_UNARY(V) \
  while(dcd_current == BP_INCREMENT || dcd_current == BP_DECREMENT) { \
    if(dcd_current == BP_INCREMENT) { V++; } else { V--; } \
    DCD_NEXT; \
  }

/* Bytecode dispatch table - optimized dispatch for fast execution */
typedef void (*bip_dispatch_fn_t)(void);

#ifdef BIP_DISPATCH_TABLE
/* Dispatch handler implementations */
static void bip_dispatch_var_addr()   { bip_var_addr_call(); }
static void bip_dispatch_str_addr()   { bip_string_assignment_call(); }
static void bip_dispatch_function()   { bip_function_call(); DCD_NEXT; }
static void bip_dispatch_factor()     { bip_factor(); }
static void bip_dispatch_next()       { DCD_NEXT; bip_next_call(); }
static void bip_dispatch_for()        { DCD_NEXT; bip_for_call(); }
static void bip_dispatch_if()         { DCD_NEXT; bip_if_call(); }
static void bip_dispatch_else()       { DCD_NEXT; bip_skip_block(); }
static void bip_dispatch_endif()      { DCD_NEXT; }
static void bip_dispatch_mem_acc()    { bip_mem_assignment_call(); }
static void bip_dispatch_while()      { DCD_NEXT; bip_while_call(); }
static void bip_dispatch_break()      { --bip_fw_id; bip_break_call(); }
static void bip_dispatch_continue()   { bip_continue_call(); }
static void bip_dispatch_io()         { DCD_NEXT; bip_io_set_call(); }
static void bip_dispatch_delay()      { DCD_NEXT; BPM_DELAY(bip_expression()); }
static void bip_dispatch_print()      { DCD_NEXT; bip_print_call(); }
static void bip_dispatch_file()       { bip_file_set_call(); }
static void bip_dispatch_pipe()       { bip_pipe_call(0); }
static void bip_dispatch_serial()     { bip_serial_call(); }
static void bip_dispatch_ltoa()       { bip_ltoa_call(); }
static void bip_dispatch_restart()    { bip_restart_call(); }
static void bip_dispatch_end()        { bip_end_call(); }
static void bip_dispatch_error()      { bip_error(dcd_ptr, BP_ERROR_STATEMENT); }

/* Dispatch table: indexed by bytecode value */
static bip_dispatch_fn_t bip_dispatch_table[256] = {0};
static bool bip_dispatch_table_initialized = false;

static void bip_init_dispatch_table() {
  if(bip_dispatch_table_initialized) return;

  /* Initialize null handlers for safety */
  for(int i = 0; i < 256; i++)
    bip_dispatch_table[i] = bip_dispatch_error;

  /* Map bytecode values to handlers */
  bip_dispatch_table[BP_FOR_ADDR]  = bip_dispatch_var_addr;
  bip_dispatch_table[BP_VAR_ACC]   = bip_dispatch_var_addr;
  bip_dispatch_table[BP_VAR_ADDR]  = bip_dispatch_var_addr;
  bip_dispatch_table[BP_STR_ACC]   = bip_dispatch_str_addr;
  bip_dispatch_table[BP_STR_ADDR]  = bip_dispatch_str_addr;
  bip_dispatch_table[BP_FUNCTION]  = bip_dispatch_function;
  bip_dispatch_table[BP_INCREMENT] = bip_dispatch_factor;
  bip_dispatch_table[BP_DECREMENT] = bip_dispatch_factor;
  bip_dispatch_table[BP_NEXT]      = bip_dispatch_next;
  bip_dispatch_table[BP_FOR]       = bip_dispatch_for;
  bip_dispatch_table[BP_IF]        = bip_dispatch_if;
  bip_dispatch_table[BP_ELSE]      = bip_dispatch_else;
  bip_dispatch_table[BP_ENDIF]     = bip_dispatch_endif;
  bip_dispatch_table[BP_MEM_ACC]   = bip_dispatch_mem_acc;
  bip_dispatch_table[BP_WHILE]     = bip_dispatch_while;
  bip_dispatch_table[BP_BREAK]     = bip_dispatch_break;
  bip_dispatch_table[BP_CONTINUE]  = bip_dispatch_continue;
  bip_dispatch_table[BP_IO]        = bip_dispatch_io;
  bip_dispatch_table[BP_DELAY]     = bip_dispatch_delay;
  bip_dispatch_table[BP_PRINT]     = bip_dispatch_print;
  bip_dispatch_table[BP_FILE]      = bip_dispatch_file;
  bip_dispatch_table[BP_PIPE]      = bip_dispatch_pipe;
  bip_dispatch_table[BP_SERIAL]    = bip_dispatch_serial;
  bip_dispatch_table[BP_LTOA]      = bip_dispatch_ltoa;
  bip_dispatch_table[BP_RESTART]   = bip_dispatch_restart;
  bip_dispatch_table[BP_END]       = bip_dispatch_end;

  bip_dispatch_table_initialized = true;
}

/* Optimized dispatch using jump table */
BP_FUN_T void bip_statement_dispatch() {
  bip_dispatch_table[(unsigned char)dcd_current]();
}

#define BP_STATEMENT bip_statement_dispatch()
#else
#define BP_STATEMENT \
  switch(dcd_current) { \
    case BP_FOR_ADDR: ; \
    case BP_VAR_ACC: ;  /* assignment by reference */ \
    case BP_VAR_ADDR:   bip_var_addr_call(); break; \
    case BP_STR_ACC: ;  /* assignment by reference */ \
    case BP_STR_ADDR:   bip_string_assignment_call(); break; \
    case BP_FUNCTION:   bip_function_call(); DCD_NEXT; break; \
    case BP_INCREMENT:  ; /* same as decrement */ \
    case BP_DECREMENT:  bip_factor();  break; \
    case BP_NEXT:       DCD_NEXT; bip_next_call(); break; \
    case BP_FOR:        DCD_NEXT; bip_for_call(); break; \
    case BP_IF:         DCD_NEXT; bip_if_call(); break; \
    case BP_ELSE:       DCD_NEXT; bip_skip_block(); break; \
    case BP_ENDIF:      DCD_NEXT; break; \
    case BP_MEM_ACC:    bip_mem_assignment_call(); break; \
    case BP_WHILE:      DCD_NEXT; bip_while_call(); break; \
    case BP_BREAK:      --bip_fw_id; bip_break_call(); break; \
    case BP_CONTINUE:   bip_continue_call(); break; \
    case BP_IO:         DCD_NEXT; bip_io_set_call(); break; \
    case BP_DELAY:      DCD_NEXT; BPM_DELAY(bip_expression()); break; \
    case BP_PRINT:      DCD_NEXT; bip_print_call(); break; \
    case BP_FILE:       bip_file_set_call(); break; \
    case BP_PIPE:       bip_pipe_call(0); break; \
    case BP_SERIAL:     bip_serial_call(); break; \
    case BP_LTOA:       bip_ltoa_call(); break; \
    case BP_RESTART:    bip_restart_call(); break; \
    case BP_END:        bip_end_call(); break; \
    default: bip_error(dcd_ptr, BP_ERROR_STATEMENT); \
  }
#endif

/* ASSIGN VALUE TO VARIABLE ------------------------------------------------ */
BP_FUN_T void bip_var_addr_call() {
  if(dcd_current == BP_VAR_ADDR) {
    DCD_NEXT;
    uint8_t bp_vac_var = *(dcd_ptr - 1) - BP_OFFSET;
    BP_SET_VARIABLE(bp_vac_var, bip_relation());
  } else if(dcd_current == BP_FOR_ADDR) {
    DCD_NEXT;
    uint8_t bp_vac_for = *(dcd_ptr - 1) - BP_OFFSET;
    bip_for_variables[bp_vac_for - 1] = bip_relation();
  } else {
    BP_VAR_T bp_vac_acc = bip_access(BP_VAR_ACC);
    BP_SET_VARIABLE(bp_vac_acc, bip_relation());
  }
}

/* END PROGRAM ------------------------------------------------------------- */
void bip_end_call() { bip_ended = true; };

/* RUN --------------------------------------------------------------------- */
BP_FUN_T bool bip_run() { bip_statement(); return !bip_ended;  };

/* RESTART PROGRAM CALL ---------------------------------------------------- */
void bip_restart_call() { bip_set_default(); DCD_INIT(bip_program_start); };

/* ERROR ------------------------------------------------------------------- */
void bip_error(char *position, const char *string) {
  bip_error_fun(position, string);
  bip_ended = true;
};

/* INDEX LINES ------------------------------------------------------------- */
void bip_index_definitions(char* program) {
  uint16_t param, l = 0;
  while(dcd_current != BP_ENDOFINPUT) {
    if(bip_ignore(BP_FUN_DEF)) {
      param = 0;
      l = *(dcd_ptr - 1) - BP_OFFSET;
      for(uint8_t i = 0; i < BP_PARAMS; i++)
        bip_definitions[l].params[i] = BP_PARAMS;
      do {
        if(bip_ignore(BP_VAR_ADDR))
          bip_definitions[l].params[param++] = *(dcd_ptr - 1);
      } while(*dcd_ptr != BP_R_RPARENT);
      bip_definitions[l].address = dcd_ptr + 1;
    } DCD_NEXT;
  }
};

/* PROCESS ARGUMENTS ------------------------------------------------------- */
void bip_process_argument(char *a) {
  for(uint16_t s = 0; s < strlen(a); s++) bip_strings[bip_arg_id][s] = a[s];
  if(++bip_arg_id >= BP_ARGS) bip_error(dcd_ptr, BP_ERROR_ARGS_MAX);
};

/* GET FILE ID ------------------------------------------------------------- */
BP_VAR_T bip_get_file_id() {
  for(uint16_t i = 0; i < BP_FILES_MAX; i++)
    if(bip_files[i].free) {
      bip_files[i].free = false;
      return i;
    }
  bip_error(dcd_ptr, BP_ERROR_FILE_MAX);
  return BP_FILES_MAX;
};

/* INITIALIZE INTERPRETER -------------------------------------------------- */
void bip_init(
  char        *program,
  bip_error_t  error,
  BPM_PRINT_T  print,
  BPM_INPUT_T  data_input,
  BPM_SERIAL_T s
) {
  bip_program_start = program;
  bip_set_default();
  DCD_INIT(program);
  bip_index_definitions(program);
  DCD_INIT(program);
  bip_serial_fun = s;
  bip_error_fun = error;
  bip_print_fun = print;
  bip_data_in_fun = data_input;
  #ifdef BIP_DISPATCH_TABLE
  bip_init_dispatch_table();
  #endif
};

void bip_set_default() {
  bip_fw_id = 0, bip_fn_id = 0, bip_ended = false, bip_arg_id = 0;
  for(BP_VAR_T i = 0; i < BP_MEM_SIZE; i++) bip_memory[i] = 0;
  for(BP_VAR_T i = 0; i < BP_VARIABLES; i++) bip_variables[i] = 0;
  for(BP_VAR_T i = BP_ARGS; i < BP_STRINGS; i++)
    for(BP_VAR_T c = 0; c < BP_STRING_MAX; c++) bip_strings[i][c] = 0;
  for(uint16_t i = 0; i < BP_FILES_MAX; i++) bip_files[i].free = true;
  for(uint16_t i = 0; i < BP_PIPES_MAX; i++) bip_pipes[i].free = true;
  for(BP_VAR_T i = 0; i < BP_CYCLE_DEPTH; i++)
    bip_cycles[i].var_id = BP_VARIABLES;
  BP_EMPTY_STRING;
};

/* IGNORE A CERTAIN CODE --------------------------------------------------- */
BP_FUN_T bool bip_ignore(char c) {
  if((c = (c == dcd_current))) DCD_NEXT;
  return c;
};

/* GET VARIABLE ------------------------------------------------------------ */
BP_FUN_T BP_VAR_T bip_get_variable(int n) {
  if(n >= 0 && n <= BP_VARIABLES) return bip_variables[n];
  bip_error(dcd_ptr, BP_ERROR_VARIABLE_GET);
  return 0;
};

/* GET ONE CHAR FROM STRING ------------------------------------------------ */
BP_FUN_T char bip_string_char(int s, int c) {
  if((c >= BP_STRING_MAX) || (s < 0 && s >= BP_STRINGS)) {
    bip_error(dcd_ptr, BP_ERROR_STRING_GET);
    return 0;
  } return bip_strings[s][c];
};

/* ACCESS MEMORY VIA INDEX [ ] --------------------------------------------- */
BP_FUN_T BP_VAR_T bip_access(BP_VAR_T v) {
  BP_EXPECT(v);
  v = bip_relation();
  BP_EXPECT(BP_ACCESS_END);
  return v;
};

/* FACTOR: (n) ------------------------------------------------------------- */
BP_FUN_T BP_VAR_T bip_factor() {
  BP_VAR_T v = 0;
  bool bitwise_not = 0, minus = 0, index = 0;
  int8_t pre = 0;
  DCD_IGNORE(BP_BITWISE_NOT, bitwise_not);
  DCD_IGNORE(BP_MINUS, minus);
  BP_UNARY(pre);
  DCD_IGNORE(BP_INDEX, index);
  switch(dcd_current) {
    case BP_FOR_ADDR:
      DCD_NEXT;
      v = *(dcd_ptr - 1) - BP_OFFSET;
      if(index) return v;
      if(pre != 0) bip_for_variables[v] += pre;
      v = bip_for_variables[v];
      break;
    case BP_VAR_ADDR:
      DCD_NEXT;
      v = *(dcd_ptr - 1) - BP_OFFSET;
      if(index) return v;
      if(pre != 0) BP_INCREMENT_VARIABLE(v, pre);
      BP_GET_VARIABLE(v, v);
      break;
    case BP_STR_ADDR:
      DCD_NEXT;
      v = *(dcd_ptr - 1) - BP_OFFSET;
      if(index) return v;
      if(dcd_current == BP_ACCESS) {
        v = bip_string_char(v, bip_access(BP_ACCESS));
        bip_return_type = BP_ACCESS;
      } else bip_return_type = BP_STR_ADDR;
      break;
    case BP_NUMBER: v = BPM_ATOL(dcd_ptr); BP_EXPECT(BP_NUMBER); break;
    case BP_VAR_ACC: v = bip_get_variable(bip_access(BP_VAR_ACC)); break;
    case BP_STR_ACC:
      v = bip_access(BP_STR_ACC);
      if(dcd_current == BP_ACCESS)
        v = bip_string_char(v, bip_access(BP_ACCESS));
      break;
    case BP_MEM_ACC: v = bip_memory[bip_access(BP_MEM_ACC)]; break;
    case BP_L_RPARENT:
      DCD_NEXT; v = bip_relation(); BP_EXPECT(BP_R_RPARENT); break;
    case BP_FUNCTION: v = bip_function_call(); DCD_NEXT; break;
    case BP_FILE: v = bip_file_get_call(); break;
    case BP_IO: v = bip_io_get_call(); break;
    case BP_MILLIS: DCD_NEXT; v = (BPM_MILLIS() % BP_VAR_MAX); break;
    case BP_ADC: v = bip_adc_call(); break;
    case BP_RND: DCD_NEXT;  v = bip_random_call(); break;
    case BP_SERIAL: v = bip_serial_call(); break;
    case BP_INPUT: v = input_call(); break;
    case BP_SIZEOF: v = bip_sizeof_call(); break;
    case BP_PIPE: v = bip_pipe_call(0); break;
    case BP_ATOL: v = bip_atol_call(0); break;
  } v = (minus) ? -v : v;
  return (bitwise_not) ? ~v : v;
};

/* TERM: *, /, % ------------------------------------------------------------*/
BP_FUN_T BP_VAR_T bip_term() {
  BP_VAR_T f1 = bip_factor(), f2 = 0;
  uint8_t op = dcd_current;
  while(op == BP_MULT || op == BP_DIV || op == BP_MOD) {
    DCD_NEXT;
    f2 = bip_factor();
    switch(op) {
      case BP_MULT: f1 = f1 * f2; break;
      case BP_DIV:
        if(!f2 && (op == BP_DIV)) bip_error(dcd_ptr, BP_ERROR_DIV_ZERO);
        else f1 = f1 / f2;
        break;
      case BP_MOD:  f1 = f1 % f2; break;
    } op = dcd_current;
  } return f1;
};

/* EXPRESSION +, -, &, | ----------------------------------------------------*/
BP_FUN_T BP_VAR_T bip_expression() {
  BP_VAR_T t1 = bip_term(), t2 = 0;
  uint8_t op = dcd_current;
  while(
    op == BP_PLUS || op == BP_MINUS || op == BP_AND || op == BP_OR ||
    op == BP_XOR || op == BP_L_SHIFT || op == BP_R_SHIFT
  ) {
    DCD_NEXT;
    t2 = bip_term();
    switch(op) {
      case BP_PLUS:    t1 = t1 + t2;  break;
      case BP_MINUS:   t1 = t1 - t2;  break;
      case BP_AND:     t1 = t1 & t2;  break;
      case BP_OR:      t1 = t1 | t2;  break;
      case BP_XOR:     t1 = t1 ^ t2;  break;
      case BP_L_SHIFT: t1 = t1 << t2; break;
      case BP_R_SHIFT: t1 = t1 >> t2; break;
    } op = dcd_current;
  } return t1;
};

/* RELATION <, >, = -------------------------------------------------------- */
BP_FUN_T BP_VAR_T bip_relation() {
  BP_VAR_T r1 = bip_expression(), r2 = 0;
  uint8_t op = dcd_current;
  while(
    op == BP_EQ || op == BP_NOT_EQ || op == BP_LTOEQ || op == BP_GTOEQ ||
    op == BP_LT || op == BP_GT || op == BP_LOGIC_OR || op == BP_LOGIC_AND
  ) {
    DCD_NEXT;
    r2 = bip_expression();
    switch(op) {
      case BP_NOT_EQ:    r1 = r1 != r2; break;
      case BP_EQ:        r1 = r1 == r2; break;
      case BP_GTOEQ:     r1 = r1 >= r2; break;
      case BP_LTOEQ:     r1 = r1 <= r2; break;
      case BP_LOGIC_OR:  r1 = r1 || r2; break;
      case BP_LOGIC_AND: r1 = r1 && r2; break;
      case BP_LT:        r1 = r1 <  r2; break;
      case BP_GT:        r1 = r1 >  r2; break;
    } op = dcd_current;
  } return r1;
};

/* HANDLE STRING CONCATENATION ---------------------------------------------- */
static void bip_string_concat(char *s) {
  while(bip_ignore(BP_PLUS)) {
    uint16_t o = strlen(s);
    uint8_t ci = 0;
    if(bip_ignore(BP_STR_ADDR)) ci = *(dcd_ptr - 1) - BP_OFFSET;
    else if(bip_ignore(BP_STR_ACC)) {
      ci = bip_expression();
      BP_EXPECT(BP_ACCESS_END);
    } else if(dcd_current == BP_STRING) {
      if(!decoder_string(s + o, sizeof(bip_string)))
        bip_error(dcd_ptr, BP_ERROR_STRING_END);
      else BP_EXPECT(BP_STRING);
      continue;
    } else bip_error(dcd_ptr, BP_ERROR_STRING_CONCAT);
    for(uint16_t i = 0; bip_strings[ci][i] && (i < (BP_STRING_MAX - o)); i++)
      *(s + o + i) = bip_strings[ci][i];
    *(s + o + strlen(bip_strings[ci])) = 0;
  }
};

/* READ SAFELY A STRING ---------------------------------------------------- */
void bip_read_string(char *s) {
  if(!decoder_string(s, sizeof(bip_string)))
    bip_error(dcd_ptr, BP_ERROR_STRING_END);
  else BP_EXPECT(BP_STRING);
  bip_string_concat(s);
};

/* PRINT ------------------------------------------------------------------- */
void bip_print_call() {
  do {
    bip_return_type = 0;
    BP_VAR_T v = 0;
    bip_ignore(BP_COMMA);
    bool is_char = bip_ignore(BP_CHAR);
    if(dcd_current == BP_STR_ACC) {
      v = bip_access(BP_STR_ACC);
      if(dcd_current == BP_ACCESS)
        BPM_PRINT_WRITE(bip_strings[v][bip_access(BP_ACCESS)]);
      else BPM_PRINT_WRITE(bip_strings[v]);
    } else if(dcd_current == BP_STRING) {
      bip_read_string(bip_string);
      BPM_PRINT_WRITE(bip_string);
      BP_EMPTY_STRING;
    } else if(dcd_current == BP_STR_ADDR) {
      v = bip_factor();
      if(bip_return_type == BP_ACCESS) {
        if(is_char) BPM_PRINT_WRITE((char)v);
        else BPM_PRINT_WRITE(v);
      } else {
        BPM_PRINT_WRITE(bip_strings[v]);
      }
    } else if(dcd_current == BP_RESTART) {
      BPM_PRINT_CLEAR;
      DCD_NEXT;
    } else if(bip_ignore(BP_CURSOR)) {
      BP_SYS_EXPRESSION_2(BPM_PRINT_CURSOR);
    } else {
      v = bip_relation();
      if(bip_return_type == BP_STR_ADDR)
        BPM_PRINT_WRITE(bip_strings[v]);
      else if(is_char) BPM_PRINT_WRITE((char)v);
      else BPM_PRINT_WRITE(v);
    }
  } while(dcd_current == BP_COMMA);
};

/* BLOCK CALL -------------------------------------------------------------- */
void bip_skip_block() {
  uint16_t id = 1;
  do {
    if(dcd_current == BP_IF) id++;
    if(dcd_current == BP_ENDIF) id--;
    if((dcd_current == BP_ELSE) && (id == 1)) return;
    if(dcd_current == BP_ENDOFINPUT) bip_error(dcd_ptr, BP_ERROR_BLOCK);
    DCD_NEXT;
  } while(id >= 1);
};

/* IF ---------------------------------------------------------------------- */
void bip_if_call() {
  if((BP_VAR_T)(bip_relation()) > 0) return;
  bip_skip_block();
  if(dcd_current == BP_ELSE) DCD_NEXT;
};

/* ASSIGN VALUE TO STRING -------------------------------------------------- */
void bip_string_assignment_call() {
  int ci = BP_STRING_MAX, si, o = 0;
  bool str_acc = (dcd_current == BP_STR_ACC);
  DCD_NEXT;
  if(str_acc) {
    si = bip_expression();
    BP_EXPECT(BP_ACCESS_END);
  } else si = *(dcd_ptr - 1) - BP_OFFSET;
  if(dcd_current == BP_ACCESS) ci = bip_access(BP_ACCESS);
  if(ci == BP_STRING_MAX) {
    if(dcd_current == BP_STRING) bip_read_string(bip_strings[si]);
    else if(bip_ignore(BP_STR_ADDR)) {
      ci = *(dcd_ptr - 1) - BP_OFFSET;
      for(uint16_t i = 0; bip_strings[ci][i] && (i < BP_STRING_MAX); i++)
        bip_strings[si][i] = bip_strings[ci][i];
      bip_string_concat(bip_strings[si]);
    } else if(bip_ignore(BP_STR_ACC)) {
      ci = bip_expression();
      BP_EXPECT(BP_ACCESS_END);
      for(uint16_t i = 0; bip_strings[ci][i] && (i < BP_STRING_MAX); i++)
        bip_strings[si][i] = bip_strings[ci][i];
      bip_string_concat(bip_strings[si]);
    }
  } else {
    if(bip_ignore(BP_STRING)) {
      bip_strings[si][ci] = (char)(*(dcd_ptr - 2));
    } else bip_strings[si][ci] = (uint8_t)bip_expression();
  }
};

/* GENERAL PURPOSE MEMORY ASSIGNMENT --------------------------------------- */
void bip_mem_assignment_call() {
  BP_VAR_T i = bip_access(BP_MEM_ACC);
  if((i >= 0) && (i < BP_MEM_SIZE)) bip_memory[i] = bip_expression();
  else bip_error(dcd_ptr, BP_ERROR_MEM_SET);
};

/* FUNCTION ---------------------------------------------------------------- */
BP_FUN_T BP_VAR_T bip_function_call() {
  bip_functions[bip_fn_id].cid = bip_fw_id;
  DCD_NEXT;
  uint8_t i = 0, f = *(dcd_ptr - 1) - BP_OFFSET, v = BP_VARIABLES;
  if(*dcd_ptr != BP_R_RPARENT) {
    bool r = true;
    do {
      if(bip_definitions[f].params[i] == BP_PARAMS) break;
      v = bip_definitions[f].params[i] - BP_OFFSET;
      bip_functions[bip_fn_id].params[i].id = v;
      // Stash global variabile value
      BP_GET_VARIABLE(v, bip_functions[bip_fn_id].params[i].value);
      // Set global variable with parameter value
      if(r) BP_SET_VARIABLE(v, bip_relation());
      DCD_IGNORE(BP_COMMA, r);
    } while(++i < BP_PARAMS);
  }

  if(bip_fn_id >= (BP_FUN_DEPTH - 1)) {
    bip_error(dcd_ptr, BP_ERROR_FUNCTION_CALL);
    return 0;
  }

  bip_functions[bip_fn_id++].address = dcd_ptr;
  DCD_GOTO(bip_definitions[f].address);
  while((dcd_current != BP_RETURN) && (dcd_current != BP_DONE)) {
    #ifdef BIP_FAST
    BP_STATEMENT;
    #else
    bip_statement();
    #endif
  }
  BP_VAR_T rel = 0;
  bool return_type = dcd_current == BP_RETURN;
  DCD_NEXT;
  if(return_type) rel = bip_relation();
  bip_fn_id--;
  for(uint8_t i = 0; i < BP_PARAMS; i++) {
    if(bip_functions[bip_fn_id].params[i].id == BP_VARIABLES) break;
    BP_SET_VARIABLE( // Set back global bip_variables;
      bip_functions[bip_fn_id].params[i].id,
      bip_functions[bip_fn_id].params[i].value
    );
    bip_functions[bip_fn_id].params[i].id = BP_VARIABLES;
    bip_functions[bip_fn_id].params[i].value = 0;
  }
  DCD_GOTO(bip_functions[bip_fn_id].address);
  bip_fw_id = bip_functions[bip_fn_id].cid;
  return rel;
};

/* CONTINUE ---------------------------------------------------------------- */
void bip_continue_call() {
  int16_t id = bip_fw_id;
  while(bip_fw_id <= id) {
    if(dcd_current == BP_NEXT) id--;
    if(dcd_current == BP_WHILE || dcd_current == BP_FOR) id++;
    if(bip_fw_id <= id) DCD_NEXT;
  }
};

/* BREAK ------------------------------------------------------------------- */
void bip_break_call() {
  bip_continue_call();
  DCD_NEXT;
};

/* CYCLE ------------------------------------------------------------------- */
void bip_for_call() {
  uint8_t vi = *(dcd_ptr - 1) - BP_OFFSET;
  BP_VAR_T l, v;
  if(bip_fw_id < BP_CYCLE_DEPTH) {
    v = bip_expression();
    BP_EXPECT(BP_COMMA);
    if((l = bip_expression()) == v) {
      bip_continue_call();
      DCD_NEXT;
      return;
    }
    bip_for_variables[vi] = v;
    bip_cycles[bip_fw_id].var_id = vi;
    bip_cycles[bip_fw_id].to = l;
    if(bip_ignore(BP_COMMA)) bip_cycles[bip_fw_id].step = bip_relation();
    else bip_cycles[bip_fw_id].step = (v < l) ? 1 : -1;
    bip_cycles[bip_fw_id++].address = dcd_ptr;
  } else bip_error_fun(dcd_ptr, BP_ERROR_FOR_MAX);
};

/* NEXT -------------------------------------------------------------------- */
BP_FUN_T void bip_next_call() {
  if(bip_fw_id) {
    if(bip_cycles[bip_fw_id - 1].var_id == BP_VARIABLES) {
      char *bp_while_next_addr = dcd_ptr;
      DCD_GOTO(bip_cycles[bip_fw_id - 1].address);
      if(bip_relation() <= 0) {
        DCD_GOTO(bp_while_next_addr);
        bip_fw_id--;
      }
    } else {
      uint8_t bp_next_addr = bip_cycles[bip_fw_id - 1].var_id;
      bip_for_variables[bp_next_addr] += bip_cycles[bip_fw_id - 1].step;
      if(bip_for_variables[bp_next_addr] != bip_cycles[bip_fw_id - 1].to) {
        DCD_GOTO(bip_cycles[bip_fw_id - 1].address);
      } else bip_cycles[--bip_fw_id].var_id = BP_VARIABLES;
    }
  } else { bip_error(dcd_ptr, BP_ERROR_NEXT); }
}

/* WHILE ------------------------------------------------------------------- */
void bip_while_call() {
  char *start = dcd_ptr;
  if(bip_relation() > 0) {
    if(bip_fw_id < BP_CYCLE_DEPTH) {
      bip_cycles[bip_fw_id++].address = start;
    } else bip_error(dcd_ptr, BP_ERROR_WHILE_MAX);
  } else bip_break_call();
};

/* INPUT/OUTPUT FUNCTIONS -------------------------------------------------- */
BP_VAR_T bip_adc_call() {
  DCD_NEXT;
  char c = dcd_current;
  if(c == BP_READ) {
    DCD_NEXT;
    BP_VAR_T p = bip_expression();
    return BPM_AREAD(p);
  } return 0;
};

BP_VAR_T bip_io_get_call() {
  DCD_NEXT;
  BP_EXPECT(BP_READ);
  BP_VAR_T v = bip_expression();
  return BPM_IO_READ(v);
};

void bip_io_set_call() {
  char c = dcd_current;
  DCD_NEXT;
  if(dcd_current == BP_WRITE) { BP_SYS_EXPRESSION_2(BPM_IO_WRITE); }
  else if(dcd_current == BP_OPEN) { BP_SYS_EXPRESSION_2(BPM_IO_MODE); }
};

/* INPUT ------------------------------------------------------------------ */
char input_call() {
  DCD_NEXT;
  if(dcd_current == BP_READ) {
    DCD_NEXT;
    return BPM_INPUT_GET(bip_data_in_fun);
  }
  return BPM_INPUT(bip_data_in_fun);
};

/* FILE SYSTEM FUNCTIONS --------------------------------------------------- */
void bip_file_set_call() {
  DCD_NEXT;
  BP_VAR_T r;
  if(dcd_current == BP_CLOSE) {
    BP_READ_THEN_ABORT_IF_OUT_OF_BOUNDS(r, BP_FILES_MAX, BP_ERROR_FILE_MAX);
    BPM_FILE_CLOSE(bip_files[r].file);
    bip_files[r].free = true;
  } else {
    BP_READ_THEN_ABORT_IF_OUT_OF_BOUNDS(r, BP_FILES_MAX, BP_ERROR_FILE_MAX);
    BP_EXPECT(BP_COMMA);
    BP_VAR_T result = 0;
    BP_SYS_RELATION(BPM_FILE_WRITE, bip_files[r].file, result);
  }
};

BP_VAR_T bip_file_get_call() {
  DCD_NEXT;
  if(dcd_current == BP_OPEN) {
    BP_VAR_T f;
    BP_GET_ID(f, bip_files, BP_FILES_MAX, BP_ERROR_FILE_MAX);
    if(f == BP_FILES_MAX) return BP_FILES_MAX;
      BP_SYS_STRING_2(BPM_FILE_OPEN, bip_files[f].file);
    if(bip_files[f].file == NULL) bip_error(dcd_ptr, BP_ERROR_FILE_OPEN);
    return f;
  } else if(dcd_current == BP_READ) {
    BP_VAR_T r;
    BP_READ_THEN_ABORT_IF_OUT_OF_BOUNDS(r, BP_FILES_MAX, BP_ERROR_FILE_MAX);
    return BPM_FILE_READ(bip_files[r].file);
  } return 0;
};

/* SERIAL SYSTEM FUNCTIONS ------------------------------------------------- */
BP_VAR_T bip_serial_call() {
  DCD_NEXT;
  char c = dcd_current;
  BP_VAR_T r;
  DCD_NEXT;
  if(c == BP_WRITE) {
    BP_VAR_T r = 0;
    BP_SYS_RELATION(BPM_SERIAL_WRITE, bip_serial_fun, r);
    return r;
  } else if(c == BP_READ) {
    return BPM_SERIAL_READ(bip_serial_fun);
  } else if(c == BP_OPEN) {
    bip_read_string(bip_string);
    BP_EXPECT(BP_COMMA);
    BP_VAR_T bd = bip_factor();
    BPM_SERIAL_OPEN(bip_serial_fun, bip_string, bd);
    return bip_serial_fun;
  } else if(c == BP_CLOSE) {
    BPM_SERIAL_FLUSH(bip_serial_fun);
  }
  return 0;
};

/* STRING LENGTH CALL ------------------------------------------------------ */
BP_VAR_T bip_sizeof_call() {
  DCD_NEXT;
  if(bip_ignore(BP_STR_ADDR)) {
    BP_VAR_T l = strlen(bip_strings[*(dcd_ptr - 1) - BP_OFFSET]);
    return l;
  } else if(dcd_current == BP_STR_ACC)
    return strlen(bip_strings[bip_access(BP_STR_ACC)]);
  else if(bip_ignore(BP_VAR_ADDR)) return sizeof(BP_VAR_T);
  return 0;
};

/* ATOL - LTOA ------------------------------------------------------------- */
BP_VAR_T bip_atol_call(BP_VAR_T v) { BP_SYS_STRING(BPM_ATOL, v); };

void bip_ltoa_call() {
  DCD_NEXT;
  BP_VAR_T v = bip_relation(), s = 0;
  BP_EXPECT(BP_COMMA);
  if(dcd_current == BP_STR_ACC) s = bip_access(BP_STR_ACC);
  else {
    DCD_NEXT;
    s = *(dcd_ptr - 1) - BP_OFFSET;
  }
  if((s < 0) || (s >= BP_STRINGS)) bip_error(dcd_ptr, BP_ERROR_STRING_GET);
  if(bip_ignore(BP_COMMA)) BPM_LTOA(v, bip_strings[s], bip_relation());
  BPM_LTOA(v, bip_strings[s], 0);
};

/* RANDOM CALL (Expects one parameter: the exclusive maximum value) -------- */
BP_VAR_T bip_random_call() {
  BP_VAR_T a = bip_expression(), b = BPM_RANDOM(a);
  return b;
};

BP_VAR_T bip_pipe_call(BP_VAR_T v) {
  DCD_NEXT;
  if(dcd_current == BP_OPEN) {
    BP_VAR_T p;
    BP_GET_ID(p, bip_pipes, BP_PIPES_MAX, BP_ERROR_PIPE_MAX);
    if(p == BP_PIPES_MAX) return BP_PIPES_MAX;
      BP_SYS_STRING_2(BPM_PIPE_OPEN, bip_pipes[p].pipe);
    if(bip_pipes[p].pipe == NULL) {
      bip_pipes[p].free = true;
      bip_error(dcd_ptr, BP_ERROR_PIPE_OPEN);
    }
    return p;
  }
  if(dcd_current == BP_READ) {
    BP_READ_THEN_ABORT_IF_OUT_OF_BOUNDS(v, BP_PIPES_MAX, BP_ERROR_PIPE_MAX);
    return BPM_PIPE_READ(bip_pipes[v].pipe);
  }
  if(dcd_current == BP_WRITE) {
    BP_READ_THEN_ABORT_IF_OUT_OF_BOUNDS(v, BP_PIPES_MAX, BP_ERROR_PIPE_MAX);
    BP_EXPECT(BP_COMMA);
    return BPM_PIPE_WRITE(bip_pipes[v].pipe, bip_expression());
  }
  if(dcd_current == BP_CLOSE) {
    BP_READ_THEN_ABORT_IF_OUT_OF_BOUNDS(v, BP_PIPES_MAX, BP_ERROR_PIPE_MAX);
    BPM_PIPE_CLOSE(bip_pipes[v].pipe);
    bip_pipes[v].free = true;
  }
  return 0;
};

/* STATEMENTS: (print, if, return, for, while...) -------------------------- */
void bip_statement() {
  BP_STATEMENT;
};