/**
 * Part of the Lccrt Project, under the Apache License v2.0
 * See http://www.apache.org/licenses/LICENSE-2.0.txt for license information.
 * SPDX-License-Identifier: Apache-2.0
 *
 * lccrt_ctx.c - реализация пользовательский интерфейс (динамической) компиляции.
 */

#define _GNU_SOURCE
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
#include <errno.h>
#include <ctype.h>
#include <limits.h>
#include <dlfcn.h>
#include <libgen.h>
#include <sys/syscall.h>
#include <unistd.h>

#include "lccrt_irv.h"

#define LCCRT_CTX_PLUGIN_MAX_NUMBER (256)
#define LCCRT_CTX_PLUGIN_TARGET_MAX_NUMBER (256)
#define LCCRT_CTX_PLUGIN_NAME_LENGTH (4096 - 1)

#define lccrt_ctx_error_plugin_sym( ctx, lname, sname) \
    lccrt_ctx_error( ctx, 0, "Plugin library [%s] hasn't symbol [%s]\n", \
                     lname, sname)

lccrt_check_type_define( lccrt_type_t);
lccrt_check_type_define( lccrt_varinit_t);
lccrt_check_type_define( lccrt_var_t);
lccrt_check_type_define( lccrt_oper_t);
lccrt_check_type_define( lccrt_oper_iterator_t);
lccrt_check_type_define( lccrt_function_t);
lccrt_check_type_define( lccrt_function_jit_info_t);
lccrt_check_type_define( lccrt_module_t);
lccrt_check_type_define( lccrt_einfo_tydescr_t);
lccrt_check_type_define( lccrt_einfo_block_t);
lccrt_check_type_define( lccrt_einfo_link_t);
lccrt_check_type_define( lccrt_context_t);
lccrt_check_type_define( lccrt_plugin_t);

/**
 * Данные стандартного менеджера вывода сообщений в файл.
 */
typedef struct
{
    int8_t is_init; /* флаг инициализации структуры */
    FILE *file; /* файл для печати сообщений */
    pid_t pid; /* идентификатор родительского процесса */
} lccrt_dir_error_info_t;

static void *lccrt_std_alloc( void *pool, uint64_t size);
static void *lccrt_std_realloc( void *pool, void *ptr, uint64_t size);
static void lccrt_std_free( void *pool, void *ptr);
static void lccrt_std_error( void *data, int errid, const char *fmt, ...);
static void lccrt_dir_error( void *data, int errid, const char *fmt, ...);
static void lccrt_std_warning( void *data, int errid, const char *fmt, ...);
static void lccrt_dir_warning( void *data, int errid, const char *fmt, ...);

/**
 * Стандартные менеджеры.
 */
lccrt_err_t lccrt_std_err = {0, &lccrt_std_error, &lccrt_std_warning};
lccrt_mem_t lccrt_std_mem = {0, &lccrt_std_alloc, &lccrt_std_realloc, &lccrt_std_free};
lccrt_err_t lccrt_dir_err = {0, &lccrt_dir_error, &lccrt_dir_warning};

/**
 * Стандартный malloc.
 */
static void *
lccrt_std_alloc( void *pool, uint64_t size)
{
    void *result = (void *)malloc( size);

    return (result);
} /* lccrt_std_alloc */

/**
 * Стандартный realloc.
 */
static void *
lccrt_std_realloc( void *pool, void *ptr, uint64_t size)
{
    void *result = (void *)realloc( ptr, size);

    return (result);
} /* lccrt_std_realloc */

/**
 * Стандартный free.
 */
static void
lccrt_std_free( void *pool, void *ptr)
{
    free( ptr);

    return;
} /* lccrt_std_free */

/**
 * Стандартная реакция на ошибку.
 */
static void
lccrt_std_error( void *data, int errid, const char *fmt, ...)
{
    char str[256];
    va_list ap;

    va_start( ap, fmt);
    vsnprintf( str, 255, fmt, ap);
    va_end( ap);

    perror( str);
    if ( errid )
    {
        exit( errid);
    }

    return;
} /* lccrt_std_error */

/**
 * Стандартная реакция на предупреждение.
 */
static void
lccrt_std_warning( void *data, int errid, const char *fmt, ...)
{
    char str[256];
    va_list ap;

    va_start( ap, fmt);
    vsnprintf( str, 255, fmt, ap);
    va_end( ap);

    printf( "%s", str);

    return;
} /* lccrt_std_warning */

