// This file is part of SmallBASIC
//
// SmallBASIC - External library support (modules)
//
// This program is distributed under the terms of the GPL v2.0 or later
// Download the GNU Public License (GPL) from www.gnu.org
//
// Copyright(C) 2001 Nicholas Christopoulos

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#if defined(__CYGWIN__)
#include <w32api/windows.h>
#include <sys/cygwin.h>
#define WIN_EXTLIB
#elif defined(__MINGW32__)
#include <windows.h>
#define WIN_EXTLIB
#endif

#include "common/smbas.h"
#include "common/extlib.h"
#include "common/pproc.h"

#if defined(__linux__) && defined(_UnixOS)
#define LNX_EXTLIB
#endif

#ifdef LNX_EXTLIB
#define LIB_EXT ".so"
#else
#define LIB_EXT ".dll"
#endif

#if defined(LNX_EXTLIB)
#include <dlfcn.h>
#endif

#include <dirent.h>

#if defined(OS_LIMITED)
#define MAX_SLIB_N  16
#else
#define MAX_SLIB_N  256
#endif

#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
/* --- Global Symbol Table ----------------------------------------------------------------------------------------------- */

static slib_t slib_table[MAX_SLIB_N]; /**< module index */
static int slib_count; /**< module count */

static ext_proc_node_t *extproctable; /**< external procedure table       */
static int extprocsize; /**< ext-proc table allocated size  */
static int extproccount; /**< ext-proc table count           */

static ext_func_node_t *extfunctable; /**< external function table        */
static int extfuncsize; /**< ext-func table allocated size  */
static int extfunccount; /**< ext-func table count           */

/*
 * reset the external proc/func lists
 */
static void slib_reset_externals(void) {
  // reset functions
  if (extfunctable) {
    tmp_free(extfunctable);
  }
  extfunctable = NULL;
  extfunccount = extfuncsize = 0;

  // reset procedures
  if (extproctable) {
    tmp_free(extproctable);
  }
  extproctable = NULL;
  extproccount = extprocsize = 0;
}

/*
 * add an external procedure to the list
 */
static int slib_add_external_proc(const char *proc_name, int lib_id) {
  // TODO: scan for conflicts
  char buf[256];

  sprintf(buf, "%s.%s", slib_table[lib_id].name, proc_name);
  strupper(buf);

  if (extproctable == NULL) {
    extprocsize = 16;
    extproctable =
    (ext_proc_node_t *) tmp_alloc(sizeof(ext_proc_node_t) * extprocsize);
  }
  else if (extprocsize <= (extproccount + 1)) {
    extprocsize += 16;
    extproctable =
    (ext_proc_node_t *) tmp_realloc(extproctable,
        sizeof(ext_proc_node_t) * extprocsize);
  }

  extproctable[extproccount].lib_id = lib_id;
  extproctable[extproccount].symbol_index = 0;
  strcpy(extproctable[extproccount].name, buf);
  strupper(extproctable[extproccount].name);

  if (opt_verbose)
    printf("LID: %d, Idx: %d, PROC '%s'\n", lib_id, extproccount,
           extproctable[extproccount].name);
  
  extproccount++;
  return extproccount - 1;
}

/*
 * Add an external function to the list
 */
static int slib_add_external_func(const char *func_name, int lib_id) {
  char buf[256];

  sprintf(buf, "%s.%s", slib_table[lib_id].name, func_name);
  strupper(buf);

  // TODO: scan for conflicts
  if (extfunctable == NULL) {
    extfuncsize = 16;
    extfunctable =
    (ext_func_node_t *) tmp_alloc(sizeof(ext_func_node_t) * extfuncsize);
  }
  else if (extfuncsize <= (extfunccount + 1)) {
    extfuncsize += 16;
    extfunctable =
    (ext_func_node_t *) tmp_realloc(extfunctable,
        sizeof(ext_func_node_t) * extfuncsize);
  }

  extfunctable[extfunccount].lib_id = lib_id;
  extfunctable[extfunccount].symbol_index = 0;
  strcpy(extfunctable[extfunccount].name, buf);
  strupper(extfunctable[extfunccount].name);

  if (opt_verbose)
  printf("LID: %d, Idx: %d, FUNC '%s'\n", lib_id, extfunccount,
      extfunctable[extfunccount].name);

  extfunccount++;
  return extfunccount - 1;
}

