fml.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <ctype.h>

#include "arena.h"
#include "parser.h"
#include "ast_interpreter.h"

#define AST_INTERPRETER_COMMAND "ast_interpret"
#define RUN "run"
#define HEAP_SIZE_COMMAND "--heap-size"
#define HEAP_LOG_COMMAND "--heap-log"

#define DEFAULT_HEAP_SIZE 512

int main ( int argc, char **argv ) {
	if ( argc < 2 ) {
		fprintf( stderr, "Input error: expected at least one argument\n" );
		return 1;
	}

  size_t heap_size = DEFAULT_HEAP_SIZE;
  char * log_file = NULL;

  u8 flag = 0;
  u8 ast_interpret = 0;
  size_t len;
  int f = -1;
  for ( int arg = 1; arg < argc; ++arg ) {
    len = strlen ( argv [ arg ] );
    for ( size_t j = 0; j < len; j++ )
      argv [ arg ] [ j ] = tolower ( argv [ arg ] [ j ] );
    if ( len == strlen ( AST_INTERPRETER_COMMAND ) && strncmp ( argv [ arg ], AST_INTERPRETER_COMMAND, len ) == 0 ) {
      ast_interpret = 1;
      f = ++arg;
    } else if ( len == strlen ( RUN ) && strncmp ( argv [ arg ], RUN, len ) == 0 ) {
      ast_interpret = 1;
      for ( size_t opt = 0; opt < 2; ++opt ) {
        len = strlen ( argv [ ++arg ] );
        if ( len == strlen ( HEAP_SIZE_COMMAND ) && strncmp ( argv [ arg ], HEAP_SIZE_COMMAND, len ) == 0 ) {
          heap_size = atoi ( argv [ ++arg ] );
          if ( heap_size == 0 ) {
		        fprintf( stderr, "Input error: invalid heap size %s.\n", argv [ arg ] );
            flag = 2;
          }
        } else if ( len == strlen ( HEAP_LOG_COMMAND ) && strncmp ( argv [ arg ], HEAP_LOG_COMMAND, len ) == 0 ) {
          log_file = argv [ ++arg ];
        }
      }
      f = ++arg;
    } else {
		  fprintf( stderr, "Input error: unknown argument %s.\n", argv [ arg ] );
      flag = 1;
    }    
  }

  if ( flag || f <= 0 ) 
    return 1;

  FILE * fp = fopen ( argv [ f ], "r" );
  (void) log_file;
  if ( ! fp ) {
    fprintf ( stderr, "Input error: file does not exists.\n" );
    return 1;
  }

  if ( fseek ( fp, 0, SEEK_END ) ) {
    fprintf ( stderr, "Input error: could not advance to the end of the file.\n" );
    return 1;
  }

  int file_len = ftell ( fp );
  if ( file_len < 0 ) {
    fprintf ( stderr, "Input error: could not count the size of the file.\n" );
    return 1;
  }
  
  size_t flen = file_len;

  rewind ( fp );

  u8 * buffer = malloc ( flen );
  if ( fread ( buffer, 1, flen, fp ) != flen ) {
    fprintf ( stderr, "Input error: could not read to the file.\n" );
    return 1;
  }

  fclose ( fp );
  

	Arena arena;
	arena_init( &arena );

	Ast *ast = parse_src ( &arena, (Str) { .str = buffer, .len = flen } );

	if ( ast == NULL ) {
		fprintf ( stderr, "Failed to parse source\n" );
		arena_destroy ( &arena );
		return 1;
	}

  if ( ast_interpret ) {
    ASTInterpreterState state;
    Heap heap;
    heap_init ( &heap, heap_size * 1024 * 1024 );
    state_init ( &state, &heap );
    evaluate ( &state, ast );
    state_destroy ( &state );
  }


  free ( buffer );
	arena_destroy( &arena );

	return 0;
}