/**
 * Подготовка данных для вывода сообщений.
 */
static lccrt_dir_error_info_t *
lccrt_dir_error_init( void)
{
    static __thread lccrt_dir_error_info_t ei = {0};

    if ( !ei.is_init
         || (ei.pid != getpid()) )
    {
        char s[1024];
        const char *dir_name = getenv( "LCCRT_ERRDIR");

        ei.is_init = 1;
        ei.pid = getpid();
        if ( !dir_name
             || (dir_name[0] == 0) )
        {
            dir_name = ".";
        }

        snprintf( s, 1024, "mkdir -p -m a+rwx %s", dir_name);
        system( s);

        snprintf( s, 1024, "%s/lccrt.errlog.pid_%d.tid_%d.txt", dir_name, getpid(), (unsigned)syscall( SYS_gettid));
        ei.file = fopen( s, "w");
    }

    return (&ei);
} /* lccrt_dir_error_init */

/**
 * Стандартная реакция на ошибку.
 */
static void
lccrt_dir_error( void *data, int errid, const char *fmt, ...)
{
    va_list ap;
    lccrt_dir_error_info_t *ei = lccrt_dir_error_init();

    va_start( ap, fmt);
    vfprintf( ei->file, fmt, ap);
    va_end( ap);

    fflush( ei->file);

    if ( errid )
    {
        exit( errid);
    }

    return;
} /* lccrt_dir_error */

/**
 * Стандартная реакция на предупреждение.
 */
static void
lccrt_dir_warning( void *data, int errid, const char *fmt, ...)
{
    va_list ap;
    lccrt_dir_error_info_t *ei = lccrt_dir_error_init();

    va_start( ap, fmt);
    vfprintf( ei->file, fmt, ap);
    va_end( ap);

    fflush( ei->file);

    return;
} /* lccrt_dir_warning */

/**
 * Чтение из файла строки.
 */
static void
lccrt_getline( FILE *f, int max_str_len, char *line)
{
    int c;
    int k = 0;

    c = getc( f);
    while ( (c != '\n')
            && (c != EOF)
            && isspace( c) )
    {
        c = getc( f);
    }

    while ( (c != '\n')
            && (c != EOF) )
    {
        if ( (k < max_str_len) )
        {
            line[k] = c;
            ++k;
        }

        c = getc( f);
    }

    line[k] = 0;

    return;
} /* lccrt_getline */

/**
 * Получить ссылку на метод.
 */
void *
lccrt_ctx_plugin_get_func( lccrt_plg_ptr p, int func_num)
{
    void *r = 0;

    lccrt_check_type_assert( p, lccrt_plugin_t);
    if ( (0 <= func_num)
         && (func_num < p->num_funcs) )
    {
        r = p->funcs[func_num];
    }

    return (r);
} /* lccrt_ctx_plugin_get_func */

/**
 * Закрытие библиотеки с ассемблером.
 */
static void
lccrt_ctx_plugin_unload( lccrt_plugin_t *a)
{
    int k;
    lccrt_context_ptr ctx = a->ctx;

    lccrt_check_type_assert( a, lccrt_plugin_t);
    if ( a->lib )
    {
        dlclose( a->lib);
        a->lib = 0;
    }

    if ( a->targs )
    {
        for ( k = 0; k < a->num_targs; ++k )
        {
            lccrt_ctx_free( ctx, a->targs[k]);
            lccrt_ctx_free( ctx, a->lccrt_s[k]);
            lccrt_ctx_free( ctx, a->include_s[k]);
        }

        lccrt_ctx_free( ctx, a->targs);
        lccrt_ctx_free( ctx, a->lccrt_s);
        lccrt_ctx_free( ctx, a->include_s);
        a->targs = 0;
    }

    lccrt_ctx_free( ctx, a->lib_name);
    lccrt_ctx_free( ctx, a->lccrt_ver);
    lccrt_ctx_free( ctx, a->lccrt_s);
    lccrt_ctx_free( ctx, a->include_s);
    a->lib_name = 0;
    a->lccrt_ver = 0;
    a->lccrt_s = 0;
    a->include_s = 0;

    a->num_targs = 0;
    a->num_funcs = 0;
    lccrt_ctx_free( ctx, a->funcs);
    a->funcs = 0;

    return;
} /* lccrt_ctx_plugin_unload */