/*
 * returns the external procedure id
 */
static int slib_is_external_proc(const char *name) {
  int i;

  for (i = 0; i < extproccount; i++) {
    if (strcmp(extproctable[i].name, name) == 0)
    return i;
  }
  return -1;
}

/*
 * returns the external function id
 */
static int slib_is_external_func(const char *name) {
  int i;

  for (i = 0; i < extfunccount; i++) {
    if (strcmp(extfunctable[i].name, name) == 0)
    return i;
  }
  return -1;
}

#endif

/**
 * returns the ID of the keyword
 */
int slib_get_kid(const char *name) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  int i;

  for (i = 0; i < extproccount; i++) {
    if (strcmp(extproctable[i].name, name) == 0)
    return i;
  }
  for (i = 0; i < extfunccount; i++) {
    if (strcmp(extfunctable[i].name, name) == 0)
    return i;
  }
#endif
  return -1;
}

/**
 * returns the library-id (index of library of the current process)
 */
int slib_get_module_id(const char *name) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  int i;
  char xname[OS_FILENAME_SIZE + 1];
  slib_t *lib;

  strcpy(xname, name);
  strcat(xname, LIB_EXT);
  for (i = 0; i < slib_count; i++) {
    lib = &slib_table[i];
    // printf("slib: %s=%s\n", lib->name, name);
    if (strcasecmp(lib->name, name) == 0)
    return i;
  }
#endif
  return -1;                    // not found
}

/**
 * updates compiler with the module's keywords
 */
void slib_setup_comp(int mid) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  int i;

  for (i = 0; i < extproccount; i++) {
    if (extproctable[i].lib_id == mid)
    comp_add_external_proc(extproctable[i].name, mid);
  }
  for (i = 0; i < extfunccount; i++) {
    if (extfunctable[i].lib_id == mid)
    comp_add_external_func(extfunctable[i].name, mid);
  }
#endif
}

/* --- System Load/Execute ----------------------------------------------------------------------------------------------- */

/*
 * retrieve the function pointer
 */
void *slib_getoptptr(slib_t * lib, const char *name) {
#if defined(LNX_EXTLIB)
  return dlsym(lib->handle, name);
#elif defined(WIN_EXTLIB)
  return GetProcAddress((HMODULE) lib->handle, name);
#else
  return NULL;
#endif
}

/*
 * retrieve the function pointer; error if its not exists
 */
void *slib_getptr(slib_t * lib, const char *name) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  void *ptr;

  ptr = slib_getoptptr(lib->handle, name);
  if (!ptr)
  panic("SB-LibMgr: %s, missing function %s\n", lib->name, name);
  return ptr;
#else
  return NULL;
#endif
}

/*
 * open library (basic open)
 */
int slib_llopen(slib_t * lib) {
#if defined(LNX_EXTLIB)
  lib->handle = dlopen(lib->fullname, RTLD_NOW);
  if (lib->handle == NULL)
  panic("SB-LibMgr: error on loading %s\n%s", lib->name, dlerror());
  return (lib->handle != NULL);
#elif defined(__CYGWIN__)
  char win32Path[1024];
  cygwin_conv_to_full_win32_path(lib->fullname, win32Path);
  lib->handle = LoadLibrary(win32Path);
  if (lib->handle == NULL)
  panic("SB-LibMgr: error on loading %s\n", win32Path);
  return (lib->handle != NULL);
#elif defined(WIN_EXTLIB)
  lib->handle = LoadLibrary(lib->fullname);
  if (lib->handle == NULL)
  panic("SB-LibMgr: error on loading %s\n", lib->name);
  return (lib->handle != NULL);
#else
  return 0;
#endif
}

/*
 * close library (basic close)
 */
int slib_llclose(slib_t * lib) {
#if defined(LNX_EXTLIB)
  if (!lib->handle)
  return 0;

  dlclose(lib->handle);
  lib->handle = NULL;
  return 1;
#elif defined(WIN_EXTLIB)
  if (!lib->handle)
  return 0;

  FreeLibrary(lib->handle);
  lib->handle = NULL;
  return 1;
#else
  return 1;
#endif
}

