implement common classes

src/avr_access.cpp

@@ -15,6 +15,7 @@
 #include "c_object.h"
 #include "c_fixnum.h"
 #include "c_string.h"
+#include "c_common.h"
 #include "ext_arduino.h"
 
 //dynaic code generation

src/c_common.cpp

@@ -0,0 +1,79 @@
+#include "vm_config.h"
+#include <string.h>
+
+#include "value.h"
+#include "micro_vm.h"
+#include "class.h"
+#include "alloc.h"
+#include "c_string.h"
+#include "global.h"
+#include "symbol.h"
+#include "console.h"
+#include "debug.h"
+#include "avr_access.h"
+
+/* Proc class */
+void c_proc_call(mrb_mvm *vm, mrb_value v[], int argc)
+{
+  // push callinfo, but not release regs
+  mrbc_push_callinfo(vm, argc);
+
+  // target irep
+  vm->pc = 0;
+  vm->pc_irep = v[0].proc->irep;
+
+  vm->current_regs = v;
+}
+
+void c_proc_to_s(mrb_mvm *vm, mrb_value v[], int argc)
+{
+  // (NOTE) address part assumes 32bit. but enough for this.
+  char buf[32];
+  mrb_printf pf;
+
+  mrbc_printf_init( &pf, buf, sizeof(buf), "<#Proc:%08x>" );
+  while( mrbc_printf_main( &pf ) > 0 ) {
+    mrbc_printf_int( &pf, (uintptr_t)v->proc, 16 );
+  }
+  mrbc_printf_end( &pf );
+
+  SET_RETURN( mrbc_string_new_cstr( buf ) );
+}
+
+/* Nil class */
+void c_nil_to_s(mrb_mvm *vm, mrb_value v[], int argc)
+{
+  v[0] = mrbc_string_new( NULL, 0);
+}
+
+/* False class */
+void c_false_to_s(mrb_mvm *vm, mrb_value v[], int argc)
+{
+  v[0] = mrbc_string_new_cstr( "false");
+}
+
+/* True class */
+void c_true_to_s(mrb_mvm *vm, mrb_value v[], int argc)
+{
+  v[0] = mrbc_string_new_cstr( "true");
+}
+
+
+void mrbc_init_class_proc(void){
+  mrbc_class_proc = mrbc_define_class("Proc", 0);
+}
+
+void mrbc_init_class_nil(void){
+  mrbc_class_nil = mrbc_define_class("Nil", 0);
+}
+
+void mrbc_init_class_false(void){
+  mrbc_class_false = mrbc_define_class("False", 0);
+}
+
+void mrbc_init_class_true(void){
+  mrbc_class_true = mrbc_define_class("True", 0);
+  //methods
+  // - to_s
+}
+

src/c_common.h

@@ -0,0 +1,18 @@
+#ifndef MRBC_SRC_C_COMMON_H_
+#define MRBC_SRC_C_COMMON_H_
+
+struct VM;
+
+void mrbc_init_class_proc(void);
+void mrbc_init_class_nil(void);
+void mrbc_init_class_false(void);
+void mrbc_init_class_true(void);
+
+void c_proc_call(mrb_mvm *vm, mrb_value v[], int argc);
+void c_proc_to_s(mrb_mvm *vm, mrb_value v[], int argc);
+void c_nil_to_s(mrb_mvm *vm, mrb_value v[], int argc);
+void c_false_to_s(mrb_mvm *vm, mrb_value v[], int argc);
+void c_true_to_s(mrb_mvm *vm, mrb_value v[], int argc);
+
+#endif
+

src/class.cpp

@@ -5,6 +5,7 @@
 #include "micro_vm.h"
 #include "class.h"
 #include "alloc.h"
+#include "c_common.h"
 #include "c_object.h"
 #include "c_string.h"
 #include "c_fixnum.h"