/**
 * Открытие библиотеки с ассемблером.
 */
static int
lccrt_ctx_load_plugin_lib( lccrt_plugin_t *a, const char *lib_name)
{
    int k;
    int r = -1;
    char *cur_name = 0;
    lccrt_context_ptr ctx = a->ctx;

    lccrt_check_type_assert( a, lccrt_plugin_t);
    if ( a->lib )
    {
        lccrt_ctx_error( ctx, 0, "INTERNAL ERROR\n");
        return (r);
    }

    if ( (lib_name[0] == '/') )
    {
        cur_name = lccrt_ctx_copy_str( ctx, lib_name);
    } else
    {
        cur_name = lccrt_ctx_cat_strs( ctx, ctx->paths.plugins[a->type], "/");
        cur_name = lccrt_ctx_catby_strs( ctx, cur_name, lib_name);
    }

    a->lib = dlopen( cur_name, RTLD_LAZY);
    if ( !a->lib )
    {
        lccrt_ctx_error( ctx, 0, "Can't load plugin library [%s]\n", cur_name);
    } else
    {
        const char **lname;
        const char **lver;
        const char *(*targs)[];
        int is_asm = (a->type == LCCRT_PLUGIN_TYPE_ASM);

        a->num_funcs = LCCRT_PLUGIN_ASM_FUNC_LAST;
        a->funcs = lccrt_ctx_mallocn( ctx, void *, a->num_funcs);
        if ( is_asm )
        {
            a->funcs[LCCRT_PLUGIN_ASM_FUNC_COMP] = dlsym( a->lib, LCCRT_ASM_SFUNC_COMPILE);
            a->funcs[LCCRT_PLUGIN_ASM_FUNC_TOOL] = dlsym( a->lib, LCCRT_ASM_SFUNC_GETTOOL);
            if ( !a->funcs[LCCRT_PLUGIN_ASM_FUNC_COMP] )
            {
                lccrt_ctx_error_plugin_sym( ctx, cur_name, LCCRT_ASM_SFUNC_COMPILE);

            } else if ( !a->funcs[LCCRT_PLUGIN_ASM_FUNC_TOOL] )
            {
                lccrt_ctx_error_plugin_sym( ctx, cur_name, LCCRT_ASM_SFUNC_GETTOOL);
            }
        } else
        {
            lccrt_assert( 0);
        }

        lname = dlsym( a->lib, LCCRT_PLUGIN_LIBRARY_NAME_S);
        lver = dlsym( a->lib, LCCRT_PLUGIN_LCCRT_VERSION_S);
        targs = dlsym( a->lib, LCCRT_PLUGIN_TARGETS_S);
        if ( !lname
             || !lname[0] )
        {
            lccrt_ctx_error_plugin_sym( ctx, cur_name, LCCRT_PLUGIN_LIBRARY_NAME_S);

        } else if ( !lname[0][0] )
        {
            lccrt_ctx_error( ctx, 0, "Plugin library [%s] name [%s] is incorrect\n",
                             cur_name, lname[0]);

        } else if ( !lver
                    || !lver[0] )
        {
            lccrt_ctx_error_plugin_sym( ctx, cur_name, LCCRT_PLUGIN_LCCRT_VERSION_S);

        } else if ( !targs )
        {
            lccrt_ctx_error_plugin_sym( ctx, cur_name, LCCRT_PLUGIN_TARGETS_S);
        } else
        {
            if ( ctx->verbose.is_base )
            {
                fprintf( stderr, "LCCRT: plugin [%s] config:\n", lib_name);
            }

            a->lib_name = lccrt_ctx_copy_str( ctx, lname[0]);
            a->lccrt_ver = lccrt_ctx_copy_str( ctx, lver[0]);
            if ( ctx->verbose.is_base )
            {
                fprintf( stderr, "    plugin self-name                  : %s\n", a->lib_name);
                fprintf( stderr, "    plugin's version of lccrt-library : %s\n", a->lccrt_ver);
            }

            a->num_targs = 0;
            for ( k = 0; (*targs)[k]; ++k )
            {
                a->num_targs++;
            }

            if ( (0 < a->num_targs)
                 && (a->num_targs < LCCRT_CTX_PLUGIN_TARGET_MAX_NUMBER) )
            {
                r = 0;
                a->targs = lccrt_ctx_mallocn( ctx, const char *, a->num_targs);
                a->lccrt_s = lccrt_ctx_mallocn( ctx, const char *, a->num_targs);
                a->include_s = lccrt_ctx_mallocn( ctx, const char *, a->num_targs);
                memset( a->targs, 0, a->num_targs*sizeof( a->lccrt_s[0]));
                memset( a->lccrt_s, 0, a->num_targs*sizeof( a->lccrt_s[0]));
                memset( a->include_s, 0, a->num_targs*sizeof( a->include_s[0]));
                for ( k = 0; k < a->num_targs; ++k )
                {
                    char buf[1024] = {0};

                    a->targs[k] = lccrt_ctx_copy_str( ctx, (*targs)[k]);
                    if ( ctx->verbose.is_base )
                    {
                        fprintf( stderr, "    plugin's target (%d)               : %s\n", k, a->targs[k]);
                    }

                    snprintf( buf, 1024, "%s/lib/%s", ctx->paths.home, a->targs[k]);
                    a->lccrt_s[k] = lccrt_ctx_copy_str( ctx, buf);
                    if ( ctx->verbose.is_base )
                    {
                        fprintf( stderr, "      plugin's target system libraries path : %s\n", a->lccrt_s[k]);
                    }

                    snprintf( buf, 1024, "%s/include/%s", ctx->paths.home, a->targs[k]);
                    a->include_s[k] = lccrt_ctx_copy_str( ctx, buf);
                    if ( ctx->verbose.is_base )
                    {
                        fprintf( stderr, "      plugin's target system include path : %s\n", a->include_s[k]);
                    }

                    if ( lccrt_str_eq( a->lib_name, "lccopt-e2k64") )
                    {
                        FILE *flib = 0;

                        snprintf( buf, 1024, "%s/liblccrt_s.a", a->lccrt_s[k]);
                        flib = fopen( buf, "r");

                        if ( !flib )
                        {
                            r = -1;
                            lccrt_ctx_error( ctx, 0, "Can't find system library [liblccrt_s.a] by path [%s]\n",
                                             a->lccrt_s[k]);
                            break;
                        } else
                        {
                            fclose( flib);
                        }
                    }
                }
            } else
            {
                a->num_targs = 0;
                lccrt_ctx_error( ctx, 0, "Plugin library [%s] number of targets [%d]\n",
                                 cur_name, a->num_targs);
            }
        }
    }

    lccrt_ctx_free( ctx, cur_name);
    if ( r )
    {
        lccrt_ctx_plugin_unload( a);
    }

    return (r);
} /* lccrt_ctx_load_plugin_lib */

