/*

 * This file is part of zsh, the Z shell.

 *

 * Copyright (c) 1996-1997 Zoltán Hidvégi

 * All rights reserved.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and to distribute modified versions of this software for any

 * purpose, provided that the above copyright notice and the following

 * two paragraphs appear in all copies of this software.

 *

 * In no event shall Zoltán Hidvégi or the Zsh Development Group be liable

 * to any party for direct, indirect, special, incidental, or consequential

 * damages arising out of the use of this software and its documentation,

 * even if Zoltán Hidvégi and the Zsh Development Group have been advised of

 * the possibility of such damage.

 *

 * Zoltán Hidvégi and the Zsh Development Group specifically disclaim any

 * warranties, including, but not limited to, the implied warranties of

 * merchantability and fitness for a particular purpose.  The software

 * provided hereunder is on an "as is" basis, and Zoltán Hidvégi and the

 * Zsh Development Group have no obligation to provide maintenance,

 * support, updates, enhancements, or modifications.

 *

 */

#include "zsh.mdh"

#include "module.pro"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

/* List of linked-in modules. */

/**/

LinkList linkedmodules;

/* The `zsh/main' module contains all the base code that can't actually be *

 * built as a separate module.  It is initialised by main(), so there's    *

 * nothing for the boot function to do.                                    */

/**/

int

setup_(UNUSED(Module m))

{

    return 0;

}

/**/

int

boot_(UNUSED(Module m))

{

    return 0;

}

/**/

int

cleanup_(UNUSED(Module m))

{

    return 0;

}

/**/

int

finish_(UNUSED(Module m))

{

    return 0;

}

/* This registers a builtin module.                                   */

/**/

void

register_module(char *n, Module_func setup, Module_func boot,

		Module_func cleanup, Module_func finish)

{

    Linkedmod m;

    m = (Linkedmod) zalloc(sizeof(*m));

    m->name = ztrdup(n);

    m->setup = setup;

    m->boot = boot;

    m->cleanup = cleanup;

    m->finish = finish;

    zaddlinknode(linkedmodules, m);

}

/* Print an alias. */

/**/

static void

printmodalias(Module m, Options ops)

{

    if (OPT_ISSET(ops,'L')) {

	printf("zmodload -A ");

	if (m->nam[0] == '-')

	    fputs("-- ", stdout);

	quotedzputs(m->nam, stdout);

	putchar('=');

	quotedzputs(m->u.alias, stdout);

    } else {

	nicezputs(m->nam, stdout);

	fputs(" -> ", stdout);

	nicezputs(m->u.alias, stdout);

    }

    putchar('\n');

}

/* Check if a module is linked in. */

/**/

Linkedmod

module_linked(char const *name)

{

    LinkNode node;

    for (node = firstnode(linkedmodules); node; incnode(node))

	if (!strcmp(((Linkedmod) getdata(node))->name, name))

	    return (Linkedmod) getdata(node);

    return NULL;

}

/* addbuiltin() can be used to add a new builtin.  It returns zero on *

 * success, 1 on failure.  The only possible type of failure is that  *

 * a builtin with the specified name already exists.  An autoloaded   *

 * builtin can be replaced using this function.                       */

/**/

int

addbuiltin(Builtin b)

{

    Builtin bn = (Builtin) builtintab->getnode2(builtintab, b->nam);

    if (bn && (bn->flags & BINF_ADDED))

	return 1;

    if (bn)

	builtintab->freenode(builtintab->removenode(builtintab, b->nam));

    builtintab->addnode(builtintab, b->nam, b);

    return 0;

}

/* Add multiple builtins.  binl points to a table of `size' builtin      *

 * structures.  Those for which (.flags & BINF_ADDED) is false are to be *

 * added; that flag is set if they succeed.  If any fail, an error       *

 * message is printed, using nam as the leading name.  Returns 1 if all  *

 * additions succeed, 2 if some succeed and some fail, and 0 if all (and *

 * at least 1) fail.  The usual usage in a boot_*() function would be    *

 *  return !addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab)); */

/**/

mod_export int

addbuiltins(char const *nam, Builtin binl, int size)

{

    int hads = 0, hadf = 0, n;

    for(n = 0; n < size; n++) {

	Builtin b = &binl[n];

	if(b->flags & BINF_ADDED)

	    continue;

	if(addbuiltin(b)) {

	    zwarnnam(nam, "name clash when adding builtin `%s'", b->nam, 0);

	    hadf = 1;

	} else {

	    b->flags |= BINF_ADDED;

	    hads = 2;

	}

    }

    return hadf ? hads : 1;

}