/*
 */
void slib_import_routines(slib_t * lib) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  int i, count;
  char buf[SB_KEYWORD_SIZE];
  int (*fgetname) (int, char *);
  int (*fcount) (void);

  lib->first_proc = extproccount;
  lib->first_func = extfunccount;

  fcount = (int (*)(void))slib_getoptptr(lib, "sblib_proc_count");
  fgetname = (int (*)(int, char *))slib_getoptptr(lib, "sblib_proc_getname");
  if (fcount) {
    count = fcount();
    for (i = 0; i < count; i++) {
      if (fgetname(i, buf))
      slib_add_external_proc(buf, lib->id);
    }
  }

  fcount = (int (*)(void))slib_getoptptr(lib, "sblib_func_count");
  fgetname = (int (*)(int, char *))slib_getoptptr(lib, "sblib_func_getname");
  if (fcount) {
    count = fcount();
    for (i = 0; i < count; i++) {
      if (fgetname(i, buf))
      slib_add_external_func(buf, lib->id);
    }
  }
#endif
}

/*
 * load a lib
 */
void slib_import(const char *name, const char *fullname) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  slib_t *lib;
  int (*minit) (void);
  int (*mtype) (void);
  void (*mdrvname) (char *);
  int mok = 0;
  int name_index = 0;

  if (strncmp(name, "lib", 3) == 0) {
    // libmysql -> store mysql
    name_index = 3;
  }

  lib = &slib_table[slib_count];
  memset(lib, 0, sizeof(slib_t));
  strncpy(lib->name, name + name_index, 255);
  strncpy(lib->fullname, fullname, 1023);
  lib->id = slib_count;

  if (!opt_quiet)
  printf("SB-LibMgr: importing %s", fullname);

  if (slib_llopen(lib)) {
    mok = 1;

    // init
    minit = (int (*)(void))slib_getoptptr(lib, "sblib_init");
    if (minit) {
      if (!minit()) {
        mok = 0;
        panic("SB-LibMgr: %s->sblib_init(), failed", lib->name);
      }
    }

    // get type
    mtype = (int (*)(void))slib_getoptptr(lib, "sblib_type");
    if (mtype) {
      lib->type = mtype();
    } else {
      lib->type = lib_lang_ext; // default type
    }
    // get info
    switch (lib->type) {
      case lib_lang_ext:
      slib_import_routines(lib);
      mok = 1;
      break;
      case lib_vfs_driver:
      mdrvname = (void (*)(char *))slib_getptr(lib, "sblib_vfsname");
      memset(lib->vfs_drvname, 0, 5);
      mdrvname(lib->vfs_drvname);
      mok = 1;
      break;
      default:
      panic("SB-LibMgr: %s->sbmod_type(), type %d is not supported", lib->type);
      mok = 0;
    };
  }
  else {
    printf("SB-LibMgr: can't open %s", fullname);
  }
  if (mok) {
    slib_count++;
    if (!opt_quiet) {
      printf("... done\n");
    }
  }
  else {
    if (!opt_quiet) {
      printf("... error\n");
    }
  }
#endif
}

/*
 * scan libraries
 */
void sblmgr_scanlibs(const char *path) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  DIR *dp;
  struct dirent *e;
  char *name, *p;
  char full[1024], libname[256];

  if ((dp = opendir(path)) == NULL) {
    if (!opt_quiet) {
      printf("SB-LibMgr: module path %s not found.\n", path);
    }
    return;
  }

  while ((e = readdir(dp)) != NULL) {
    name = e->d_name;
    if ((strcmp(name, ".") == 0) || (strcmp(name, "..") == 0)) {
      continue;
    }
    if ((p = strstr(name, LIB_EXT)) != NULL) {
      if (strcmp(p, LIB_EXT) == 0) {
        // store it

        strcpy(libname, name);
        p = strchr(libname, '.');
        *p = '\0';

        strcpy(full, path);
        if (path[strlen(path) - 1] != '/') {
          strcat(full, "/");    // add trailing separator
        }
        strcat(full, name);

        slib_import(libname, full);
      }
    }
  }

  closedir(dp);