/**
 * Поиск lccrt-home пути на основе пути к liblccrt.so (места расположения загруженной библиотеки).
 */
char *
lccrt_ctx_find_home_path( lccrt_ctx_ptr ctx)
{
    Dl_info dli;
    char *t = 0;
    char *s = 0;

    dladdr( &lccrt_ctx_find_home_path, &dli);
    t = realpath( dli.dli_fname, 0);
    if ( !t )
    {
        lccrt_ctx_error( ctx, 0, "Can't resolve real path of lccrt-library's location [%s]\n", dli.dli_fname);
    }

    s = dirname( t);
    if ( !s )
    {
        lccrt_ctx_error( ctx, 0, "Can't resolve directory of lccrt-library's location [%s]\n", t);
    }

    s = lccrt_ctx_cat_strs( ctx, s, "/lccrt");
    free( t);

    return (s);
} /* lccrt_ctx_find_home_path */

/**
 * Загрузка плагина.
 */
static int
lccrt_ctx_load_plugin( lccrt_ctx_ptr ctx, lccrt_plugin_type_t type, const char *env, const char *dir)
{
    int k;
    int r = 0;
    char *f_name = 0;
    FILE *f = 0;
    int num_ps = 0;
    lccrt_plugin_t ps[LCCRT_CTX_PLUGIN_MAX_NUMBER] = {0};

    if ( getenv( env) )
    {
        ctx->paths.plugins[type] = lccrt_ctx_copy_str( ctx, getenv( env));
    } else
    {
        ctx->paths.plugins[type] = lccrt_ctx_cat_strs( ctx, ctx->paths.plugin, "/");
        ctx->paths.plugins[type] = lccrt_ctx_cat_strs( ctx, ctx->paths.plugins[type], dir);
    }

    f_name = lccrt_ctx_cat_strs( ctx, ctx->paths.plugins[type], "/plugin.conf");
    f = fopen( f_name, "r");
    if ( !f )
    {
        lccrt_ctx_error( ctx, 0, "Can't open plugin [%s] config file [%s]\n", dir, f_name);
        lccrt_ctx_free( ctx, f_name);
        r = -1;
    } else
    {
        char name[LCCRT_CTX_PLUGIN_NAME_LENGTH + 1];

        lccrt_ctx_free( ctx, f_name);
        while ( !feof( f) )
        {
            lccrt_getline( f, LCCRT_CTX_PLUGIN_NAME_LENGTH, name);
            if ( (name[0] == '#')
                 || (name[0] == 0) )
            {
                /* Пропускаем текущую строчку. */
            } else
            {
                if ( (num_ps < LCCRT_CTX_PLUGIN_MAX_NUMBER) )
                {
                    int is_load = 0;

                    lccrt_check_type_init( ps + num_ps, lccrt_plugin_t);
                    ps[num_ps].ctx = ctx;
                    ps[num_ps].type = type;
                    if ( (lccrt_ctx_load_plugin_lib( ps + num_ps, name) == 0) )
                    {
                        is_load = 1;
                        num_ps++;
                        for ( k = 0; k < num_ps - 1; ++k )
                        {
                            if ( lccrt_str_eq( ps[k].lib_name, ps[num_ps-1].lib_name) )
                            {
                                is_load = 0;
                                lccrt_ctx_error( ctx, 0, "Duplicate plugin name [%s]\n",
                                                 ps[k].lib_name);
                                break;
                            }
                        }
                    }

                    if ( !is_load )
                    {
                        lccrt_ctx_error( ctx, 0, "Can't load plugin [%s]\n", name);
                        for ( k = 0; k < num_ps; ++k )
                        {
                            lccrt_ctx_plugin_unload( ps + k);
                        }

                        lccrt_context_delete( ctx);
                        return (0);
                    }
                }
            }
        }

        fclose( f);
        if ( (num_ps == 0) )
        {
            //lccrt_ctx_warning( ctx, 0, "The plugin [%s] set is empty\n", dir);
        } else
        {
            ctx->num_plgs[type] = num_ps;
            ctx->plgs[type] = lccrt_ctx_memdup( ctx, ps, num_ps * sizeof( ps[0]));
        }
    }

    return (r);
} /* lccrt_ctx_load_plugin */