/* The list of function wrappers defined. */

/**/

FuncWrap wrappers;

/* This adds a definition for a wrapper. Return value is one in case of *

 * error and zero if all went fine. */

/**/

mod_export int

addwrapper(Module m, FuncWrap w)

{

    FuncWrap p, q;

    /*

     * We can't add a wrapper to an alias, since it's supposed

     * to behave identically to the resolved module.  This shouldn't

     * happen since we usually add wrappers when a real module is

     * loaded.

     */

    if (m->flags & MOD_ALIAS)

	return 1;

    if (w->flags & WRAPF_ADDED)

	return 1;

    for (p = wrappers, q = NULL; p; q = p, p = p->next);

    if (q)

	q->next = w;

    else

	wrappers = w;

    w->next = NULL;

    w->flags |= WRAPF_ADDED;

    w->module = m;

    return 0;

}

/* $module_path ($MODULE_PATH) */

/**/

char **module_path;

/* List of modules */

/**/

mod_export LinkList modules;

/* Define an autoloadable builtin.  It returns 0 on success, or 1 on *

 * failure.  The only possible cause of failure is that a builtin    *

 * with the specified name already exists.                           */

/**/

int

add_autobin(char *nam, char *module)

{

    Builtin bn = zshcalloc(sizeof(*bn));

    bn->nam = ztrdup(nam);

    bn->optstr = ztrdup(module);

    return addbuiltin(bn);

}

/* Remove the builtin added previously by addbuiltin().  Returns *

 * zero on succes and -1 if there is no builtin with that name.  */

/**/

int

deletebuiltin(char *nam)

{

    Builtin bn;

    bn = (Builtin) builtintab->removenode(builtintab, nam);

    if (!bn)

	return -1;

    builtintab->freenode((HashNode)bn);

    return 0;

}

/* Delete multiple builtins.  binl points to a table of `size' builtin  *

 * structures.  Those for which (.flags & BINF_ADDED) is true are to be *

 * deleted; that flag is cleared.  If any fail, an error message is     *

 * printed, using nam as the leading name.  Returns 1 if all deletions  *

 * succeed, 2 if some succeed and some fail, and 0 if all (and at least *

 * 1) fail.  In normal use, from a cleanup_*() function, this return    *

 * value would be ignored -- the only cause of failure would be that a  *

 * wayward module had deleted our builtin without telling us.           */

/**/

mod_export int

deletebuiltins(char const *nam, Builtin binl, int size)

{

    int hads = 0, hadf = 0, n;

    for(n = 0; n < size; n++) {

	Builtin b = &binl[n];

	if(!(b->flags & BINF_ADDED))

	    continue;

	if(deletebuiltin(b->nam)) {

	    zwarnnam(nam, "builtin `%s' already deleted", b->nam, 0);

	    hadf = 1;

	} else

	    hads = 2;

	b->flags &= ~BINF_ADDED;

    }

    return hadf ? hads : 1;

}

/* This removes the given wrapper definition from the list. Returned is *

 * one in case of error and zero otherwise. */

/**/

mod_export int

deletewrapper(Module m, FuncWrap w)

{

    FuncWrap p, q;

    if (m->flags & MOD_ALIAS)

	return 1;

    if (w->flags & WRAPF_ADDED) {

	for (p = wrappers, q = NULL; p && p != w; q = p, p = p->next);

	if (p) {

	    if (q)

		q->next = p->next;

	    else

		wrappers = p->next;

	    p->flags &= ~WRAPF_ADDED;

	    return 0;

	}

    }

    return 1;

}

/**/

#ifdef DYNAMIC

/**/

#ifdef AIXDYNAMIC

#include <sys/ldr.h>

static char *dlerrstr[256];

static void *

load_and_bind(const char *fn)

{

    void *ret = (void *) load((char *) fn, L_NOAUTODEFER, NULL);

    if (ret) {

	LinkNode node;

	int err = loadbind(0, (void *) addbuiltin, ret);

	for (node = firstnode(modules); !err && node; incnode(node)) {

	    Module m = (Module) getdata(node);

	    if (!(m->flags & MOD_ALIAS) &&

		m->u.handle && !(m->flags & MOD_LINKED))

		err |= loadbind(0, m->u.handle, ret);

	}

	if (err) {

	    loadquery(L_GETMESSAGES, dlerrstr, sizeof(dlerrstr));

	    unload(ret);

	    ret = NULL;

	}

    } else

	loadquery(L_GETMESSAGES, dlerrstr, sizeof(dlerrstr));

    return ret;

}

