116 lines
2.7 KiB
C
116 lines
2.7 KiB
C
// === Includes
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "execution/execution.h"
|
|
#include "io_backend/io_backend.h"
|
|
#include "lexer/lexer.h"
|
|
#include "parser/parser.h"
|
|
#include "utils/args/args.h"
|
|
#include "utils/vars/vars.h"
|
|
|
|
// === Error codes
|
|
|
|
#define SUCCESS 0
|
|
#define ERR_INPUT_PROCESSING 2
|
|
#define ERR_MALLOC 3
|
|
#define ERR_GENERIC 4
|
|
|
|
// === Functions
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
// Create the options struct (with argument handler)
|
|
struct args_options options;
|
|
int return_code = args_handler(argc, argv, &options);
|
|
if (return_code != 0)
|
|
{
|
|
print_usage(stderr, argv[0]);
|
|
return ERR_INPUT_PROCESSING;
|
|
}
|
|
// args_print(&options);
|
|
|
|
// Initialize variables hash map
|
|
struct hash_map *vars = vars_init();
|
|
if (vars == NULL)
|
|
{
|
|
fprintf(stderr, "Error: Failed to initialize variables hash map\n");
|
|
return ERR_MALLOC;
|
|
}
|
|
|
|
// Create the IO-Backend context struct
|
|
struct iob_context *io_context = malloc(sizeof(struct iob_context));
|
|
if (io_context == NULL)
|
|
{
|
|
fprintf(stderr,
|
|
"Error: Memory allocation failed for IO Backend context\n");
|
|
return ERR_MALLOC;
|
|
}
|
|
|
|
// Convert args_options to iob_context
|
|
return_code = iob_config_from_args(&options, io_context);
|
|
if (return_code != 0)
|
|
{
|
|
fprintf(stderr,
|
|
"Error: Failed to configure IO Backend from arguments\n");
|
|
free(io_context);
|
|
return ERR_INPUT_PROCESSING;
|
|
}
|
|
|
|
// Init IO Backend (with the context struct)
|
|
return_code = iob_init(io_context);
|
|
if (return_code != 0)
|
|
{
|
|
fprintf(stderr,
|
|
"Error: IO Backend initialization failed with code %d\n",
|
|
return_code);
|
|
free(io_context);
|
|
return ERR_INPUT_PROCESSING;
|
|
}
|
|
|
|
free(io_context);
|
|
|
|
// init lexer context
|
|
struct lexer_context *ctx = calloc(1, sizeof(struct lexer_context));
|
|
|
|
// init parser
|
|
int parser_init();
|
|
|
|
// Retrieve and build first AST
|
|
struct ast *command_ast = get_ast(ctx);
|
|
|
|
if (options.pretty_print)
|
|
{
|
|
ast_print_dot(command_ast);
|
|
}
|
|
|
|
// Main parse-execute loop
|
|
while (command_ast != NULL && command_ast->type != AST_END)
|
|
{
|
|
if (command_ast->type != AST_VOID)
|
|
{
|
|
// Execute AST
|
|
return_code = execution(command_ast, vars);
|
|
|
|
// set $? variable
|
|
set_var_int(vars, "?", return_code);
|
|
}
|
|
|
|
ast_free(&command_ast);
|
|
|
|
// Retrieve and build next AST
|
|
command_ast = get_ast(ctx);
|
|
}
|
|
|
|
destroy_lexer_context(&ctx);
|
|
|
|
hash_map_free(&vars);
|
|
|
|
if (command_ast == NULL)
|
|
return ERR_INPUT_PROCESSING;
|
|
|
|
ast_free(&command_ast);
|
|
parser_close();
|
|
|
|
return return_code;
|
|
}
|