/**
 * Создание контекста (конструктор).
 * ---------------------------------
 * @param   mem      менеджер памяти (0 - менеджер по умолчанию)
 * @param   err      менеджер сообщений об ошибках (0 - менеджер по умолчанию)
 * @result           новый контекст, созданный с помощью менеджера памяти
 *
 * @ingroup tyCtxFns
 */
lccrt_context_ptr
lccrt_context_new( lccrt_mem_ptr mem, lccrt_err_ptr err)
{
    int k;
    lccrt_context_ptr ctx = 0;
    FILE *pc = 0;

    if ( !mem )
    {
        mem = &lccrt_std_mem;
    }

    if ( !err )
    {
        err = &lccrt_std_err;
    }

    if ( getenv( "LCCRT_ERRDIR") )
    {
        err = &lccrt_dir_err;
    }

    ctx = (*mem->palloc)( mem->pool, sizeof( lccrt_context_t));
    memset( ctx, 0, sizeof( lccrt_context_t));
    lccrt_check_type_init( ctx, lccrt_context_t);
    ctx->mem = *mem;
    ctx->err = *err;
    ctx->modules = lccrt_hash_new( ctx, LCCRT_HASH_KEY_INTPTR);
    ctx->module_max = 0;

    if ( getenv( "LCCRT_HOME") )
    {
        ctx->paths.home = lccrt_ctx_copy_str( ctx, getenv( "LCCRT_HOME"));
    } else
    {
        ctx->paths.home = lccrt_ctx_find_home_path( ctx);
    }

    if ( getenv( "LCCRT_HOME_PLUGIN") )
    {
        ctx->paths.plugin = lccrt_ctx_copy_str( ctx, getenv( "LCCRT_HOME_PLUGIN"));
    } else
    {
        ctx->paths.plugin = lccrt_ctx_cat_strs( ctx, ctx->paths.home, "/plugin");
    }

    if ( getenv( "LCCRT_VERBOSE") )
    {
        ctx->verbose.is_base = atoi( getenv( "LCCRT_VERBOSE"));
    }

    lccrt_ctx_load_plugin( ctx, LCCRT_PLUGIN_TYPE_ASM, "LCCRT_PLUGIN_TYPE_ASM", "asm");

    return (ctx);
} /* lccrt_context_new */