#endif
}

/*
 * slib-manager: initialize manager
 */
void sblmgr_init(int mcount, const char *mlist) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  int all = 0;

  slib_count = 0;

  if (!opt_quiet && mcount) {
    printf("SB-LibMgr: scanning for modules...\n");
  }
  if (mcount) {
    if (mlist) {
      if (strlen(mlist) == 0) {
        all = 1;
      } else {
        all = 1;
      }
      // TODO: else load the specified modules
    }
    else {
      all = 1;
    }
    if (all) {
      // the -m argument specifies the location of all modules
#if defined(LNX_EXTLIB) && !defined(PACKAGE_LIB_DIR)
      sblmgr_scanlibs(opt_modlist);
#elif defined(LNX_EXTLIB)
      sblmgr_scanlibs(opt_modlist[0] ? opt_modlist : PACKAGE_LIB_DIR);
#elif defined(__CYGWIN__) || defined(__MINGW32__)
      sblmgr_scanlibs(opt_modlist);
#elif defined(WIN_EXTLIB)
      sblmgr_scanlibs("c:\\sbasic\\modules");
      sblmgr_scanlibs("sbasic\\modules");
#endif
    }
  }
  if (!opt_quiet) {
    printf("\n");
  }
#endif
}

/*
 * slib-manager: close everything
 */
void sblmgr_close() {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  int i;
  slib_t *lib;
  void (*mclose) (void);

  for (i = 0; i < slib_count; i++) {
    lib = &slib_table[i];
    if (lib->handle) {
      mclose = (void (*)(void))slib_getoptptr(lib, "sblib_close");
      if (mclose)
      mclose();
      slib_llclose(lib);
    }
  }
#endif
}

/**
 *   @ingroup mod
 *
 *   search modules for a vfsmodule with that driver-name.
 *
 *   @param name the name of the driver (char[5])
 *   @return lib-id on success; otherwise -1
 */
int sblmgr_getvfs(const char *name) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  int i;
  slib_t *lib;

  for (i = 0; i < slib_count; i++) {
    lib = &slib_table[i];
    if (lib->type == lib_vfs_driver) {
      if (strncmp(lib->vfs_drvname, name, 5) == 0)
      return i;
    }
  }
#endif
  return -1;
}

/*
 * returns the 'index' function-name of the 'lib'
 */
int sblmgr_getfuncname(int lib_id, int index, char *buf) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  slib_t *lib;
  int (*mgf) (int, char *);

  buf[0] = '\0';
  if (lib_id < 0 || lib_id >= slib_count)
  return 0;                   // error

  lib = &slib_table[lib_id];
  mgf = (int (*)(int, char *))slib_getoptptr(lib, "sblib_func_getname");
  if (mgf == NULL)
  return 0;// error

  return mgf(index, buf);
#else
  return 0;
#endif
}

/*
 * returns the 'index' procedure-name of the 'lib'
 */
int sblmgr_getprocname(int lib_id, int index, char *buf) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  slib_t *lib;
  int (*mgp) (int, char *);

  buf[0] = '\0';
  if (lib_id < 0 || lib_id >= slib_count)
  return 0;                   // error

  lib = &slib_table[lib_id];
  mgp = (int (*)(int, char *))slib_getoptptr(lib, "sblib_proc_getname");
  if (mgp == NULL)
  return 0;// error

  return mgp(index, buf);
#else
  return 0;
#endif
}

/*
 * build parameter table
 */
int slib_build_ptable(slib_par_t * ptable) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  int pcount = 0;
  var_t *arg = NULL;
  byte ready, code;
  addr_t ofs;

  if (code_peek() == kwTYPE_LEVEL_BEGIN) {
    code_skipnext();            // kwTYPE_LEVEL_BEGIN

    ready = 0;
    do {
      code = code_peek();
      switch (code) {
        case kwTYPE_EOC:
        code_skipnext();
        break;
        case kwTYPE_SEP:         // separator 
        code_skipsep();
        break;
        case kwTYPE_LEVEL_END:// ) -- end of parameters
        ready = 1;
        break;
        case kwTYPE_VAR:// variable
        ofs = prog_ip;// store IP

        if (code_isvar()) {
          // push parameter
          ptable[pcount].var_p = code_getvarptr();
          ptable[pcount].byref = 1;
          pcount++;
          break;
        }

        prog_ip = ofs;          // restore IP
        // no 'break' here
        default:
        // default --- expression (BYVAL ONLY)
        arg = v_new();
        eval(arg);
        if (!prog_error) {
          // push parameter
          ptable[pcount].var_p = arg;
          ptable[pcount].byref = 0;
          pcount++;
        }
        else {
          v_free(arg);
          tmp_free(arg);
          return pcount;
        }

      }

    }while (!ready);

    code_skipnext();            // kwTYPE_LEVEL_END
  }

  return pcount;
