vm/words.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6 /* Compile a word definition with the non-optimizing compiler. Allocates memory */
   7 void factor_vm::jit_compile_word(cell word_, cell def_, bool relocating)
   8 {
   9         data_root<word> word(word_,this);
  10         data_root<quotation> def(def_,this);
  11
  12         code_block *compiled = jit_compile_quot(word.value(),def.value(),relocating);
  13         word->code = compiled;
  14
  15         if(to_boolean(word->pic_def)) jit_compile_quot(word->pic_def,relocating);
  16         if(to_boolean(word->pic_tail_def)) jit_compile_quot(word->pic_tail_def,relocating);
  17 }
  18
  19 cell factor_vm::find_all_words()
  20 {
  21         return instances(WORD_TYPE);
  22 }
  23
  24 void factor_vm::compile_all_words()
  25 {
  26         data_root<array> words(find_all_words(),this);
  27
  28         cell length = array_capacity(words.untagged());
  29         for(cell i = 0; i < length; i++)
  30         {
  31                 data_root<word> word(array_nth(words.untagged(),i),this);
  32
  33                 if(!word->code || !word->code->optimized_p())
  34                         jit_compile_word(word.value(),word->def,false);
  35
  36                 update_word_xt(word.untagged());
  37
  38         }
  39 }
  40
  41 word *factor_vm::allot_word(cell name_, cell vocab_, cell hashcode_)
  42 {
  43         data_root<object> vocab(vocab_,this);
  44         data_root<object> name(name_,this);
  45
  46         data_root<word> new_word(allot<word>(sizeof(word)),this);
  47
  48         new_word->hashcode = hashcode_;
  49         new_word->vocabulary = vocab.value();
  50         new_word->name = name.value();
  51         new_word->def = special_objects[OBJ_UNDEFINED];
  52         new_word->props = false_object;
  53         new_word->counter = tag_fixnum(0);
  54         new_word->pic_def = false_object;
  55         new_word->pic_tail_def = false_object;
  56         new_word->subprimitive = false_object;
  57         new_word->profiling = NULL;
  58         new_word->code = NULL;
  59
  60         jit_compile_word(new_word.value(),new_word->def,true);
  61         if(profiling_p)
  62         {
  63                 code_block *profiling_block = compile_profiling_stub(new_word.value());
  64                 new_word->profiling = profiling_block;
  65                 initialize_code_block(new_word->profiling);
  66         }
  67
  68         update_word_xt(new_word.untagged());
  69
  70         return new_word.untagged();
  71 }
  72
  73 /* (word) ( name vocabulary hashcode -- word ) */
  74 void factor_vm::primitive_word()
  75 {
  76         cell hashcode = dpop();
  77         cell vocab = dpop();
  78         cell name = dpop();
  79         dpush(tag<word>(allot_word(name,vocab,hashcode)));
  80 }
  81
  82 /* word-xt ( word -- start end ) */
  83 void factor_vm::primitive_word_xt()
  84 {
  85         data_root<word> w(dpop(),this);
  86         w.untag_check(this);
  87
  88         if(profiling_p)
  89         {
  90                 dpush(allot_cell((cell)w->profiling->xt()));
  91                 dpush(allot_cell((cell)w->profiling + w->profiling->size()));
  92         }
  93         else
  94         {
  95                 dpush(allot_cell((cell)w->code->xt()));
  96                 dpush(allot_cell((cell)w->code + w->code->size()));
  97         }
  98 }
  99
 100 void factor_vm::update_word_xt(word *w)
 101 {
 102         if(profiling_p && w->profiling)
 103                 w->xt = w->profiling->xt();
 104         else
 105                 w->xt = w->code->xt();
 106 }
 107
 108 void factor_vm::primitive_optimized_p()
 109 {
 110         word *w = untag_check<word>(dpeek());
 111         drepl(tag_boolean(w->code->optimized_p()));
 112 }
 113
 114 void factor_vm::primitive_wrapper()
 115 {
 116         wrapper *new_wrapper = allot<wrapper>(sizeof(wrapper));
 117         new_wrapper->object = dpeek();
 118         drepl(tag<wrapper>(new_wrapper));
 119 }
 120
 121 }