Unfinished binary MIR from mir2c

[unia909]

Hello. I recently became interested in this project. I wrote a small program using WinAPI streams in C and compiled with mir2c. When I compile the program to text representation it runs fine. But when I compile to binary MIR, I get an Unfinished binary MIR error.

Code that i use to compile C to MIR

#include <string.h>
#include "mir.h"
#include "c2mir/c2mir.h"

typedef struct {
  char *code;
  int code_len, curr_char;
} input_t;

static int t_getc (void *data) {
  input_t *input = data;
  return input->curr_char >= input->code_len ? EOF : input->code[input->curr_char++];
}

int main() {
  MIR_context_t ctx = MIR_init();
  c2mir_init(ctx);

  const char *code =
    "#define NULL ((void*)0)\n"
    "#define WINAPI __stdcall\n"
    "typedef unsigned int DWORD, *LPDWORD;\n"
    "typedef void* LPVOID;\n"
    "typedef LPVOID HANDLE;\n"
    "\n"
    "typedef struct _SECURITY_ATTRIBUTES {\n"
    "  DWORD  nLength;\n"
    "  LPVOID lpSecurityDescriptor;\n"
    "  BOOL   bInheritHandle;\n"
    "} SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;\n"
    "\n"
    "typedef DWORD (*LPTHREAD_START_ROUTINE)(LPVOID);\n"
    "\n"
    "DWORD GetCurrentThreadId();\n"
    "HANDLE CreateThread(\n"
    "  LPSECURITY_ATTRIBUTES   lpThreadAttributes,\n"
    "  size_t                   dwStackSize,\n"
    "  LPTHREAD_START_ROUTINE  lpStartAddress,\n"
    "  LPVOID                  lpParameter,\n"
    "  DWORD                   dwCreationFlags,\n"
    "  LPDWORD                 lpThreadId\n"
    ");\n"
    "\n"
    "DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);\n"
    "\n"
    "DWORD proc(void* lpParameter) {\n"
    "  printf(\"Hello from MIR Thread %d\\n\", GetCurrentThreadId());\n"
    "  return 0;\n"
    "}\n"
    "\n"
    "int main() {\n"
    "  HANDLE hThread = CreateThread(NULL, 0, proc, NULL, 0, NULL);\n"
    "  WaitForSingleObject(hThread, 0xF5);\n"
    "  return 0;\n"
    "}\n";
  input_t input = {code, strlen(code), 0};
  struct c2mir_options options;
  options.include_dirs_num = 0;
  options.macro_commands_num = 0;
  options.module_num = 0;
  options.message_file = 0;
  options.asm_p = 0; // change this to 1 to compile text MIR
  options.debug_p = 0;
  options.ignore_warnings_p = 0;
  options.no_prepro_p = 0;
  options.object_p = 1;
  options.pedantic_p = 0;
  options.prepro_only_p = 0;
  options.verbose_p = 0;
  options.syntax_only_p = 0;
  options.prepro_output_file = 0;
  FILE *output = fopen("/ReactOS/main.mir", "w");

  int ret = c2mir_compile(ctx, &options, t_getc, &input, "DEMOS CORE", output);
  printf("ret is %d\n", ret);

  fclose(output);
  c2mir_finish(ctx);
  MIR_finish(ctx);
}

Code that running compiled mir file:

#include "mir.h"
#include <Windows.h>

int main() {
  MIR_context_t ctx = MIR_init();
  FILE *f = fopen("main.mir", "r");

#if 1 // load from binary
  MIR_read(ctx, f);
#else // load from text
  char *buf = malloc(4096);
  fread(buf, 1, 4096, f);
  MIR_scan_string(ctx, buf);
  fclose(f);
  free(buf);
#endif
  fclose(f);

  MIR_module_t mod = DLIST_HEAD(MIR_module_t, *MIR_get_module_list(ctx));
  MIR_item_t func = DLIST_TAIL(MIR_item_t, mod->items)->ref_def;

  MIR_load_external (ctx, "printf", printf);
  MIR_load_external (ctx, "CreateThread", CreateThread);
  MIR_load_external (ctx, "GetCurrentThreadId", GetCurrentThreadId);
  MIR_load_external (ctx, "WaitForSingleObject", WaitForSingleObject);
  MIR_load_module(ctx, mod);
  MIR_link(ctx, MIR_set_interp_interface, NULL);

  MIR_interp(ctx, func, NULL, 0);

  MIR_finish(ctx);
}

[vnmakarov]

Thank you for reporting this. Windows is not officially supported yet.

I've tried the same on Linux and was not able to reproduce the problem.

Although, I found that output file is closed twice. Once in c2mir_compile, and second time in main. May be that is the reason for the problem.

To be honest I don't understand why the output file is closed in c2mir_compile. It seem illogical to me. I will think should I fix this.