/**
 * Удаление контекста (деструктор).
 * --------------------------------
 * @param   ctx                удаляемый контекст
 *
 * @ingroup tyCtxFns
 */
void
lccrt_context_delete( lccrt_context_ptr ctx)
{
    lccrt_hash_entry_ptr he;

    lccrt_check_type_assert( ctx, lccrt_context_t);

    /* Удаляем все ранее созданные модули. */
    while ( (he = lccrt_hash_first( ctx->modules)) )
    {
        lccrt_module_delete( (lccrt_module_ptr)lccrt_hash_get_key( he));
    }
    lccrt_hash_delete( ctx->modules);

    lccrt_ctx_free( ctx, ctx->paths.home);
    lccrt_ctx_free( ctx, ctx->paths.plugin);
    lccrt_ctx_free( ctx, ctx->paths.plugins[LCCRT_PLUGIN_TYPE_ASM]);

    lccrt_check_type_done( ctx, lccrt_context_t);
    (*ctx->mem.pfree)( ctx->mem.pool, ctx);

    return;
} /* lccrt_context_delete */

/**
 * Прочитать свойство.
 */
int
lccrt_context_get_verbose_ir( lccrt_context_ptr ctx)
{
    int r = ctx->verbose.is_ir;

    lccrt_check_type_assert( ctx, lccrt_context_t);

    return (r);
} /* lccrt_context_get_verbose_ir */

/**
 * Установить свойство.
 */
void
lccrt_context_set_verbose_ir( lccrt_context_ptr ctx, int value)
{
    lccrt_check_type_assert( ctx, lccrt_context_t);
    ctx->verbose.is_ir = value;

    return;
} /* lccrt_context_set_verbose_ir */

/**
 * Поиск плагина.
 */
static lccrt_plugin_t *
lccrt_context_find_plugin( lccrt_context_ptr c, lccrt_plugin_type_t type, const char *plg_name, int is_assert)
{
    int k;
    lccrt_plugin_t *r = 0;

    if ( plg_name )
    {
        for ( k = 0; k < c->num_plgs[type]; ++k )
        {
            if ( lccrt_str_eq( plg_name, c->plgs[type][k].lib_name) )
            {
                r = c->plgs[type] + k;
                break;
            }
        }
    }

    if ( !r
         && is_assert )
    {
        lccrt_ctx_error( c, 0, "No plugin with name [%s]\n", plg_name);
    }

    return (r);
} /* lccrt_context_find_plugin */

/**
 * Поиск плагина.
 */
static lccrt_plg_ptr
lccrt_context_find_plugin_for_arch( lccrt_context_ptr c, lccrt_plugin_type_t type, const char *arch)
{
    int k, i;
    lccrt_plg_ptr r = 0;

    for ( k = 0; k < c->num_plgs[type] && !r; ++k )
    {
        lccrt_plg_ptr p = c->plgs[type] + k;

        for ( i = 0; i < p->num_targs; ++i )
        {
            if ( lccrt_str_eq( arch, p->targs[i]) )
            {
                r = p;
                break;
            }
        }
    }

    if ( !r )
    {
        lccrt_ctx_error( c, 0, "No plugin for target [%s]\n", arch);
    }

    return (r);
} /* lccrt_context_find_plugin_for_arch */

/**
 * Получить ссылку на плагин.
 */
lccrt_plg_ptr
lccrt_context_get_plugin_asm( lccrt_ctx_ptr ctx, const char *plg_name)
{
    lccrt_plg_ptr r = lccrt_context_find_plugin( ctx, LCCRT_PLUGIN_TYPE_ASM, plg_name, 1);

    return (r);
} /* lccrt_context_get_plugin_asm */

/**
 * Поиск ассемблера.
 */
