One Level Up Top Level

runtime/ffi/ffi_symbol.c - ktap

Functions defined

Source code

  1. /*
  2. * ffi_symbol.c - ktapvm kernel module ffi symbol submodule
  3. *
  4. * This file is part of ktap by Jovi Zhangwei.
  5. *
  6. * Copyright (C) 2012-2013 Jovi Zhangwei <jovi.zhangwei@gmail.com>.
  7. *
  8. * ktap is free software; you can redistribute it and/or modify it
  9. * under the terms and conditions of the GNU General Public License,
  10. * version 2, as published by the Free Software Foundation.
  11. *
  12. * ktap is distributed in the hope it will be useful, but WITHOUT
  13. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15. * more details.
  16. *
  17. * You should have received a copy of the GNU General Public License along with
  18. * this program; if not, write to the Free Software Foundation, Inc.,
  19. * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  20. */


  23. #include "../../include/ktap_types.h"
  24. #include "../../include/ktap_ffi.h"
  25. #include "../ktap.h"
  26. #include "../kp_vm.h"
  27. #include "../kp_obj.h"
  28. #include "../kp_str.h"
  29. #include "../kp_tab.h"

  31. ‌static inline csymbol *get_csym_arr(ktap_state_t *ks)
  32. {
  33.     return G(ks)->ffis.csym_arr;
  34. }

  36. ‌static inline int get_csym_nr(ktap_state_t *ks)
  37. {
  38.     return G(ks)->ffis.csym_nr;
  39. }

  41. ‌static inline void set_csym_arr(ktap_state_t *ks, csymbol *csym)
  42. {
  43.     G(ks)->ffis.csym_arr = csym;
  44. }

  46. ‌static inline void set_csym_nr(ktap_state_t *ks, int nr)
  47. {
  48.     G(ks)->ffis.csym_nr = nr;
  49. }


  52. ‌static inline ktap_tab_t *get_ffi_ctable(ktap_state_t *ks)
  53. {
  54.     return G(ks)->ffis.ctable;
  55. }

  57. ‌static int setup_ffi_ctable(ktap_state_t *ks)
  58. {
  59.     ktap_val_t ffi_name, ffi_lib_name, ffi_mt;
  60.     const ktap_val_t *gt, *ffit;
  61.     ktap_tab_t *registry;

  63.     gt = kp_tab_getint(hvalue(&G(ks)->registry), KTAP_RIDX_GLOBALS);

  65.     G(ks)->ffis.ctable = kp_tab_new(ks, 0, 512);
  66.     if (!G(ks)->ffis.ctable)
  67.         return -1;

  69.     /* get global["ffi"] */
  70.     set_string(&ffi_name, kp_str_new(ks, "ffi"));
  71.     registry = hvalue(gt);
  72.     ffit = kp_tab_get(ks, registry, &ffi_name);
  73.     /* insert ffi C table to ffi table */
  74.     set_table(&ffi_mt, get_ffi_ctable(ks));
  75.     set_string(&ffi_lib_name, kp_str_new(ks, "C"));
  76.     registry = hvalue(ffit);
  77.     kp_tab_setvalue(ks, registry, &ffi_lib_name, &ffi_mt);

  79.     return 0;
  80. }

  82. ‌inline csymbol *ffi_get_csym_by_id(ktap_state_t *ks, int id)
  83. {
  84.     return &(get_csym_arr(ks)[id]);
  85. }

  87. ‌csymbol_id ffi_get_csym_id(ktap_state_t *ks, char *name)
  88. {
  89.     int i;

  91.     for (i = 0; i < get_csym_nr(ks); i++) {
  92.         if (!strcmp(name, csym_name(ffi_get_csym_by_id(ks, i)))) {
  93.             return i;
  94.         }
  95.     }

  97.     kp_error(ks, "Cannot find csymbol with name %s\n", name);
  98.     return 0;
  99. }

  101. ‌static void add_ffi_func_to_ctable(ktap_state_t *ks, csymbol_id id)
  102. {
  103.     ktap_val_t func_name, fv;
  104.     ktap_cdata_t *cd;
  105.     csymbol *cs;

  107.     /* push cdata to ctable */
  108.     set_cdata(&fv, kp_obj_newobject(ks, KTAP_TYPE_CDATA, sizeof(ktap_cdata_t),
  109.                     NULL));
  110.     cd = cdvalue(&fv);
  111.     cd_set_csym_id(cd, id);

  113.     cs = id_to_csym(ks, id);
  114.     set_string(&func_name, kp_str_new(ks, csym_name(cs)));
  115.     kp_tab_setvalue(ks, get_ffi_ctable(ks), &func_name, &fv);
  116. }

  118. ‌static int setup_ffi_symbol_table(ktap_state_t *ks)
  119. {
  120.     int i;
  121.     csymbol *cs;

  123.     if (setup_ffi_ctable(ks))
  124.         return -1;

  126.     /* push all functions to ctable */
  127.     for (i = 0; i < get_csym_nr(ks); i++) {
  128.         cs = &get_csym_arr(ks)[i];
  129.         switch (cs->type) {
  130.         case FFI_FUNC:
  131.             kp_verbose_printf(ks, "[%d] loading C function %s\n",
  132.                     i, csym_name(cs));
  133.             add_ffi_func_to_ctable(ks, i);
  134.             kp_verbose_printf(ks, "%s loaded\n", csym_name(cs));
  135.             break;
  136.         case FFI_STRUCT:
  137.         case FFI_UNION:
  138.             break;
  139.         default:
  140.             break;
  141.         }
  142.     }

  144.     return 0;
  145. }

  147. ‌void ffi_free_symbols(ktap_state_t *ks)
  148. {
  149.     int i;
  150.     csymbol_id *arg_ids;
  151.     csymbol *cs;

  153.     if (!get_csym_arr(ks))
  154.         return;

  156.     for (i = 0; i < get_csym_nr(ks); i++) {
  157.         cs = &get_csym_arr(ks)[i];
  158.         switch (csym_type(cs)) {
  159.         case FFI_FUNC:
  160.             arg_ids = csym_func_arg_ids(cs);
  161.             if (arg_ids)
  162.                 kp_free(ks, arg_ids);
  163.             break;
  164.         case FFI_STRUCT:
  165.         case FFI_UNION:
  166.             /*@TODO finish this  20.11 2013 (houqp)*/
  167.             break;
  168.         default:
  169.             break;
  170.         }
  171.     }

  173.     kp_free(ks, get_csym_arr(ks));
  174. }

  176. ‌int ffi_set_csym_arr(ktap_state_t *ks, int cs_nr, csymbol *new_arr)
  177. {
  178.     set_csym_nr(ks, cs_nr);
  179.     set_csym_arr(ks, new_arr);
  180.     return setup_ffi_symbol_table(ks);
  181. }

One Level Up Top Level