#define dlopen(X,Y) load_and_bind(X)

#define dlclose(X)  unload(X)

#define dlerror()   (dlerrstr[0])

/**/

#else

#ifdef HAVE_DLFCN_H

# if defined(HAVE_DL_H) && defined(HPUXDYNAMIC)

#  include <dl.h>

# else

#  include <dlfcn.h>

# endif

#else

# ifdef HAVE_DL_H

#  include <dl.h>

#  define RTLD_LAZY BIND_DEFERRED

#  define RTLD_GLOBAL DYNAMIC_PATH

# else

#  include <sys/types.h>

#  include <nlist.h>

#  include <link.h>

# endif

#endif

/**/

#ifdef HPUXDYNAMIC

# define dlopen(file,mode) (void *)shl_load((file), (mode), (long) 0)

# define dlclose(handle) shl_unload((shl_t)(handle))

static

void *

hpux_dlsym(void *handle, char *name)

{

    void *sym_addr;

    if (!shl_findsym((shl_t *)&handle, name, TYPE_UNDEFINED, &sym_addr))

	return sym_addr;

    return NULL;

}

# define dlsym(handle,name) hpux_dlsym(handle,name)

# define dlerror() 0

#else

# ifndef HAVE_DLCLOSE

#  define dlclose(X) ((X), 0)

# endif

/**/

#endif

#ifdef DLSYM_NEEDS_UNDERSCORE

# define STR_SETUP     "_setup_"

# define STR_BOOT      "_boot_"

# define STR_CLEANUP   "_cleanup_"

# define STR_FINISH    "_finish_"

#else /* !DLSYM_NEEDS_UNDERSCORE */

# define STR_SETUP     "setup_"

# define STR_BOOT      "boot_"

# define STR_CLEANUP   "cleanup_"

# define STR_FINISH    "finish_"

#endif /* !DLSYM_NEEDS_UNDERSCORE */

/**/

#endif /* !AIXDYNAMIC */

#ifndef RTLD_LAZY

# define RTLD_LAZY 1

#endif

#ifndef RTLD_GLOBAL

# define RTLD_GLOBAL 0

#endif

/**/

static void *

try_load_module(char const *name)

{

    char buf[PATH_MAX + 1];

    char **pp;

    void *ret = NULL;

    int l;

    l = 1 + strlen(name) + 1 + strlen(DL_EXT);

    for (pp = module_path; !ret && *pp; pp++) {

	if (l + (**pp ? strlen(*pp) : 1) > PATH_MAX)

	    continue;

	sprintf(buf, "%s/%s.%s", **pp ? *pp : ".", name, DL_EXT);

	ret = dlopen(unmeta(buf), RTLD_LAZY | RTLD_GLOBAL);

    }

    return ret;

}

/**/

static void *

do_load_module(char const *name)

{

    void *ret;

    ret = try_load_module(name);

    if (!ret) {

	int waserr = errflag;

	zerr("failed to load module: %s", name, 0);

	errflag = waserr;

    }

    return ret;

}

/**/

#else /* !DYNAMIC */

/**/

static void *

do_load_module(char const *name)

{

    int waserr = errflag;

    zerr("failed to load module: %s", name, 0);

    errflag = waserr;

    return NULL;

}

/**/

#endif /* !DYNAMIC */

/*

 * Find a module in the list.

 * If aliasp is non-zero, resolve any aliases to the underlying module.

 * If namep is set, this is set to point to the last alias value resolved,

 *   even if that module was not loaded. or the module name if no aliases.

 *   Hence this is always the physical module to load in a chain of aliases.

 * Return NULL if the module named is not stored as a structure, or if we were

 * resolving aliases and the final module named is not stored as a

 * structure.

 *

 * TODO: now we have aliases, there may be some merit in using a hash

 * table instead of a linked list.

 */

/**/

static LinkNode

find_module(const char *name, int aliasp, const char **namep)

{

    Module m;

    LinkNode node;

    for (node = firstnode(modules); node; incnode(node)) {

	m = (Module) getdata(node);

	if (!strcmp(m->nam, name)) {

	    if (aliasp && (m->flags & MOD_ALIAS)) {

		if (namep)

		    *namep = m->u.alias;

		return find_module(m->u.alias, 1, namep);

	    }

	    if (namep)

		*namep = m->nam;

	    return node;

	}

    }

    return NULL;

}

/*

 * Unlink and free a module node from the linked list.