#else
  return 0;
#endif
}

/*
 * free parameter table
 */
void slib_free_ptable(slib_par_t * ptable, int pcount) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  int i;

  for (i = 0; i < pcount; i++) {
    if (ptable[i].byref == 0) {
      v_free(ptable[i].var_p);
      tmp_free(ptable[i].var_p);
    }
  }
#endif
}

/*
 *  execute a procedure
 */
int sblmgr_procexec(int lib_id, int index) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  slib_t *lib;
  var_t ret;
  slib_par_t *ptable = NULL;
  int (*pexec) (int, int, slib_par_t *, var_t *);
  int pcount = 0;
  int success = 0;

  if (lib_id < 0 || lib_id >= slib_count) {
    // rt_raise(...)
    return 0;// error
  }

  lib = &slib_table[lib_id];
  if (lib->type == lib_vfs_driver)
  pexec = slib_getoptptr(lib, "sblib_vfs_exec");
  else
  pexec = slib_getoptptr(lib, "sblib_proc_exec");
  if (pexec == NULL) {
    // rt_raise(...)
    return 0;// error
  }

  // build parameter table
  ptable = tmp_alloc(sizeof(slib_par_t) * 64);// 64 = maximum parameter
  pcount = slib_build_ptable(ptable);
  if (prog_error) {
    slib_free_ptable(ptable, pcount);
    return 0;
  }

  // exec
  v_init(&ret);
  success = pexec(index - lib->first_proc, pcount, ptable, &ret);

  // error
  if (!success) {
    if (ret.type == V_STR)
    rt_raise("SB-LibMgr:\n%s: %s\n", lib->name, ret.v.p.ptr);
    else
    rt_raise("SB-LibMgr:\n%s: not specified error\n", lib->name);
  }

  // clean-up
  if (ptable) {
    slib_free_ptable(ptable, pcount);
    tmp_free(ptable);
  }

  v_free(&ret);

  return success;
#else
  return 0;
#endif
}

/*
 * execute a function
 */
int sblmgr_funcexec(int lib_id, int index, var_t * ret) {
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
  slib_t *lib;
  slib_par_t *ptable = NULL;
  int (*pexec) (int, int, slib_par_t *, var_t *);
  int pcount = 0;
  int success = 0;

  if (lib_id < 0 || lib_id >= slib_count) {
    // rt_raise(...)
    return 0;// error
  }

  lib = &slib_table[lib_id];
  if (lib->type == lib_vfs_driver)
  pexec = slib_getoptptr(lib, "sblib_vfs_exec");
  else
  pexec = slib_getoptptr(lib, "sblib_func_exec");
  if (pexec == NULL) {
    // rt_raise(...)
    return 0;// error
  }

  // build parameter table
  ptable = tmp_alloc(sizeof(slib_par_t) * 64);// 64 = maximum parameter
  pcount = slib_build_ptable(ptable);
  if (prog_error) {
    slib_free_ptable(ptable, pcount);
    return 0;
  }

  // exec
  v_init(ret);
  success = pexec(index - lib->first_func, pcount, ptable, ret);

  // error
  if (!success) {
    if (ret->type == V_STR)
    rt_raise("SB-LibMgr:\n%s: %s\n", lib->name, ret->v.p.ptr);
    else
    rt_raise("SB-LibMgr:\n%s: (error not specified)\n", lib->name);
  }

  // clean-up
  if (ptable) {
    slib_free_ptable(ptable, pcount);
    tmp_free(ptable);
  }

  return success;
#else
  return 0;
#endif
}