static int
lccrt_context_find_target( lccrt_context_ptr c, lccrt_plugin_t *a, const char *targ, int is_assert)
{
    int k;
    int r = -1;

    if ( a )
    {
        if ( targ )
        {
            for ( k = 0; k < a->num_targs; ++k )
            {
                if ( lccrt_str_eq( targ, a->targs[k]) )
                {
                    r = k;
                    break;
                }
            }
        }

        if ( (r < 0)
             && is_assert )
        {
            lccrt_ctx_error( c, 0, "In plugin [%s] no target [%s]\n", a->lib_name, targ);
        }
    }

    return (r);
} /* lccrt_context_find_target */

/**
 * Компиляция модуля.
 */
int
lccrt_module_compile_asm( lccrt_module_ptr m, const char *asm_lib,
                          lccrt_asm_compile_config_t *cnf)
{
    int k;
    int r = -1;
    lccrt_context_ptr c = lccrt_module_get_context( m);
    lccrt_plugin_t *a = lccrt_context_get_plugin_asm( c, asm_lib);

    if ( cnf->is_jit )
    {
        assert( 0);
    }

    if ( 0 )
    {
        lccrt_fs_ptr fs = lccrt_fs_new_file( c, stdout);

        lccrt_asm_print_module( fs, m);
        lccrt_fs_delete( fs);
    }

    if ( (lccrt_context_find_target( c, a, cnf->target, 1) >= 0) )
    {
        r = ((lccrt_asm_compile_t)a->funcs[LCCRT_PLUGIN_ASM_FUNC_COMP])( m, cnf);
    }

    return (r);
} /* lccrt_module_compile_asm */

/**
 * Получить значение утилиты.
 */
const char *
lccrt_context_get_toolchain( lccrt_ctx_ptr c, const char *asm_lib, const char *targ,
                             const char *tool_type, const char *tool_name)
{
    const char *r = "";
    lccrt_plugin_t *a = lccrt_context_get_plugin_asm( c, asm_lib);
    int k = lccrt_context_find_target( c, a, targ, 1);

    if ( (k >= 0) )
    {
        if ( lccrt_str_eq( tool_type, "lib_path")
             && lccrt_str_eq( tool_name, "lccrt_s") )
        {
            r = a->lccrt_s[k];

        } else if ( lccrt_str_eq( tool_type, "include_path")
                    && lccrt_str_eq( tool_name, "system") )
        {
            r = a->include_s[k];
        } else
        {
            r = ((lccrt_asm_gettool_t)a->funcs[LCCRT_PLUGIN_ASM_FUNC_TOOL])( targ, tool_type, tool_name);
        }
    }

    return (r);
} /* lccrt_context_get_toolchain */

/**
 * Получить значение поля.
 */
lccrt_err_t
lccrt_context_get_err_info( lccrt_ctx_ptr ctx)
{
    lccrt_err_t r;

    lccrt_check_type_assert( ctx, lccrt_context_t);
    r = ctx->err;

    return (r);
} /* lccrt_context_get_err_info */

/**
 * Установить значение поля.
 */
lccrt_err_t
lccrt_context_set_err_info( lccrt_ctx_ptr ctx, lccrt_err_t err)
{
    lccrt_err_t r;

    lccrt_check_type_assert( ctx, lccrt_context_t);
    r = ctx->err;
    ctx->err = err;

    return (r);
} /* lccrt_context_set_err_info */

/**
 * Выделение участка памяти.
 */
void *
lccrt_ctx_malloc_func( lccrt_ctx_ptr ctx, uint64_t size)
{
    void *r;

    lccrt_check_type_assert( ctx, lccrt_context_t);
    r = ctx->mem.palloc( &(ctx->mem), size);

    return (r);
} /* lccrt_ctx_malloc_func */

/**
 * Выделение участка памяти.
 */
void *
lccrt_ctx_realloc_func( lccrt_ctx_ptr ctx, void *ptr, uint64_t size)
{
    void *r;

    lccrt_check_type_assert( ctx, lccrt_context_t);
    r = ctx->mem.prealloc( &(ctx->mem), ptr, size);

    return (r);
} /* lccrt_ctx_realloc_func */

/**
 * Освобождение участка памяти.
 */
void *
lccrt_ctx_free_func( lccrt_ctx_ptr ctx, void *ptr)
{
    lccrt_check_type_assert( ctx, lccrt_context_t);
    if ( ptr )
    {
        ctx->mem.pfree( &(ctx->mem), ptr);
    }

    return (0);
} /* lccrt_ctx_free_func */

