diff options
39 files changed, 563 insertions, 277 deletions
@@ -10,10 +10,8 @@ load "#{MRUBY_ROOT}/tasks/mruby_build.rake" load "#{MRUBY_ROOT}/tasks/mrbgem_spec.rake" # load configuration file -MRUBY_CONFIGS = ["#{MRUBY_ROOT}/build_config.rb", ENV['MRUBY_CONFIG']].compact -MRUBY_CONFIGS.each do |config| - load config unless config.empty? -end +MRUBY_CONFIG = (ENV['MRUBY_CONFIG'] && ENV['MRUBY_CONFIG'] != '') ? ENV['MRUBY_CONFIG'] : "#{MRUBY_ROOT}/build_config.rb" +load MRUBY_CONFIG # load basic rules MRuby.each_target do |build| @@ -49,6 +47,30 @@ depfiles = MRuby.targets['host'].bins.map do |bin| install_path end +MRuby.each_target do + gems.map do | gem | + current_dir = gem.dir.relative_path_from(Dir.pwd) + relative_from_root = gem.dir.relative_path_from(MRUBY_ROOT) + current_build_dir = "#{build_dir}/#{relative_from_root}" + + gem.bins.each do | bin | + exec = exefile("#{build_dir}/bin/#{bin}") + objs = Dir.glob("#{current_dir}/tool/#{bin}/*.c").map { |f| objfile(f.pathmap("#{current_build_dir}/tool/#{bin}/%n")) } + + file exec => objs + [libfile("#{build_dir}/lib/libmruby")] do |t| + gem_flags = gems.map { |g| g.linker.flags } + gem_flags_before_libraries = gems.map { |g| g.linker.flags_before_libraries } + gem_flags_after_libraries = gems.map { |g| g.linker.flags_after_libraries } + gem_libraries = gems.map { |g| g.linker.libraries } + gem_library_paths = gems.map { |g| g.linker.library_paths } + linker.run t.name, t.prerequisites, gem_libraries, gem_library_paths, gem_flags, gem_flags_before_libraries + end + + depfiles += [ exec ] + end + end +end + depfiles += MRuby.targets.reject { |n, t| n == 'host' }.map { |n, t| [t.libfile("#{t.build_dir}/lib/libmruby")] + t.bins.map { |bin| t.exefile("#{t.build_dir}/bin/#{bin}") } }.flatten diff --git a/build_config.rb b/build_config.rb index 3c089d8cc..7ca020527 100644 --- a/build_config.rb +++ b/build_config.rb @@ -12,16 +12,22 @@ MRuby::Build.new do |conf| # conf.gem :git => '[email protected]:masuidrive/mrbgems-example.git', :branch => 'master', :options => '-v' # Use standard Math module - conf.gem 'mrbgems/mruby-math' + conf.gem "#{root}/mrbgems/mruby-math" # Use standard Time class - conf.gem 'mrbgems/mruby-time' + conf.gem "#{root}/mrbgems/mruby-time" # Use standard Struct class - conf.gem 'mrbgems/mruby-struct' + conf.gem "#{root}/mrbgems/mruby-struct" # Use standard Kernel#sprintf method - conf.gem 'mrbgems/mruby-sprintf' + conf.gem "#{root}/mrbgems/mruby-sprintf" + + # Use extensional String class + conf.gem "#{root}/mrbgems/mruby-string-ext" + + # Use extensional Numeric class + conf.gem "#{root}/mrbgems/mruby-numeric-ext" # Generate binaries # conf.bins = %w(mrbc mruby mirb) diff --git a/include/mrbconf.h b/include/mrbconf.h index 52490ceba..b485642dc 100644 --- a/include/mrbconf.h +++ b/include/mrbconf.h @@ -46,6 +46,10 @@ /* page size of memory pool */ //#define POOL_PAGE_SIZE 16000 +/* initial minimum size for string buffer */ +//#define MRB_STR_BUF_MIN_SIZE 128 + + /* -DDISABLE_XXXX to drop following features */ //#define DISABLE_STDIO /* use of stdio */ @@ -64,7 +68,7 @@ # define str_to_mrb_float(buf) strtod(buf, NULL) #endif -#ifdef MRB_INT64 +#if defined(MRB_INT64) # ifdef MRB_NAN_BOXING # error Cannot use NaN boxing when mrb_int is 64bit # else @@ -73,6 +77,11 @@ # define MRB_INT_MAX INT64_MAX # define str_to_mrb_int(buf) strtoll(buf, NULL, 10) # endif +#elif defined(MRB_INT16) + typedef int16_t mrb_int; +# define MRB_INT_MIN INT16_MIN +# define MRB_INT_MAX INT16_MAX +# define str_to_mrb_int(buf) strtol(buf, NULL, 10) #else typedef int32_t mrb_int; # define MRB_INT_MIN INT32_MIN @@ -106,8 +115,10 @@ typedef short mrb_sym; # define strtoll _strtoi64 # define PRId32 "I32d" # define PRId64 "I64d" +typedef unsigned int mrb_bool; #else # include <inttypes.h> +typedef _Bool mrb_bool; #endif #ifdef ENABLE_STDIO diff --git a/include/mruby.h b/include/mruby.h index ed746f409..1054fd639 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -121,9 +121,9 @@ typedef struct mrb_state { size_t gc_threshold; int gc_interval_ratio; int gc_step_ratio; - unsigned int gc_disabled:1; - unsigned int gc_full:1; - unsigned int is_generational_gc_mode:1; + mrb_bool gc_disabled:1; + mrb_bool gc_full:1; + mrb_bool is_generational_gc_mode:1; size_t majorgc_old_threshold; struct alloca_header *mems; @@ -156,6 +156,7 @@ void mrb_undef_class_method(mrb_state*, struct RClass*, const char*); mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv); struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super); struct RClass * mrb_module_new(mrb_state *mrb); +int mrb_class_defined(mrb_state *mrb, const char *name); struct RClass * mrb_class_get(mrb_state *mrb, const char *name); struct RClass * mrb_class_obj_get(mrb_state *mrb, const char *name); @@ -189,10 +190,10 @@ mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...); mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, mrb_value*); mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, mrb_value*, mrb_value); mrb_sym mrb_intern(mrb_state*,const char*); -mrb_sym mrb_intern2(mrb_state*,const char*,int); +mrb_sym mrb_intern2(mrb_state*,const char*,size_t); mrb_sym mrb_intern_str(mrb_state*,mrb_value); const char *mrb_sym2name(mrb_state*,mrb_sym); -const char *mrb_sym2name_len(mrb_state*,mrb_sym,int*); +const char *mrb_sym2name_len(mrb_state*,mrb_sym,size_t*); mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value); void *mrb_malloc(mrb_state*, size_t); @@ -201,9 +202,8 @@ void *mrb_realloc(mrb_state*, void*, size_t); struct RBasic *mrb_obj_alloc(mrb_state*, enum mrb_vtype, struct RClass*); void *mrb_free(mrb_state*, void*); -mrb_value mrb_str_new(mrb_state *mrb, const char *p, int len); /* mrb_str_new */ +mrb_value mrb_str_new(mrb_state *mrb, const char *p, size_t len); mrb_value mrb_str_new_cstr(mrb_state*, const char*); -mrb_value mrb_str_new2(mrb_state *mrb, const char *p); mrb_state* mrb_open(void); mrb_state* mrb_open_allocf(mrb_allocf, void *ud); diff --git a/include/mruby/array.h b/include/mruby/array.h index 5d78ccddd..7fba4a99c 100644 --- a/include/mruby/array.h +++ b/include/mruby/array.h @@ -38,12 +38,14 @@ struct RArray { void mrb_ary_decref(mrb_state*, mrb_shared_array*); mrb_value mrb_ary_new_capa(mrb_state*, mrb_int); mrb_value mrb_ary_new(mrb_state *mrb); -mrb_value mrb_ary_new_elts(mrb_state *mrb, mrb_int n, const mrb_value *elts); +mrb_value mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals); +/* compatibility macros - soon to be removed */ +#define mrb_ary_new_elts(mrb,size,vals) mrb_ary_new_from_values(mrb,size,vals) +#define mrb_ary_new4(mrb,size,vals) mrb_ary_new_from_values(mrb,size,vals) void mrb_ary_concat(mrb_state*, mrb_value, mrb_value); mrb_value mrb_ary_splat(mrb_state*, mrb_value); void mrb_ary_push(mrb_state*, mrb_value, mrb_value); mrb_value mrb_ary_pop(mrb_state *mrb, mrb_value ary); -mrb_value mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, mrb_value *vals); mrb_value mrb_ary_aget(mrb_state *mrb, mrb_value self); mrb_value mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n); void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val); @@ -51,7 +53,6 @@ mrb_int mrb_ary_len(mrb_state *mrb, mrb_value ary); void mrb_ary_replace(mrb_state *mrb, mrb_value a, mrb_value b); mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self); mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item); -mrb_value mrb_ary_new4(mrb_state *mrb, mrb_int n, const mrb_value *elts); mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr); mrb_value mrb_ary_entry(mrb_value ary, mrb_int offset); mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self); diff --git a/include/mruby/compile.h b/include/mruby/compile.h index 2cbc28321..a50c85e42 100644 --- a/include/mruby/compile.h +++ b/include/mruby/compile.h @@ -21,9 +21,9 @@ typedef struct mrbc_context { int slen; char *filename; short lineno; - int capture_errors:1; - int dump_result:1; - int no_exec:1; + mrb_bool capture_errors:1; + mrb_bool dump_result:1; + mrb_bool no_exec:1; } mrbc_context; mrbc_context* mrbc_context_new(mrb_state *mrb); @@ -67,8 +67,8 @@ enum heredoc_type { /* heredoc structure */ struct mrb_parser_heredoc_info { enum heredoc_type type; - int allow_indent:1; - int line_head:1; + mrb_bool allow_indent:1; + mrb_bool line_head:1; const char *term; int term_len; mrb_ast_node *doc; @@ -102,8 +102,8 @@ struct mrb_parser_state { mrb_ast_node *heredocs; /* list of mrb_parser_heredoc_info* */ mrb_ast_node *parsing_heredoc; - int heredoc_starts_nextline:1; - int heredoc_end_now:1; /* for mirb */ + mrb_bool heredoc_starts_nextline:1; + mrb_bool heredoc_end_now:1; /* for mirb */ void *ylval; diff --git a/include/mruby/string.h b/include/mruby/string.h index 4ba4ce544..613c6c6a7 100644 --- a/include/mruby/string.h +++ b/include/mruby/string.h @@ -13,8 +13,6 @@ extern "C" { #define IS_EVSTR(p,e) ((p) < (e) && (*(p) == '$' || *(p) == '@' || *(p) == '{')) -#define STR_BUF_MIN_SIZE 128 - extern const char mrb_digitmap[]; typedef struct mrb_shared_string { @@ -48,14 +46,13 @@ mrb_value mrb_str_plus(mrb_state*, mrb_value, mrb_value); mrb_value mrb_obj_as_string(mrb_state *mrb, mrb_value obj); mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, int len); /* mrb_str_resize */ mrb_value mrb_string_value(mrb_state *mrb, mrb_value *ptr); /* StringValue */ -mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, int len); +mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len); mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str); mrb_value mrb_str_buf_new(mrb_state *mrb, int capa); -mrb_value mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, int len); +mrb_value mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len); char *mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr); char *mrb_string_value_ptr(mrb_state *mrb, mrb_value ptr); -int mrb_str_sublen(mrb_state *mrb, mrb_value str, int pos); int mrb_str_offset(mrb_state *mrb, mrb_value str, int pos); mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str); /* mrb_str_dup */ mrb_value mrb_str_intern(mrb_state *mrb, mrb_value self); @@ -68,7 +65,7 @@ mrb_value mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2); mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str); int mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2); mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str); -mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, long len); +mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, mrb_int len); mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2); int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2); diff --git a/mrbgems/mruby-numeric-ext/mrbgem.rake b/mrbgems/mruby-numeric-ext/mrbgem.rake new file mode 100644 index 000000000..69c4fde4c --- /dev/null +++ b/mrbgems/mruby-numeric-ext/mrbgem.rake @@ -0,0 +1,4 @@ +MRuby::Gem::Specification.new('mruby-numeric-ext') do |spec| + spec.license = 'MIT' + spec.authors = 'mruby developers' +end diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c new file mode 100644 index 000000000..b2c0e7986 --- /dev/null +++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c @@ -0,0 +1,30 @@ +#include "mruby.h" +#include "mruby/numeric.h" + +static mrb_value +mrb_int_chr(mrb_state *mrb, mrb_value x) +{ + mrb_int chr; + char c; + + chr = mrb_fixnum(x); + if (chr >= (1 << CHAR_BIT)) { + mrb_raisef(mrb, E_RANGE_ERROR, "%ld out of char range", chr); + } + c = (char)chr; + + return mrb_str_new(mrb, &c, 1); +} + +void +mrb_mruby_numeric_ext_gem_init(mrb_state* mrb) +{ + struct RClass *i = mrb_class_get(mrb, "Integer"); + + mrb_define_method(mrb, i, "chr", mrb_int_chr, ARGS_NONE()); +} + +void +mrb_mruby_numeric_ext_gem_final(mrb_state* mrb) +{ +} diff --git a/mrbgems/mruby-numeric-ext/test/numeric.rb b/mrbgems/mruby-numeric-ext/test/numeric.rb new file mode 100644 index 000000000..6c1cf0fce --- /dev/null +++ b/mrbgems/mruby-numeric-ext/test/numeric.rb @@ -0,0 +1,10 @@ +## +# Numeric(Ext) Test + +assert('Integer#chr') do + assert_equal(65.chr, "A") + assert_equal(0x42.chr, "B") + + # multibyte encoding (not support yet) + assert_raise(RangeError) { 12345.chr } +end diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index 12ed05d13..8aff03cbf 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/mrbgems/mruby-sprintf/src/sprintf.c @@ -26,7 +26,7 @@ #define BITSPERDIG (sizeof(mrb_int)*CHAR_BIT) #define EXTENDSIGN(n, l) (((~0 << (n)) >> (((n)*(l)) % BITSPERDIG)) & ~(~0 << (n))) -static void fmt_setup(char*,size_t,int,int,int,int); +static void fmt_setup(char*,size_t,int,int,mrb_int,mrb_int); static char* remove_sign_bits(char *str, int base) @@ -78,7 +78,8 @@ static mrb_value mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base) { char buf[64], *b = buf + sizeof buf; - unsigned long val = mrb_fixnum(x); + mrb_int num = mrb_fixnum(x); + unsigned long val = (unsigned long)num; char d; if (base != 2) { @@ -96,7 +97,7 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base) *--b = mrb_digitmap[(int)(val % base)]; } while (val /= base); - if (mrb_fixnum(x) < 0) { + if (num < 0) { b = remove_sign_bits(b, base); switch (base) { case 16: d = 'f'; break; @@ -110,7 +111,7 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base) } } - return mrb_str_new2(mrb, b); + return mrb_str_new_cstr(mrb, b); } #define FNONE 0 @@ -495,10 +496,13 @@ mrb_str_format(mrb_state *mrb, int argc, const mrb_value *argv, mrb_value fmt) { const char *p, *end; char *buf; - long blen, bsiz; + mrb_int blen; + mrb_int bsiz; mrb_value result; - int n; - int width, prec, flags = FNONE; + mrb_int n; + mrb_int width; + mrb_int prec; + int flags = FNONE; int nextarg = 1; int posarg = 0; mrb_value nextvalue; @@ -709,7 +713,8 @@ retry: format_s: { mrb_value arg = GETARG(); - long len, slen; + mrb_int len; + mrb_int slen; if (*p == 'p') arg = mrb_inspect(mrb, arg); str = mrb_obj_as_string(mrb, arg); @@ -760,12 +765,12 @@ retry: case 'u': { mrb_value val = GETARG(); char fbuf[32], nbuf[64], *s; - const char *prefix = 0; + const char *prefix = NULL; int sign = 0, dots = 0; char sc = 0; - long v = 0, org_v = 0; + mrb_int v = 0, org_v = 0; int base; - int len; + mrb_int len; switch (*p) { case 'd': @@ -807,7 +812,7 @@ retry: val = mrb_str_to_inum(mrb, val, 0, TRUE); goto bin_retry; case MRB_TT_FIXNUM: - v = (long)mrb_fixnum(val); + v = mrb_fixnum(val); break; default: val = mrb_Integer(mrb, val); @@ -888,7 +893,12 @@ retry: } } } - len = (int)strlen(s); + { + size_t size; + size = strlen(s); + /* PARANOID: assert(size <= MRB_INT_MAX) */ + len = (mrb_int)size; + } if (dots) { prec -= 2; @@ -906,22 +916,26 @@ retry: if (prefix && !prefix[1]) { /* octal */ if (dots) { - prefix = 0; + prefix = NULL; } else if (len == 1 && *s == '0') { len = 0; if (flags & FPREC) prec--; } else if ((flags & FPREC) && (prec > len)) { - prefix = 0; + prefix = NULL; } } else if (len == 1 && *s == '0') { - prefix = 0; + prefix = NULL; } if (prefix) { - width -= (int)strlen(prefix); + size_t size; + size = strlen(prefix); + /* PARANOID: assert(size <= MRB_INT_MAX). + * this check is absolutely paranoid. */ + width -= (mrb_int)size; } if ((flags & (FZERO|FMINUS|FPREC)) == FZERO) { @@ -1064,7 +1078,7 @@ retry: } static void -fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec) +fmt_setup(char *buf, size_t size, int c, int flags, mrb_int width, mrb_int prec) { char *end = buf + size; int n; @@ -1077,12 +1091,12 @@ fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec) if (flags & FSPACE) *buf++ = ' '; if (flags & FWIDTH) { - n = snprintf(buf, end - buf, "%d", width); + n = snprintf(buf, end - buf, "%d", (int)width); buf += n; } if (flags & FPREC) { - n = snprintf(buf, end - buf, ".%d", prec); + n = snprintf(buf, end - buf, ".%d", (int)prec); buf += n; } diff --git a/mrbgems/mruby-string-ext/mrbgem.rake b/mrbgems/mruby-string-ext/mrbgem.rake new file mode 100644 index 000000000..83db97eb4 --- /dev/null +++ b/mrbgems/mruby-string-ext/mrbgem.rake @@ -0,0 +1,4 @@ +MRuby::Gem::Specification.new('mruby-string-ext') do |spec| + spec.license = 'MIT' + spec.authors = 'mruby developers' +end diff --git a/mrbgems/mruby-string-ext/mrblib/string.rb b/mrbgems/mruby-string-ext/mrblib/string.rb new file mode 100644 index 000000000..142a63882 --- /dev/null +++ b/mrbgems/mruby-string-ext/mrblib/string.rb @@ -0,0 +1,38 @@ +class String + def lstrip + a = 0 + z = self.size - 1 + a += 1 while " \f\n\r\t\v".include?(self[a]) and a <= z + (z >= 0) ? self[a..z] : "" + end + + def rstrip + a = 0 + z = self.size - 1 + z -= 1 while " \f\n\r\t\v\0".include?(self[z]) and a <= z + (z >= 0) ? self[a..z] : "" + end + + def strip + a = 0 + z = self.size - 1 + a += 1 while " \f\n\r\t\v".include?(self[a]) and a <= z + z -= 1 while " \f\n\r\t\v\0".include?(self[z]) and a <= z + (z >= 0) ? self[a..z] : "" + end + + def lstrip! + s = self.lstrip + (s == self) ? nil : self.replace(s) + end + + def rstrip! + s = self.rstrip + (s == self) ? nil : self.replace(s) + end + + def strip! + s = self.strip + (s == self) ? nil : self.replace(s) + end +end diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c new file mode 100644 index 000000000..b10b021a2 --- /dev/null +++ b/mrbgems/mruby-string-ext/src/string.c @@ -0,0 +1,31 @@ +#include "mruby.h" +#include "mruby/string.h" + +static mrb_value +mrb_str_getbyte(mrb_state *mrb, mrb_value str) +{ + mrb_int pos; + mrb_get_args(mrb, "i", &pos); + + if (pos < 0) + pos += RSTRING_LEN(str); + if (pos < 0 || RSTRING_LEN(str) <= pos) + return mrb_nil_value(); + + return mrb_fixnum_value((unsigned char)RSTRING_PTR(str)[pos]); +} + + +void +mrb_mruby_string_ext_gem_init(mrb_state* mrb) +{ + struct RClass * s = mrb->string_class; + + mrb_define_method(mrb, s, "dump", mrb_str_dump, ARGS_NONE()); + mrb_define_method(mrb, s, "getbyte", mrb_str_getbyte, ARGS_REQ(1)); +} + +void +mrb_mruby_string_ext_gem_final(mrb_state* mrb) +{ +} diff --git a/mrbgems/mruby-string-ext/test/string.rb b/mrbgems/mruby-string-ext/test/string.rb new file mode 100644 index 000000000..eaff81890 --- /dev/null +++ b/mrbgems/mruby-string-ext/test/string.rb @@ -0,0 +1,72 @@ +## +# String(Ext) Test + +assert('String#getbyte') do + str1 = "hello" + bytes1 = [104, 101, 108, 108, 111] + assert_equal bytes1[0], str1.getbyte(0) + assert_equal bytes1[-1], str1.getbyte(-1) + assert_equal bytes1[6], str1.getbyte(6) + + str2 = "\xFF" + bytes2 = [0xFF] + assert_equal bytes2[0], str2.getbyte(0) +end + +assert('String#dump') do + "foo".dump == "\"foo\"" +end + +assert('String#strip') do + s = " abc " + s.strip + "".strip == "" and " \t\r\n\f\v".strip == "" and + "\0a\0".strip == "\0a" and + "abc".strip == "abc" and + " abc".strip == "abc" and + "abc ".strip == "abc" and + " abc ".strip == "abc" and + s == " abc " +end + +assert('String#lstrip') do + s = " abc " + s.lstrip + "".lstrip == "" and " \t\r\n\f\v".lstrip == "" and + "\0a\0".lstrip == "\0a\0" and + "abc".lstrip == "abc" and + " abc".lstrip == "abc" and + "abc ".lstrip == "abc " and + " abc ".lstrip == "abc " and + s == " abc " +end + +assert('String#rstrip') do + s = " abc " + s.rstrip + "".rstrip == "" and " \t\r\n\f\v".rstrip == "" and + "\0a\0".rstrip == "\0a" and + "abc".rstrip == "abc" and + " abc".rstrip == " abc" and + "abc ".rstrip == "abc" and + " abc ".rstrip == " abc" and + s == " abc " +end + +assert('String#strip!') do + s = " abc " + t = "abc" + s.strip! == "abc" and s == "abc" and t.strip! == nil +end + +assert('String#lstrip!') do + s = " abc " + t = "abc " + s.lstrip! == "abc " and s == "abc " and t.lstrip! == nil +end + +assert('String#rstrip!') do + s = " abc " + t = " abc" + s.rstrip! == " abc" and s == " abc" and t.rstrip! == nil +end diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index 33997b294..b1ee9579f 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -112,7 +112,7 @@ mrb_value mrb_struct_getmember(mrb_state *mrb, mrb_value obj, mrb_sym id) { mrb_value members, slot, *ptr, *ptr_members; - long i, len; + mrb_int i, len; ptr = RSTRUCT_PTR(obj); members = mrb_struct_members(mrb, obj); @@ -166,7 +166,7 @@ mrb_id_attrset(mrb_state *mrb, mrb_sym id) { const char *name; char *buf; - int len; + size_t len; mrb_sym mid; name = mrb_sym2name_len(mrb, id, &len); @@ -184,7 +184,8 @@ static mrb_value mrb_struct_set(mrb_state *mrb, mrb_value obj, mrb_value val) { const char *name; - int i, len; + int i; + size_t len; mrb_sym mid; mrb_value members, slot, *ptr, *ptr_members; @@ -236,7 +237,7 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass * k { mrb_value nstr, *ptr_members; mrb_sym id; - long i, len; + mrb_int i, len; struct RClass *c; if (mrb_nil_p(name)) { @@ -288,7 +289,7 @@ mrb_struct_define(mrb_state *mrb, const char *name, ...) char *mem; if (!name) nm = mrb_nil_value(); - else nm = mrb_str_new2(mrb, name); + else nm = mrb_str_new_cstr(mrb, name); ary = mrb_ary_new(mrb); va_start(ar, name); @@ -341,7 +342,7 @@ mrb_struct_s_def(mrb_state *mrb, mrb_value klass) mrb_value name, rest; mrb_value *pargv; int argcnt; - long i; + mrb_int i; mrb_value b, st; mrb_sym id; mrb_value *argv; @@ -444,7 +445,7 @@ inspect_struct(mrb_state *mrb, mrb_value s, int recur) const char *cn = mrb_class_name(mrb, mrb_obj_class(mrb, s)); mrb_value members, str = mrb_str_new(mrb, "#<struct ", 9); mrb_value *ptr, *ptr_members; - long i, len; + mrb_int i, len; if (cn) { mrb_str_append(mrb, str, mrb_str_new_cstr(mrb, cn)); @@ -471,7 +472,7 @@ inspect_struct(mrb_state *mrb, mrb_value s, int recur) id = mrb_symbol(slot); if (mrb_is_local_id(id) || mrb_is_const_id(id)) { const char *name; - int len; + size_t len; name = mrb_sym2name_len(mrb, id, &len); mrb_str_append(mrb, str, mrb_str_new(mrb, name, len)); @@ -531,7 +532,7 @@ static mrb_value mrb_struct_aref_id(mrb_state *mrb, mrb_value s, mrb_sym id) { mrb_value *ptr, members, *ptr_members; - long i, len; + mrb_int i, len; ptr = RSTRUCT_PTR(s); members = mrb_struct_members(mrb, s); @@ -568,7 +569,7 @@ mrb_struct_aref_id(mrb_state *mrb, mrb_value s, mrb_sym id) mrb_value mrb_struct_aref_n(mrb_state *mrb, mrb_value s, mrb_value idx) { - long i; + mrb_int i; if (mrb_string_p(idx) || mrb_symbol_p(idx)) { return mrb_struct_aref_id(mrb, s, mrb_to_id(mrb, idx)); @@ -598,7 +599,7 @@ static mrb_value mrb_struct_aset_id(mrb_state *mrb, mrb_value s, mrb_sym id, mrb_value val) { mrb_value members, *ptr, *ptr_members; - long i, len; + mrb_int i, len; members = mrb_struct_members(mrb, s); len = RARRAY_LEN(members); @@ -643,7 +644,7 @@ mrb_struct_aset_id(mrb_state *mrb, mrb_value s, mrb_sym id, mrb_value val) mrb_value mrb_struct_aset(mrb_state *mrb, mrb_value s) { - long i; + mrb_int i; mrb_value idx; mrb_value val; @@ -689,7 +690,7 @@ mrb_struct_equal(mrb_state *mrb, mrb_value s) { mrb_value s2; mrb_value *ptr, *ptr2; - long i, len; + mrb_int i, len; mrb_get_args(mrb, "o", &s2); if (mrb_obj_equal(mrb, s, s2)) return mrb_true_value(); @@ -720,7 +721,7 @@ mrb_struct_eql(mrb_state *mrb, mrb_value s) { mrb_value s2; mrb_value *ptr, *ptr2; - long i, len; + mrb_int i, len; mrb_get_args(mrb, "o", &s2); if (mrb_obj_equal(mrb, s, s2)) return mrb_true_value(); diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index ecc9090f1..74882e1e8 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -130,7 +130,7 @@ mrb_time_free(mrb_state *mrb, void *ptr) static struct mrb_data_type mrb_time_type = { "Time", mrb_time_free }; /** Updates the datetime of a mrb_time based on it's timezone and -seconds setting. Returns self on cussess, NULL of failure. */ +seconds setting. Returns self on success, NULL of failure. */ static struct mrb_time* mrb_time_update_datetime(struct mrb_time *self) { @@ -528,6 +528,8 @@ mrb_time_initialize(mrb_state *mrb, mrb_value self) if (tm) { mrb_time_free(mrb, tm); } + DATA_TYPE(self) = &mrb_time_type; + DATA_PTR(self) = NULL; n = mrb_get_args(mrb, "|iiiiiii", &ayear, &amonth, &aday, &ahour, &amin, &asec, &ausec); @@ -538,7 +540,6 @@ mrb_time_initialize(mrb_state *mrb, mrb_value self) tm = time_mktime(mrb, ayear, amonth, aday, ahour, amin, asec, ausec, MRB_TIMEZONE_LOCAL); } DATA_PTR(self) = tm; - DATA_TYPE(self) = &mrb_time_type; return self; } diff --git a/src/array.c b/src/array.c index b8cd436f0..f0fcdb10d 100644 --- a/src/array.c +++ b/src/array.c @@ -89,21 +89,6 @@ array_copy(mrb_value *dst, const mrb_value *src, size_t size) } } - -mrb_value -mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, mrb_value *vals) -{ - mrb_value ary; - struct RArray *a; - - ary = mrb_ary_new_capa(mrb, size); - a = mrb_ary_ptr(ary); - array_copy(a->ptr, vals, size); - a->len = size; - - return ary; -} - mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr) { @@ -433,25 +418,19 @@ mrb_ary_reverse(mrb_state *mrb, mrb_value self) } mrb_value -mrb_ary_new4(mrb_state *mrb, mrb_int n, const mrb_value *elts) +mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals) { mrb_value ary; + struct RArray *a; - ary = mrb_ary_new_capa(mrb, n); - if (n > 0 && elts) { - array_copy(RARRAY_PTR(ary), elts, n); - RARRAY_LEN(ary) = n; - } + ary = mrb_ary_new_capa(mrb, size); + a = mrb_ary_ptr(ary); + array_copy(a->ptr, vals, size); + a->len = size; return ary; } -mrb_value -mrb_ary_new_elts(mrb_state *mrb, mrb_int n, const mrb_value *elts) -{ - return mrb_ary_new4(mrb, n, elts); -} - void mrb_ary_push(mrb_state *mrb, mrb_value ary, mrb_value elem) /* mrb_ary_push */ { @@ -938,7 +917,7 @@ inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list) mrb_str_buf_cat(mrb, arystr, head, sizeof(head)); for(i=0; i<RARRAY_LEN(ary); i++) { - mrb_int ai = mrb_gc_arena_save(mrb); + int ai = mrb_gc_arena_save(mrb); if (i > 0) { mrb_str_buf_cat(mrb, arystr, sep, sizeof(sep)); diff --git a/src/class.c b/src/class.c index a3defc2ae..7935b7b3e 100644 --- a/src/class.c +++ b/src/class.c @@ -203,6 +203,12 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id return c; } +int +mrb_class_defined(mrb_state *mrb, const char *name) +{ + return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), mrb_intern(mrb, name)); +} + static struct RClass * class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym id) { @@ -293,10 +299,12 @@ void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, int aspec) { struct RProc *p; + int ai = mrb_gc_arena_save(mrb); p = mrb_proc_new_cfunc(mrb, func); p->target_class = c; mrb_define_method_raw(mrb, c, mid, p); + mrb_gc_arena_restore(mrb, ai); } void @@ -1176,7 +1184,7 @@ mrb_class_path(mrb_state *mrb, struct RClass *c) { mrb_value path; const char *name; - int len; + size_t len; path = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern(mrb, "__classpath__")); if (mrb_nil_p(path)) { @@ -1453,7 +1461,7 @@ static void check_cv_name(mrb_state *mrb, mrb_sym id) { const char *s; - int len; + size_t len; s = mrb_sym2name_len(mrb, id, &len); if (len < 3 || !(s[0] == '@' && s[1] == '@')) { @@ -1675,7 +1683,7 @@ static void check_const_name(mrb_state *mrb, mrb_sym id) { const char *s; - int len; + size_t len; s = mrb_sym2name_len(mrb, id, &len); if (len < 1 || !ISUPPER(*s)) { diff --git a/src/codegen.c b/src/codegen.c index 33df7fbf5..799434a06 100644 --- a/src/codegen.c +++ b/src/codegen.c @@ -49,7 +49,7 @@ typedef struct scope { int pc; int lastlabel; int ainfo:15; - int mscope:1; + mrb_bool mscope:1; struct loopinfo *loop; int ensure_level; @@ -690,7 +690,7 @@ static mrb_sym attrsym(codegen_scope *s, mrb_sym a) { const char *name; - int len; + size_t len; char *name2; name = mrb_sym2name_len(s->mrb, a, &len); @@ -708,7 +708,7 @@ gen_values(codegen_scope *s, node *t, int val) int n = 0; while (t) { - if ((intptr_t)t->car->car == NODE_SPLAT) { // splat mode + if (n >= 127 || (intptr_t)t->car->car == NODE_SPLAT) { // splat mode if (val) { pop_n(n); genop(s, MKOP_ABC(OP_ARRAY, cursp(), cursp(), n)); @@ -789,7 +789,7 @@ gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val) } pop_n(n+1); { - int len; + size_t len; const char *name = mrb_sym2name_len(s->mrb, sym, &len); if (!noop && len == 1 && name[0] == '+') { @@ -1491,7 +1491,7 @@ codegen(codegen_scope *s, node *tree, int val) case NODE_OP_ASGN: { mrb_sym sym = sym(tree->cdr->car); - int len; + size_t len; const char *name = mrb_sym2name_len(s->mrb, sym, &len); int idx; diff --git a/src/dump.c b/src/dump.c index ba5a69a56..9666f7562 100644 --- a/src/dump.c +++ b/src/dump.c @@ -279,7 +279,7 @@ get_syms_block_size(mrb_state *mrb, mrb_irep *irep, int type) size += DUMP_SIZE(MRB_DUMP_SIZE_OF_SHORT, type); /* snl(n) */ if (irep->syms[sym_no] != 0) { - int len; + size_t len; name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len); nlen = str_dump_len((char*)name, len, type); @@ -421,9 +421,10 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type) uint16_t nlen =0; if (irep->syms[sym_no] != 0) { - int len; + size_t len; name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len); + if (len > UINT16_MAX) goto error_exit; nlen = str_dump_len((char*)name, len, type); if ( nlen > buf_size - 1) { buf_size = nlen + 1; diff --git a/src/error.c b/src/error.c index ed30173bc..6bd891768 100644 --- a/src/error.c +++ b/src/error.c @@ -5,6 +5,7 @@ */ #include "mruby.h" +#include <errno.h> #include <stdarg.h> #include <setjmp.h> #include <string.h> @@ -89,7 +90,7 @@ exc_to_s(mrb_state *mrb, mrb_value exc) { mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern(mrb, "mesg")); - if (mrb_nil_p(mesg)) return mrb_str_new2(mrb, mrb_obj_classname(mrb, exc)); + if (mrb_nil_p(mesg)) return mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, exc)); return mesg; } @@ -140,7 +141,7 @@ exc_inspect(mrb_state *mrb, mrb_value exc) } } else { - str = mrb_str_new2(mrb, mrb_obj_classname(mrb, exc)); + str = mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, exc)); if (!mrb_nil_p(mesg) && RSTRING_LEN(mesg) > 0) { mrb_str_cat2(mrb, str, ": "); mrb_str_append(mrb, str, mesg); @@ -218,7 +219,7 @@ void mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg) { mrb_value mesg; - mesg = mrb_str_new2(mrb, msg); + mesg = mrb_str_new_cstr(mrb, msg); mrb_exc_raise(mrb, mrb_exc_new3(mrb, c, mesg)); } @@ -401,7 +402,20 @@ mrb_make_exception(mrb_state *mrb, int argc, mrb_value *argv) void mrb_sys_fail(mrb_state *mrb, const char *mesg) { - mrb_raise(mrb, E_RUNTIME_ERROR, mesg); + struct RClass *sce; + mrb_int no; + + no = (mrb_int)errno; + if (mrb_class_defined(mrb, "SystemCallError")) { + sce = mrb_class_get(mrb, "SystemCallError"); + if (mesg != NULL) { + mrb_funcall(mrb, mrb_obj_value(sce), "_sys_fail", 2, mrb_fixnum_value(no), mrb_str_new_cstr(mrb, mesg)); + } else { + mrb_funcall(mrb, mrb_obj_value(sce), "_sys_fail", 1, mrb_fixnum_value(no)); + } + } else { + mrb_raise(mrb, E_RUNTIME_ERROR, mesg); + } } void @@ -197,7 +197,7 @@ struct heap_page { struct heap_page *next; struct heap_page *free_next; struct heap_page *free_prev; - unsigned int old:1; + mrb_bool old:1; RVALUE objects[MRB_HEAP_PAGE_SIZE]; }; diff --git a/src/kernel.c b/src/kernel.c index 7187a125d..e0a1a0a52 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -555,7 +555,7 @@ static void check_iv_name(mrb_state *mrb, mrb_sym id) { const char *s; - int len; + size_t len; s = mrb_sym2name_len(mrb, id, &len); if (len < 2 || !(s[0] == '@' && s[1] != '@')) { diff --git a/src/parse.y b/src/parse.y index 62393a0bb..fe1bd805f 100644 --- a/src/parse.y +++ b/src/parse.y @@ -882,7 +882,7 @@ heredoc_start_sym(parser_state *p, node *beg, mrb_sym sym, enum heredoc_type typ { char *bs = (char*)beg->cdr->car; int allow_indent = (bs[2] == '-'); - int len; + size_t len; const char *s = mrb_sym2name_len(p->mrb, sym, &len); return heredoc_start_sb(p, s, len, type, allow_indent); } @@ -3393,34 +3393,38 @@ toklen(parser_state *p) #define IS_LABEL_POSSIBLE() ((p->lstate == EXPR_BEG && !cmd_state) || IS_ARG()) #define IS_LABEL_SUFFIX(n) (peek_n(p, ':',(n)) && !peek_n(p, ':', (n)+1)) -static unsigned long +static int scan_oct(const int *start, int len, int *retlen) { const int *s = start; - unsigned long retval = 0; + int retval = 0; + /* assert(len <= 3) */ while (len-- && *s >= '0' && *s <= '7') { retval <<= 3; retval |= *s++ - '0'; } *retlen = s - start; + return retval; } -static unsigned long +static int scan_hex(const int *start, int len, int *retlen) { static const char hexdigit[] = "0123456789abcdef0123456789ABCDEF"; register const int *s = start; - register unsigned long retval = 0; + register int retval = 0; char *tmp; - while (len-- && *s && (tmp = (char *)strchr(hexdigit, *s))) { + /* assert(len <= 2) */ + while (len-- && *s && (tmp = strchr(hexdigit, *s))) { retval <<= 4; retval |= (tmp - hexdigit) & 15; s++; } *retlen = s - start; + return retval; } @@ -3457,19 +3461,19 @@ read_escape(parser_state *p) case '0': case '1': case '2': case '3': /* octal constant */ case '4': case '5': case '6': case '7': { - int buf[3]; - int i; + int buf[3]; + int i; - buf[0] = c; - for (i=1; i<3; i++) { + buf[0] = c; + for (i=1; i<3; i++) { buf[i] = nextc(p); if (buf[i] == -1) goto eof; - if (buf[i] < '0' || '7' < buf[i]) { - pushback(p, buf[i]); - break; - } - } - c = scan_oct(buf, i, &i); + if (buf[i] < '0' || '7' < buf[i]) { + pushback(p, buf[i]); + break; + } + } + c = scan_oct(buf, i, &i); } return c; diff --git a/src/state.c b/src/state.c index b6805a4a4..b9523b400 100644 --- a/src/state.c +++ b/src/state.c @@ -53,6 +53,7 @@ mrb_alloca(mrb_state *mrb, size_t size) struct alloca_header *p; p = (struct alloca_header*) mrb_malloc(mrb, sizeof(struct alloca_header)+size); + if (p == NULL) return NULL; p->next = mrb->mems; mrb->mems = p; return (void*)p->buf; @@ -61,9 +62,12 @@ mrb_alloca(mrb_state *mrb, size_t size) static void mrb_alloca_free(mrb_state *mrb) { - struct alloca_header *p = mrb->mems; + struct alloca_header *p; struct alloca_header *tmp; + if (mrb == NULL) return; + p = mrb->mems; + while (p) { tmp = p; p = p->next; diff --git a/src/string.c b/src/string.c index cfef5730c..d474f6f96 100644 --- a/src/string.c +++ b/src/string.c @@ -6,6 +6,8 @@ #include "mruby.h" +#include <stdint.h> +#include <stddef.h> #include <string.h> #include "mruby/string.h" #include "mruby/class.h" @@ -20,7 +22,7 @@ const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz"; static mrb_value str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2); -static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len); +static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len); #define RESIZE_CAPA(s,capacity) do {\ s->ptr = (char *)mrb_realloc(mrb, s->ptr, (capacity)+1);\ @@ -56,11 +58,11 @@ str_modify(mrb_state *mrb, struct RString *s) } else { char *ptr, *p; - long len; + mrb_int len; p = s->ptr; len = s->len; - ptr = (char *)mrb_malloc(mrb, len+1); + ptr = (char *)mrb_malloc(mrb, (size_t)len + 1); if (p) { memcpy(ptr, p, len); } @@ -104,21 +106,6 @@ str_mod_check(mrb_state *mrb, mrb_value str, char *p, mrb_int len) #define mrb_obj_alloc_string(mrb) ((struct RString*)mrb_obj_alloc((mrb), MRB_TT_STRING, (mrb)->string_class)) -static struct RString* -str_alloc(mrb_state *mrb, struct RClass *c) -{ - struct RString* s; - - s = mrb_obj_alloc_string(mrb); - - s->c = c; - s->ptr = 0; - s->len = 0; - s->aux.capa = 0; - - return s; -} - /* char offset to byte offset */ int mrb_str_offset(mrb_state *mrb, mrb_value str, int pos) @@ -129,8 +116,9 @@ mrb_str_offset(mrb_state *mrb, mrb_value str, int pos) static struct RString* str_new(mrb_state *mrb, const char *p, int len) { - struct RString *s = str_alloc(mrb, mrb->string_class); + struct RString *s; + s = mrb_obj_alloc_string(mrb); s->len = len; s->aux.capa = len; s->ptr = (char *)mrb_malloc(mrb, len+1); @@ -156,6 +144,10 @@ mrb_str_new_empty(mrb_state *mrb, mrb_value str) return mrb_obj_value(s); } +#ifndef MRB_STR_BUF_MIN_SIZE +# define MRB_STR_BUF_MIN_SIZE 128 +#endif + mrb_value mrb_str_buf_new(mrb_state *mrb, int capa) { @@ -163,8 +155,8 @@ mrb_str_buf_new(mrb_state *mrb, int capa) s = mrb_obj_alloc_string(mrb); - if (capa < STR_BUF_MIN_SIZE) { - capa = STR_BUF_MIN_SIZE; + if (capa < MRB_STR_BUF_MIN_SIZE) { + capa = MRB_STR_BUF_MIN_SIZE; } s->len = 0; s->aux.capa = capa; @@ -175,9 +167,11 @@ mrb_str_buf_new(mrb_state *mrb, int capa) } static void -str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, int len) +str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, size_t len) { - long capa, total, off = -1; + mrb_int capa; + mrb_int total; + ptrdiff_t off = -1; str_modify(mrb, s); if (ptr >= s->ptr && ptr <= s->ptr + s->len) { @@ -185,13 +179,13 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, int len) } if (len == 0) return; capa = s->aux.capa; - if (s->len >= INT_MAX - len) { + if (s->len >= MRB_INT_MAX - len) { mrb_raise(mrb, E_ARGUMENT_ERROR, "string sizes too big"); } total = s->len+len; if (capa <= total) { while (total > capa) { - if (capa + 1 >= INT_MAX / 2) { + if (capa + 1 >= MRB_INT_MAX / 2) { capa = (total + 4095) / 4096; break; } @@ -208,7 +202,7 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, int len) } mrb_value -mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, int len) +mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len) { if (len == 0) return str; str_buf_cat(mrb, mrb_str_ptr(str), ptr, len); @@ -216,7 +210,7 @@ mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, int len) } mrb_value -mrb_str_new(mrb_state *mrb, const char *p, int len) +mrb_str_new(mrb_state *mrb, const char *p, size_t len) { struct RString *s; @@ -224,17 +218,6 @@ mrb_str_new(mrb_state *mrb, const char *p, int len) return mrb_obj_value(s); } -mrb_value -mrb_str_new2(mrb_state *mrb, const char *ptr) -{ - struct RString *s; - if (!ptr) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "NULL pointer given"); - } - s = str_new(mrb, ptr, strlen(ptr)); - return mrb_obj_value(s); -} - /* * call-seq: (Caution! NULL string) * String.new(str="") => new_str @@ -246,11 +229,23 @@ mrb_value mrb_str_new_cstr(mrb_state *mrb, const char *p) { struct RString *s; - int len = strlen(p); + size_t len; + + if (p) { + len = strlen(p); + if ((mrb_int)len < 0) { + mrb_raise(mrb, E_ARGUMENT_ERROR, "argument too big"); + } + } + else { + len = 0; + } s = mrb_obj_alloc_string(mrb); s->ptr = (char *)mrb_malloc(mrb, len+1); - memcpy(s->ptr, p, len); + if (p) { + memcpy(s->ptr, p, len); + } s->ptr[len] = 0; s->len = len; s->aux.capa = len; @@ -263,6 +258,10 @@ mrb_str_to_cstr(mrb_state *mrb, mrb_value str0) { mrb_value str; + if (!mrb_string_p(str0)) { + mrb_raise(mrb, E_TYPE_ERROR, "expected String"); + } + str = mrb_str_new(mrb, RSTRING_PTR(str0), RSTRING_LEN(str0)); if (strlen(RSTRING_PTR(str)) != RSTRING_LEN(str)) { mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte"); @@ -302,7 +301,7 @@ mrb_str_literal(mrb_state *mrb, mrb_value str) struct RString *s, *orig; mrb_shared_string *shared; - s = str_alloc(mrb, mrb->string_class); + s = mrb_obj_alloc_string(mrb); orig = mrb_str_ptr(str); if (!(orig->flags & MRB_STR_SHARED)) { str_make_shared(mrb, mrb_str_ptr(str)); @@ -311,6 +310,7 @@ mrb_str_literal(mrb_state *mrb, mrb_value str) shared->refcnt++; s->ptr = shared->ptr; s->len = shared->len; + s->aux.capa = 0; s->aux.shared = shared; s->flags |= MRB_STR_SHARED; @@ -446,7 +446,7 @@ mrb_str_times(mrb_state *mrb, mrb_value self) if (times < 0) { mrb_raise(mrb, E_ARGUMENT_ERROR, "negative argument"); } - if (times && INT_MAX/times < RSTRING_LEN(self)) { + if (times && MRB_INT_MAX / times < RSTRING_LEN(self)) { mrb_raise(mrb, E_ARGUMENT_ERROR, "argument too big"); } @@ -557,8 +557,9 @@ mrb_str_cmp_m(mrb_state *mrb, mrb_value str1) static int str_eql(mrb_state *mrb, const mrb_value str1, const mrb_value str2) { - const long len = RSTRING_LEN(str1); + const size_t len = RSTRING_LEN(str1); + /* assert(SIZE_MAX >= MRB_INT_MAX) */ if (len != RSTRING_LEN(str2)) return FALSE; if (memcmp(RSTRING_PTR(str1), RSTRING_PTR(str2), len) == 0) return TRUE; @@ -657,8 +658,8 @@ mrb_str_match(mrb_state *mrb, mrb_value self/* x */) return mrb_nil_value(); } -static inline long -mrb_memsearch_qs(const unsigned char *xs, long m, const unsigned char *ys, long n) +static inline mrb_int +mrb_memsearch_qs(const unsigned char *xs, mrb_int m, const unsigned char *ys, mrb_int n) { const unsigned char *x = xs, *xe = xs + m; const unsigned char *y = ys; @@ -677,8 +678,8 @@ mrb_memsearch_qs(const unsigned char *xs, long m, const unsigned char *ys, long return -1; } -static int -mrb_memsearch(const void *x0, int m, const void *y0, int n) +static mrb_int +mrb_memsearch(const void *x0, mrb_int m, const void *y0, mrb_int n) { const unsigned char *x = (const unsigned char *)x0, *y = (const unsigned char *)y0; @@ -705,7 +706,8 @@ mrb_str_index(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int offset) { mrb_int pos; char *s, *sptr; - int len, slen; + mrb_int len, slen; + len = RSTRING_LEN(str); slen = RSTRING_LEN(sub); if (offset < 0) { @@ -739,7 +741,7 @@ mrb_str_dup(mrb_state *mrb, mrb_value str) static mrb_value mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value indx) { - long idx; + mrb_int idx; if (!strcmp(_obj_classname(mrb, indx), REGEXP_CLASS)) { mrb_raise(mrb, E_NOTIMP_ERROR, "Regexp Class not implemented"); @@ -920,7 +922,8 @@ mrb_str_chomp_bang(mrb_state *mrb, mrb_value str) mrb_value rs; mrb_int newline; char *p, *pp; - long len, rslen; + mrb_int rslen; + mrb_int len; struct RString *s = mrb_str_ptr(str); str_modify(mrb, s); @@ -1157,7 +1160,7 @@ mrb_str_eql(mrb_state *mrb, mrb_value self) } static mrb_value -mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len) +mrb_str_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len) { struct RString *orig, *s; mrb_shared_string *shared; @@ -1176,7 +1179,7 @@ mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len) } mrb_value -mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, int len) +mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len) { mrb_value str2; @@ -1267,7 +1270,7 @@ mrb_str_hash(mrb_state *mrb, mrb_value str) { /* 1-8-7 */ struct RString *s = mrb_str_ptr(str); - long len = s->len; + mrb_int len = s->len; char *p = s->ptr; mrb_int key = 0; @@ -1381,7 +1384,7 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str) switch (mrb_type(sub)) { case MRB_TT_FIXNUM: { int c = mrb_fixnum(sub); - long len = RSTRING_LEN(str); + mrb_int len = RSTRING_LEN(str); unsigned char *p = (unsigned char*)RSTRING_PTR(str); for (;pos<len;pos++) { @@ -1404,10 +1407,10 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str) case MRB_TT_STRING: pos = mrb_str_index(mrb, str, sub, pos); break; - } + } - if (pos == -1) return mrb_nil_value(); - return mrb_fixnum_value(pos); + if (pos == -1) return mrb_nil_value(); + return mrb_fixnum_value(pos); } #define STR_REPLACE_SHARED_MIN 10 @@ -1637,7 +1640,7 @@ mrb_str_rindex(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos) char *s, *sbeg, *t; struct RString *ps = mrb_str_ptr(str); struct RString *psub = mrb_str_ptr(sub); - long len = psub->len; + mrb_int len = psub->len; /* substring longer than string */ if (ps->len < len) return -1; @@ -1661,15 +1664,6 @@ mrb_str_rindex(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos) } } -#ifdef INCLUDE_ENCODING -/* byte offset to char offset */ -int -mrb_str_sublen(mrb_state *mrb, mrb_value str, long pos) -{ - return pos; -} -#endif //INCLUDE_ENCODING - /* 15.2.10.5.31 */ /* * call-seq: @@ -1728,7 +1722,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str) switch (mrb_type(sub)) { case MRB_TT_FIXNUM: { int c = mrb_fixnum(sub); - long len = RSTRING_LEN(str); + mrb_int len = RSTRING_LEN(str); unsigned char *p = (unsigned char*)RSTRING_PTR(str); for (pos=len;pos>=0;pos--) { @@ -1865,7 +1859,9 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) int argc; mrb_value spat = mrb_nil_value(); enum {awk, string, regexp} split_type = string; - long beg, end, i = 0, lim_p; + long i = 0, lim_p; + mrb_int beg; + mrb_int end; mrb_int lim = 0; mrb_value result, tmp; @@ -1934,7 +1930,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) char *ptr = RSTRING_PTR(str); char *temp = ptr; char *eptr = RSTRING_END(str); - long slen = RSTRING_LEN(spat); + mrb_int slen = RSTRING_LEN(spat); if (slen == 0) { int ai = mrb_gc_arena_save(mrb); @@ -1972,7 +1968,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) mrb_ary_push(mrb, result, tmp); } if (!lim_p && lim == 0) { - long len; + mrb_int len; while ((len = RARRAY_LEN(result)) > 0 && (tmp = RARRAY_PTR(result)[len-1], RSTRING_LEN(tmp) == 0)) mrb_ary_pop(mrb, result); @@ -2054,7 +2050,8 @@ mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck) char *end; char sign = 1; int c; - unsigned long val; + unsigned int n; + mrb_int val; #undef ISDIGIT #define ISDIGIT(c) ('0' <= (c) && (c) <= '9') @@ -2158,19 +2155,18 @@ mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck) return mrb_fixnum_value(0); } - val = strtoul((char*)str, &end, base); - + n = strtoul((char*)str, &end, base); + if (n > MRB_INT_MAX) { + mrb_raisef(mrb, E_ARGUMENT_ERROR, "string (%s) too big for integer", str); + } + val = n; if (badcheck) { if (end == str) goto bad; /* no number */ while (*end && ISSPACE(*end)) end++; if (*end) goto bad; /* trailing garbage */ } - if (sign) return mrb_fixnum_value(val); - else { - long result = -(long)val; - return mrb_fixnum_value(result); - } + return mrb_fixnum_value(sign ? val : -val); bad: mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid string for number(%s)", str); /* not reached */ @@ -2440,7 +2436,7 @@ mrb_str_upcase(mrb_state *mrb, mrb_value self) mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str) { - long len; + mrb_int len; const char *p, *pend; char *q; struct RString *result; @@ -2542,7 +2538,7 @@ mrb_str_dump(mrb_state *mrb, mrb_value str) } mrb_value -mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, long len) +mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, mrb_int len) { if (len < 0) { mrb_raise(mrb, E_ARGUMENT_ERROR, "negative string size (or size too big)"); diff --git a/src/symbol.c b/src/symbol.c index 72a5bea6b..3993cd37e 100644 --- a/src/symbol.c +++ b/src/symbol.c @@ -10,10 +10,11 @@ #include "mruby/string.h" #include <ctype.h> +#include <limits.h> /* ------------------------------------------------------ */ typedef struct symbol_name { - int len; + size_t len; const char *name; } symbol_name; @@ -35,7 +36,7 @@ KHASH_DECLARE(n2s, symbol_name, mrb_sym, 1) KHASH_DEFINE (n2s, symbol_name, mrb_sym, 1, sym_hash_func, sym_hash_equal) /* ------------------------------------------------------ */ mrb_sym -mrb_intern2(mrb_state *mrb, const char *name, int len) +mrb_intern2(mrb_state *mrb, const char *name, size_t len) { khash_t(n2s) *h = mrb->name2sym; symbol_name sname; @@ -43,6 +44,7 @@ mrb_intern2(mrb_state *mrb, const char *name, int len) mrb_sym sym; char *p; + if (len < 0) len = 0; sname.len = len; sname.name = name; k = kh_get(n2s, h, sname); @@ -72,8 +74,9 @@ mrb_intern_str(mrb_state *mrb, mrb_value str) return mrb_intern2(mrb, RSTRING_PTR(str), RSTRING_LEN(str)); } +/* lenp must be a pointer to a size_t variable */ const char* -mrb_sym2name_len(mrb_state *mrb, mrb_sym sym, int *lenp) +mrb_sym2name_len(mrb_state *mrb, mrb_sym sym, size_t *lenp) { khash_t(n2s) *h = mrb->name2sym; khiter_t k; @@ -178,7 +181,7 @@ mrb_sym_to_s(mrb_state *mrb, mrb_value sym) { mrb_sym id = mrb_symbol(sym); const char *p; - int len; + size_t len; p = mrb_sym2name_len(mrb, id, &len); return mrb_str_new(mrb, p, len); @@ -329,7 +332,7 @@ sym_inspect(mrb_state *mrb, mrb_value sym) { mrb_value str; const char *name; - int len; + size_t len; mrb_sym id = mrb_symbol(sym); name = mrb_sym2name_len(mrb, id, &len); @@ -346,7 +349,7 @@ sym_inspect(mrb_state *mrb, mrb_value sym) const char* mrb_sym2name(mrb_state *mrb, mrb_sym sym) { - int len; + size_t len; const char *name = mrb_sym2name_len(mrb, sym, &len); if (!name) return NULL; @@ -374,7 +377,8 @@ sym_cmp(mrb_state *mrb, mrb_value s1) if (sym1 == sym2) return mrb_fixnum_value(0); else { const char *p1, *p2; - int len, len1, len2, retval; + int retval; + size_t len, len1, len2; p1 = mrb_sym2name_len(mrb, sym1, &len1); p2 = mrb_sym2name_len(mrb, sym2, &len2); diff --git a/src/variable.c b/src/variable.c index 8715505c3..850999042 100644 --- a/src/variable.c +++ b/src/variable.c @@ -520,7 +520,7 @@ inspect_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p) { mrb_value str = *(mrb_value*)p; const char *s; - int len; + size_t len; /* need not to show internal data */ if (RSTRING_PTR(str)[0] == '-') { /* first element */ @@ -548,6 +548,7 @@ mrb_obj_iv_inspect(mrb_state *mrb, struct RObject *obj) mrb_value str = mrb_sprintf(mrb, "-<%s:%p", cn, (void*)obj); iv_foreach(mrb, t, inspect_i, &str); + mrb_str_cat(mrb, str, ">", 1); return str; } return mrb_any_to_s(mrb, mrb_obj_value(obj)); @@ -586,7 +587,7 @@ iv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p) { mrb_value ary; const char* s; - int len; + size_t len; ary = *(mrb_value*)p; s = mrb_sym2name_len(mrb, sym, &len); @@ -630,7 +631,7 @@ cv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p) { mrb_value ary; const char* s; - int len; + size_t len; ary = *(mrb_value*)p; s = mrb_sym2name_len(mrb, sym, &len); @@ -55,12 +55,20 @@ The value below allows about 60000 recursive calls in the simplest case. */ #endif static inline void -stack_copy(mrb_value *dst, const mrb_value *src, size_t size) +stack_clear(mrb_value *from, size_t count) { - size_t i; + const mrb_value mrb_value_zero = { { 0 } }; + + while(count-- > 0) { + *from++ = mrb_value_zero; + } +} - for (i = 0; i < size; i++) { - dst[i] = src[i]; +static inline void +stack_copy(mrb_value *dst, const mrb_value *src, size_t size) +{ + while (size-- > 0) { + *dst++ = *src++; } } @@ -130,15 +138,14 @@ stack_extend(mrb_state *mrb, int room, int keep) } if (room > keep) { - int i; - for (i=keep; i<room; i++) { #ifndef MRB_NAN_BOXING - static const mrb_value mrb_value_zero = { { 0 } }; - mrb->stack[i] = mrb_value_zero; + stack_clear(&(mrb->stack[keep]), room - keep); #else + int i; + for (i=keep; i<room; i++) { SET_NIL_VALUE(mrb->stack[i]); -#endif } +#endif } } @@ -1061,7 +1068,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) stack = e->stack + 1; } if (r == 0) { - regs[a] = mrb_ary_new_elts(mrb, m1+m2, stack); + regs[a] = mrb_ary_new_from_values(mrb, m1+m2, stack); } else { mrb_value *pp = NULL; @@ -1149,7 +1156,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) memmove(®s[1], argv, sizeof(mrb_value)*(m1+o)); /* m1 + o */ } if (r) { /* r */ - regs[m1+o+1] = mrb_ary_new_elts(mrb, argc-m1-o-m2, argv+m1+o); + regs[m1+o+1] = mrb_ary_new_from_values(mrb, argc-m1-o-m2, argv+m1+o); } if (m2) { memmove(®s[m1+o+r+1], &argv[argc-m2], sizeof(mrb_value)*m2); @@ -1731,7 +1738,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self) int i; if (len > pre + post) { - regs[a++] = mrb_ary_new_elts(mrb, len - pre - post, ary->ptr+pre); + regs[a++] = mrb_ary_new_from_values(mrb, len - pre - post, ary->ptr+pre); while (post--) { regs[a++] = ary->ptr[len-post-1]; } diff --git a/tasks/mrbgem_spec.rake b/tasks/mrbgem_spec.rake index 5b01bc79b..649f99d0e 100644 --- a/tasks/mrbgem_spec.rake +++ b/tasks/mrbgem_spec.rake @@ -28,6 +28,8 @@ module MRuby attr_accessor :test_objs, :test_rbfiles, :test_args attr_accessor :test_preload + attr_accessor :bins + attr_block MRuby::Build::COMMANDS def initialize(name, &block) @@ -59,6 +61,8 @@ module MRuby @test_preload = 'test/assert.rb' @test_args = {} + @bins = [] + instance_eval(&@initializer) if !name || !licenses || !authors @@ -76,6 +80,10 @@ module MRuby define_gem_init_builder end + def self.bin=(bin) + @bins = [bin].flatten + end + def build_dir "#{build.build_dir}/mrbgems/#{name}" end diff --git a/tasks/mrbgems.rake b/tasks/mrbgems.rake index 17f266105..2d670227f 100644 --- a/tasks/mrbgems.rake +++ b/tasks/mrbgems.rake @@ -9,7 +9,7 @@ MRuby.each_target do # loader all gems self.libmruby << objfile("#{build_dir}/mrbgems/gem_init") file objfile("#{build_dir}/mrbgems/gem_init") => "#{build_dir}/mrbgems/gem_init.c" - file "#{build_dir}/mrbgems/gem_init.c" => MRUBY_CONFIGS.flatten do |t| + file "#{build_dir}/mrbgems/gem_init.c" => [MRUBY_CONFIG] do |t| FileUtils.mkdir_p "#{build_dir}/mrbgems" open(t.name, 'w') do |f| f.puts %Q[/*] diff --git a/tasks/mruby_build.rake b/tasks/mruby_build.rake index d0809cbdc..1afb95334 100644 --- a/tasks/mruby_build.rake +++ b/tasks/mruby_build.rake @@ -182,8 +182,9 @@ module MRuby puts " Binaries: #{@bins.join(', ')}" unless @bins.empty? unless @gems.empty? puts " Included Gems:" - @gems.map(&:name).each do |name| - puts " #{name}" + @gems.map do |gem| + puts " #{gem.name}" + puts " - Binaries: #{gem.bins.join(', ')}" unless gem.bins.empty? end end puts "================================================" diff --git a/tasks/mruby_build_commands.rake b/tasks/mruby_build_commands.rake index 3795b47d4..b647ccf98 100644 --- a/tasks/mruby_build_commands.rake +++ b/tasks/mruby_build_commands.rake @@ -78,9 +78,9 @@ module MRuby @out_ext = build.exts.object if build_dir.include? "mrbgems/" - generated_file_matcher = Regexp.new("^#{build_dir}/(.*)#{Regexp.escape out_ext}$") + generated_file_matcher = Regexp.new("^#{Regexp.escape build_dir}/(.*)#{Regexp.escape out_ext}$") else - generated_file_matcher = Regexp.new("^#{build_dir}/(?!mrbgems/.+/)(.*)#{Regexp.escape out_ext}$") + generated_file_matcher = Regexp.new("^#{Regexp.escape build_dir}/(?!mrbgems/.+/)(.*)#{Regexp.escape out_ext}$") end source_exts.each do |ext, compile| rule generated_file_matcher => [ diff --git a/tasks/mruby_build_gem.rake b/tasks/mruby_build_gem.rake index 69dd4cafc..24f53a501 100644 --- a/tasks/mruby_build_gem.rake +++ b/tasks/mruby_build_gem.rake @@ -1,7 +1,12 @@ module MRuby module LoadGems def gem(gemdir, &block) - gemdir = load_external_gem(gemdir) if gemdir.is_a?(Hash) + caller_dir = File.expand_path(File.dirname(/^(.*?):\d/.match(caller.first).to_a[1])) + if gemdir.is_a?(Hash) + gemdir = load_external_gem(gemdir) + else + gemdir = File.expand_path(gemdir, caller_dir) + end gemrake = File.join(gemdir, "mrbgem.rake") fail "Can't find #{gemrake}" unless File.exists?(gemrake) @@ -27,7 +32,7 @@ module MRuby return gemdir if File.exists?(gemdir) options = [params[:options]] || [] - options << "--branch \"#{params[:branch]}\"" if params[:tag] + options << "--branch \"#{params[:branch]}\"" if params[:branch] FileUtils.mkdir_p "build/mrbgems" git.run_clone gemdir, url, options diff --git a/test/driver.c b/test/driver.c index 5183145b4..4a7a7b25e 100644 --- a/test/driver.c +++ b/test/driver.c @@ -17,7 +17,8 @@ void mrb_init_mrbtest(mrb_state *); /* Print a short remark for the user */ -void print_hint(void) +static void +print_hint(void) { printf("mrbtest - Embeddable Ruby Test\n"); printf("\nThis is a very early version, please test and report errors.\n"); @@ -35,13 +36,31 @@ check_error(mrb_state *mrb) return mrb_fixnum_p(ko_test) && mrb_fixnum(ko_test) == 0 && mrb_fixnum_p(kill_test) && mrb_fixnum(kill_test) == 0; } +static int +eval_test(mrb_state *mrb) +{ + mrb_value return_value; + const char *prog = "report()"; + + /* evaluate the test */ + return_value = mrb_load_string(mrb, prog); + /* did an exception occur? */ + if (mrb->exc) { + mrb_p(mrb, return_value); + mrb->exc = 0; + return EXIT_FAILURE; + } + else if (!check_error(mrb)) { + return EXIT_FAILURE; + } + return EXIT_SUCCESS; +} + int main(int argc, char **argv) { mrb_state *mrb; - mrb_value return_value; - const char *prog = "report()"; - int ret = EXIT_SUCCESS; + int ret; print_hint(); @@ -58,17 +77,7 @@ main(int argc, char **argv) } mrb_init_mrbtest(mrb); - /* evaluate the test */ - return_value = mrb_load_string(mrb, prog); - /* did an exception occur? */ - if (mrb->exc) { - mrb_p(mrb, return_value); - mrb->exc = 0; - ret = EXIT_FAILURE; - } - else if (!check_error(mrb)) { - ret = EXIT_FAILURE; - } + ret = eval_test(mrb); mrb_close(mrb); return ret; diff --git a/tools/mirb/mirb.c b/tools/mirb/mirb.c index e20de629d..c20c788e4 100644 --- a/tools/mirb/mirb.c +++ b/tools/mirb/mirb.c @@ -132,7 +132,8 @@ is_code_block_open(struct mrb_parser_state *parser) } /* Print a short remark for the user */ -void print_hint(void) +static void +print_hint(void) { printf("mirb - Embeddable Interactive Ruby Shell\n"); printf("\nThis is a very early version, please test and report errors.\n"); diff --git a/tools/mrbc/mrbc.c b/tools/mrbc/mrbc.c index bc551fffc..09ab2ca1d 100644 --- a/tools/mrbc/mrbc.c +++ b/tools/mrbc/mrbc.c @@ -19,8 +19,8 @@ struct _args { char *filename; char *initname; char *ext; - int check_syntax : 1; - int verbose : 1; + mrb_bool check_syntax : 1; + mrb_bool verbose : 1; }; static void @@ -83,6 +83,12 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args) switch ((*argv)[1]) { case 'o': + if (outfile) { + printf("%s: An output file is already specified. (%s)\n", + *origargv, outfile); + result = -5; + goto exit; + } outfile = get_outfilename((*argv) + 2, ""); break; case 'B': diff --git a/tools/mruby/mruby.c b/tools/mruby/mruby.c index 9d6182238..c509c0d30 100644 --- a/tools/mruby/mruby.c +++ b/tools/mruby/mruby.c @@ -26,10 +26,10 @@ void mrb_show_copyright(mrb_state *); struct _args { FILE *rfp; char* cmdline; - int fname : 1; - int mrbfile : 1; - int check_syntax : 1; - int verbose : 1; + mrb_bool fname : 1; + mrb_bool mrbfile : 1; + mrb_bool check_syntax : 1; + mrb_bool verbose : 1; int argc; char** argv; }; @@ -52,7 +52,7 @@ usage(const char *name) printf("Usage: %s [switches] programfile\n", name); while(*p) - printf(" %s\n", *p++); + printf(" %s\n", *p++); } static int @@ -125,7 +125,6 @@ append_cmdline: exit(0); } else return -3; - return 0; default: return -4; } @@ -189,14 +188,14 @@ showcallinfo(mrb_state *mrb) if (irep->filename != NULL) filename = irep->filename; if (irep->lines != NULL) { - mrb_code *pc; + mrb_code *pc; - if (i+1 <= ciidx) { - pc = mrb->cibase[i+1].pc; - } - else { - pc = (mrb_code*)mrb_voidp(mrb_obj_iv_get(mrb, mrb->exc, mrb_intern(mrb, "lastpc"))); - } + if (i+1 <= ciidx) { + pc = mrb->cibase[i+1].pc; + } + else { + pc = (mrb_code*)mrb_voidp(mrb_obj_iv_get(mrb, mrb->exc, mrb_intern(mrb, "lastpc"))); + } if (irep->iseq <= pc && pc < irep->iseq + irep->ilen) { line = irep->lines[pc - irep->iseq - 1]; } @@ -211,19 +210,16 @@ showcallinfo(mrb_state *mrb) method = mrb_sym2name(mrb, ci->mid); if (method) { const char *cn = mrb_class_name(mrb, ci->proc->target_class); - + if (cn) { - printf("\t[%d] %s:%d:in %s%s%s\n", - i, filename, line, cn, sep, method); + printf("\t[%d] %s:%d:in %s%s%s\n", i, filename, line, cn, sep, method); } else { - printf("\t[%d] %s:%d:in %s\n", - i, filename, line, method); + printf("\t[%d] %s:%d:in %s\n", i, filename, line, method); } } else { - printf("\t[%d] %s:%d\n", - i, filename, line); + printf("\t[%d] %s:%d\n", i, filename, line); } } } |