/**
 *   @ingroup mod
 *
 *   executes a vfs standard function
 *
 *   @param func the function's index
 *   @param f the file structure
 *   @return it is depended on 'func'
 */
long sblmgr_vfsexec(enum slib_vfs_idx_t func, dev_file_t * f, ...)
{
  va_list ap;
  long retval = 0;

  va_start(ap, f);
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
    {
      slib_t *lib;

      lib = &slib_table[f->vfslib];

      switch (func) {
        case lib_vfs_open:
        {
          int (*func) (const char *name, int flags);
          func = slib_getoptptr(lib->handle, "vfs_open");
          if (func) {
            f->last_error = f->handle = func(f->name + 5, f->open_flags);
            retval = (f->handle >= 0);
          }
        }
        break;
        case lib_vfs_close:
        {
          int (*func) (int handle);
          func = slib_getoptptr(lib->handle, "vfs_close");
          if (func) {
            retval = func(f->handle);
            f->handle = -1;
          }
        }
        break;
        case lib_vfs_read:
        {
          long (*func) (int handle, char *data, long size);
          byte *data;
          dword size;

          data = va_arg(ap, byte *);
          size = va_arg(ap, dword);
          func = slib_getoptptr(lib->handle, "vfs_read");
          if (func)
          retval = (func(f->handle, data, size) == size);
        }
        break;
        case lib_vfs_write:
        {
          long (*func) (int handle, char *data, long size);
          byte *data;
          dword size;

          data = va_arg(ap, byte *);
          size = va_arg(ap, dword);
          func = slib_getoptptr(lib->handle, "vfs_write");
          if (func)
          retval = (func(f->handle, data, size) == size);
        }
        break;
        case lib_vfs_eof:
        {
          int (*func) (int handle);
          func = slib_getoptptr(lib->handle, "vfs_eof");
          if (func)
          retval = func(f->handle);
        }
        case lib_vfs_tell:
        {
          long (*func) (int handle);
          func = slib_getoptptr(lib->handle, "vfs_tell");
          if (func)
          retval = func(f->handle);
        }
        case lib_vfs_length:
        {
          long (*func) (int handle);
          func = slib_getoptptr(lib->handle, "vfs_length");
          if (func)
          retval = func(f->handle);
        }
        case lib_vfs_seek:
        {
          long (*func) (int handle, long offset);
          dword offset;

          offset = va_arg(ap, dword);
          func = slib_getoptptr(lib->handle, "vfs_seek");
          if (func)
          retval = func(f->handle, offset);
        }
        default:
        // error
    ;
  }
}
#endif
    va_end(ap);
    return retval;
  }

/**
 *   @ingroup mod
 *
 *   executes a vfs directory-function
 *
 *   @param func the function's index
 *   @param lib the lib's id
 *   @return it is depended on 'func'
 */
long sblmgr_vfsdirexec(enum slib_vfs_idx_t func, int ilib, ...)
{
  va_list ap;
  int retval = 0;

  va_start(ap, ilib);
#if defined(LNX_EXTLIB) || defined(WIN_EXTLIB)
    {
      slib_t *lib;

      lib = &slib_table[ilib];

      switch (func) {
        case lib_vfs_chmod:
        {
          long (*func) (const char *name, int mode);
          char *name;
          int mode;

          name = va_arg(ap, char *);
          mode = va_arg(ap, int);
          func = slib_getoptptr(lib->handle, "vfs_chmod");
          if (func)
          retval = (func(name, mode) == 0);
        }
        break;
        case lib_vfs_access:
        {
          long (*func) (const char *name, int mode);
          char *name;
          int mode;

          name = va_arg(ap, char *);
          mode = va_arg(ap, int);
          func = slib_getoptptr(lib->handle, "vfs_access");
          if (func)
          retval = func(name, mode);
        }
        break;
        case lib_vfs_attr:
        case lib_vfs_exist:
        case lib_vfs_remove:
        case lib_vfs_list:
        case lib_vfs_chdir:
        case lib_vfs_mkdir:
        case lib_vfs_rmdir:
        default:
        ;
      }
    }
#endif
    va_end(ap);
    return retval;
  }