/**
 * Копирование участка памяти.
 */
void *
lccrt_ctx_memdup_func( lccrt_ctx_ptr ctx, void *ptr, uint64_t size)
{
    void *r = 0;

    lccrt_check_type_assert( ctx, lccrt_context_t);
    if ( (size > 0) )
    {
        r = ctx->mem.palloc( &(ctx->mem), size);
        if ( ptr )
        {
            memcpy( r, ptr, size);
        } else
        {
            memset( r, 0, size);
        }
    }

    return (r);
} /* lccrt_ctx_memdup_func */

/**
 * Копирование массива.
 */
void **
lccrt_ctx_copy_arr_func( lccrt_ctx_ptr ctx, void **ptr, uint64_t size, uint64_t len)
{
    uint64_t k;
    void **r = 0;

    if ( (len > 0) )
    {
        r = lccrt_ctx_malloc_func( ctx, len * sizeof( r[0]));
        for ( k = 0; k < len; ++k )
        {
            r[k] = lccrt_ctx_memdup_func( ctx, ptr[k], size);
        }
    }

    return (r);
} /* lccrt_ctx_copy_arr_func */

/**
 * Копирование участка памяти.
 */
char *
lccrt_ctx_copy_str( lccrt_ctx_ptr ctx, const char *str)
{
    void *r = 0;

    if ( str )
    {
        r = (char *)lccrt_ctx_memdup_func( ctx, (void *)str, strlen( str) + 1);
    }

    return (r);
} /* lccrt_ctx_copy_str */

/**
 * Объединение строк.
 */
char *
lccrt_ctx_cat_strs( lccrt_ctx_ptr ctx, const char *str1, const char *str2)
{
    char *r = 0;
    int len1 = str1 ? strlen( str1) : 0;
    int len2 = str2 ? strlen( str2) : 0;

    r = lccrt_ctx_malloc_func( ctx, len1 + len2 + 1);
    memcpy( r, str1, len1);
    memcpy( r + len1, str2, len2);
    r[len1 + len2] = 0;

    return (r);
} /* lccrt_ctx_cat_strs */

/**
 * Объединение строк.
 */
char *
lccrt_ctx_catby_strs( lccrt_ctx_ptr ctx, const char *str1, const char *str2)
{
    char *r = lccrt_ctx_cat_strs( ctx, str1, str2);

    lccrt_ctx_free( ctx, str1);

    return (r);
} /* lccrt_ctx_catby_strs */

/**
 * Старт внешней программы с перенаправлением стандартного потока вывода
 * на канальные файловые дескрипторы.
 */
int
lccrt_exec_with_fork( const char *path, /* первый аргумент execv */
                      char *argv[], /* второй аргумент execv */
                      pid_t *wpid,
                      int fds[2]) /* fds[0] - выходной декскриптор для внешней программы,
                                     fds[1] - входной  декскриптор для внешней программы */
{
    pid_t pid;
    int ifd[2] = {-1, -1};
    int ofd[2] = {-1, -1};
    int r = -1;

    if ( wpid )
    {
        wpid[0] = -1;
    }

    if ( fds )
    {
        if ( (pipe( ifd) != 0) )
        {
            /* Не удалось создать канал. */
            return (r);
        }

        if ( (pipe( ofd) != 0) )
        {
            /* Не удалось создать канал. */
            return (r);
        }
    }

    pid = fork();
    if ( (pid < 0) )
    {
        /* Не удалось создать процесс. */
        return (r);
    }

    if ( (pid == 0) )
    {
        /* Запускаем внешнюю программу. */
        if ( fds )
        {
            close( ifd[1]);
            dup2( ifd[0], STDIN_FILENO);
            close( ifd[0]);

            close( ofd[0]);
            dup2( ofd[1], STDOUT_FILENO);
            dup2( ofd[1], STDERR_FILENO);
            close( ofd[1]);
        }

        execvp( path, argv);
    } else
    {
        /* Возвращаем файловые дескрипторы с вводом и выводом внешней программы. */
        r = 0;
        if ( fds )
        {
            close( ifd[0]);
            close( ofd[1]);

            fds[0] = ofd[0];
            fds[1] = ifd[1];
        }

        if ( wpid )
        {
            (*wpid) = pid;
        }
    }

    return (r);
} /* lccrt_exec_with_fork */