@@ -126,20 +127,22 @@ void mrbc_define_method(mrb_class *cls, const char *name, mrb_func_t cfunc)
 
 void mrbc_init_class(void)
 {
+  //basic
   mrbc_init_class_object();
   mrbc_init_class_string();
   mrbc_init_class_fixnum();
+  mrbc_init_class_nil();
+  mrbc_init_class_proc();
+  mrbc_init_class_false();
+  mrbc_init_class_true();
+
+  mrbc_init_class_symbol();
+
+  //extension
   mrbc_init_class_arduino();
 
-  //TODO
 #if 0
-  mrbc_init_class_nil(0);
-  mrbc_init_class_proc(0);
-  mrbc_init_class_false(0);
-  mrbc_init_class_true(0);
-
-  mrbc_init_class_fixnum(0);
-  mrbc_init_class_symbol(0);
+  //TODO
   mrbc_init_class_array(0);
   mrbc_init_class_range(0);
   //mrbc_init_class_hash(0);

src/code.h

@@ -15,7 +15,7 @@ const unsigned char* const mmruby_code_irep_table[] PROGMEM = {
 };
 
 /* Proc table */
-const unsigned char mmruby_code_proc_table_size PROGMEM = 30;
+const unsigned char mmruby_code_proc_table_size PROGMEM = 37;
 
 
 const uint8_t mmruby_code_proc_table_Object[] PROGMEM = {
@@ -31,18 +31,23 @@ const uint8_t mmruby_code_proc_table_Object[] PROGMEM = {
 };
 
 const uint8_t mmruby_code_proc_table_Proc[] PROGMEM = {
+  36,24,
+  32,25,
   0
 };
 
 const uint8_t mmruby_code_proc_table_False[] PROGMEM = {
+  32,27,
   0
 };
 
 const uint8_t mmruby_code_proc_table_True[] PROGMEM = {
+  32,28,
   0
 };
 
 const uint8_t mmruby_code_proc_table_Nil[] PROGMEM = {
+  32,26,
   0
 };
 
@@ -52,31 +57,33 @@ const uint8_t mmruby_code_proc_table_Array[] PROGMEM = {
 
 const uint8_t mmruby_code_proc_table_Fixnum[] PROGMEM = {
   16,9,
-  36,10,
-  37,11,
-  38,12,
-  39,13,
-  40,14,
-  41,15,
-  42,16,
+  37,10,
+  38,11,
+  39,12,
+  40,13,
+  41,14,
+  42,15,
+  43,16,
   15,17,
   20,18,
-  43,19,
-  44,20,
-  45,21,
-  46,22,
+  44,19,
+  45,20,
+  46,21,
+  47,22,
   32,23,
   0
 };
 
 const uint8_t mmruby_code_proc_table_String[] PROGMEM = {
-  13,24,
-  14,25,
-  47,26,
+  48,30,
+  32,31,
+  49,32,
+  50,33,
   0
 };
 
 const uint8_t mmruby_code_proc_table_Symbol[] PROGMEM = {
+  32,29,
   0
 };
 
@@ -85,10 +92,10 @@ const uint8_t mmruby_code_proc_table_Range[] PROGMEM = {
 };
 
 const uint8_t mmruby_code_proc_table_Arduino[] PROGMEM = {
-  28,27,
-  22,28,
-  27,29,
-  48,30,
+  28,34,
+  22,35,
+  27,36,
+  51,37,
   0
 };
 
@@ -118,21 +125,28 @@ inline mrb_func_t find_c_funcs_by_no(short no){
     case 21: func = c_fixnum_chr; break;
     case 22: func = c_ineffect; break;
     case 23: func = c_fixnum_to_s; break;
-    case 24: func = c_string_add; break;
-    case 25: func = c_string_eql; break;
-    case 26: func = c_string_size; break;
-    case 27: func = class_arduino_delay; break;
-    case 28: func = class_arduino_pin_mode; break;
-    case 29: func = class_arduino_digital_write; break;
-    case 30: func = class_arduino_digital_read; break;
+    case 24: func = c_proc_call; break;
+    case 25: func = c_proc_to_s; break;
+    case 26: func = c_nil_to_s; break;
+    case 27: func = c_false_to_s; break;
+    case 28: func = c_true_to_s; break;
+    case 29: func = c_true_to_s; break;
+    case 30: func = c_all_symbols; break;
+    case 31: func = c_to_s; break;
+    case 32: func = c_to_s; break;
+    case 33: func = c_ineffect; break;
+    case 34: func = class_arduino_delay; break;
+    case 35: func = class_arduino_pin_mode; break;
+    case 36: func = class_arduino_digital_write; break;
+    case 37: func = class_arduino_digital_read; break;
     default: break;
   }
   return func;
 }
 
 
 /* Symbol table */
-const unsigned char mmruby_code_symbol_table_size PROGMEM = 49;
+const unsigned char mmruby_code_symbol_table_size PROGMEM = 52;
 const char mmruby_code_symbol_ref00[] PROGMEM ="";
 const char mmruby_code_symbol_ref01[] PROGMEM ="Object";
 const char mmruby_code_symbol_ref02[] PROGMEM ="String";
@@ -169,19 +183,22 @@ const char mmruby_code_symbol_ref20[] PROGMEM ="to_s";
 const char mmruby_code_symbol_ref21[] PROGMEM ="class";
 const char mmruby_code_symbol_ref22[] PROGMEM ="attr_reader";
 const char mmruby_code_symbol_ref23[] PROGMEM ="attr_accessor";
-const char mmruby_code_symbol_ref24[] PROGMEM ="-@";
-const char mmruby_code_symbol_ref25[] PROGMEM ="**";
-const char mmruby_code_symbol_ref26[] PROGMEM ="%";
-const char mmruby_code_symbol_ref27[] PROGMEM ="&";
-const char mmruby_code_symbol_ref28[] PROGMEM ="|";
-const char mmruby_code_symbol_ref29[] PROGMEM ="^";
-const char mmruby_code_symbol_ref2a[] PROGMEM ="~";
-const char mmruby_code_symbol_ref2b[] PROGMEM ="abs";
-const char mmruby_code_symbol_ref2c[] PROGMEM ="times";
-const char mmruby_code_symbol_ref2d[] PROGMEM ="chr";
-const char mmruby_code_symbol_ref2e[] PROGMEM ="to_i";
-const char mmruby_code_symbol_ref2f[] PROGMEM ="size";
-const char mmruby_code_symbol_ref30[] PROGMEM ="digital_read";
+const char mmruby_code_symbol_ref24[] PROGMEM ="call";
+const char mmruby_code_symbol_ref25[] PROGMEM ="-@";
+const char mmruby_code_symbol_ref26[] PROGMEM ="**";
+const char mmruby_code_symbol_ref27[] PROGMEM ="%";
+const char mmruby_code_symbol_ref28[] PROGMEM ="&";
+const char mmruby_code_symbol_ref29[] PROGMEM ="|";
+const char mmruby_code_symbol_ref2a[] PROGMEM ="^";
+const char mmruby_code_symbol_ref2b[] PROGMEM ="~";
+const char mmruby_code_symbol_ref2c[] PROGMEM ="abs";
+const char mmruby_code_symbol_ref2d[] PROGMEM ="times";
+const char mmruby_code_symbol_ref2e[] PROGMEM ="chr";
+const char mmruby_code_symbol_ref2f[] PROGMEM ="to_i";
+const char mmruby_code_symbol_ref30[] PROGMEM ="all_symbols";
+const char mmruby_code_symbol_ref31[] PROGMEM ="id2name";
+const char mmruby_code_symbol_ref32[] PROGMEM ="to_sym";
+const char mmruby_code_symbol_ref33[] PROGMEM ="digital_read";
 
 const char* const mmruby_code_symbol_table[] PROGMEM = {
   mmruby_code_symbol_ref00,
@@ -233,6 +250,9 @@ const char* const mmruby_code_symbol_table[] PROGMEM = {
   mmruby_code_symbol_ref2e,
   mmruby_code_symbol_ref2f,
   mmruby_code_symbol_ref30,
+  mmruby_code_symbol_ref31,
+  mmruby_code_symbol_ref32,
+  mmruby_code_symbol_ref33,
 };
 
 /* Symbol IDs */

src/symbol.cpp

@@ -15,6 +15,7 @@
 #include <stdint.h>
 #include <string.h>
 #include "avr_access.h"
+#include "class.h"
 #include "symbol.h"
 #include "alloc.h"
 #include "console.h"
@@ -111,3 +112,44 @@ const char * symid_to_str(mrb_sym sym_id)
   return symbol_table[sym_id-static_sym_tbl_size];
 }
 
+/* Methods in Symbol class */
+void c_all_symbols(mrb_mvm *vm, mrb_value v[], int argc)
+{
+  //TODO
+#if 0
+  mrb_value ret = mrbc_array_new(vm, sym_index_pos);
+
+  int i;
+  for( i = 0; i < sym_index_pos; i++ ) {
+    mrb_value sym1 = {.tt = MRB_TT_SYMBOL};
+    sym1.i = i;
+    mrbc_array_push(&ret, &sym1);
+  }
+  SET_RETURN(ret);
+#endif
+}
+
+void c_to_s(mrb_mvm *vm, mrb_value v[], int argc)
+{
+  v[0] = mrbc_string_new_cstr( symid_to_str(v[0].i));
+}
+
+void c_equal3(mrb_mvm *vm, mrb_value v[], int argc)
+{
+  if( mrbc_compare(&v[0], &v[1]) == 0 ) {
+    SET_TRUE_RETURN();
+  } else {
+    SET_FALSE_RETURN();
+  }
+}
+
+void mrbc_init_class_symbol(void){
+  mrbc_class_symbol = mrbc_define_class("Symbol", 0);
+  //methods
+  //all_symbols
+  //to_s
+  //id2name
+  //to_sym
+  //===
+}
+

src/symbol.h

@@ -23,9 +23,14 @@ struct VM;
 
 void init_symbol_table(void);
 mrb_value mrbc_symbol_new(struct VM *vm, const char *str);
+mrb_value mrbc_string_new_cstr(const char *src);
 mrb_sym str_to_symid(const char *str);
 const char *symid_to_str(mrb_sym sym_id);
-void mrbc_init_class_symbol(struct VM *vm);
+void mrbc_init_class_symbol(void);
+
+void c_all_symbols(mrb_mvm *vm, mrb_value v[], int argc);
+void c_to_s(mrb_mvm *vm, mrb_value v[], int argc);
+void c_equal3(mrb_mvm *vm, mrb_value v[], int argc);
 
 static inline const char * mrbc_symbol_cstr(const mrb_value *v)
 {