ruby-prof 1.6.3-x64-mingw-ucrt → 1.7.0-x64-mingw-ucrt

data/ext/ruby_prof/rp_call_tree.c

@@ -480,7 +480,7 @@ static VALUE prof_call_tree_load(VALUE self, VALUE data)
     return data;
 }
 
-void rp_init_call_tree()
+void rp_init_call_tree(void)
 {
     /* CallTree */
     cRpCallTree = rb_define_class_under(mProf, "CallTree", rb_cObject);

data/ext/ruby_prof/rp_call_tree.h

@@ -42,6 +42,6 @@ prof_call_tree_t* prof_get_call_tree(VALUE self);
 VALUE prof_call_tree_wrap(prof_call_tree_t* call_tree);
 void prof_call_tree_free(prof_call_tree_t* call_tree);
 
-void rp_init_call_tree();
+void rp_init_call_tree(void);
 
 #endif //__RP_CALL_TREE_H__

data/ext/ruby_prof/rp_call_trees.c

@@ -21,7 +21,7 @@ prof_call_trees_t* prof_get_call_trees(VALUE self)
     return result;
 }
 
-prof_call_trees_t* prof_call_trees_create()
+prof_call_trees_t* prof_call_trees_create(void)
 {
     prof_call_trees_t* result = ALLOC(prof_call_trees_t);
     result->start = ALLOC_N(prof_call_tree_t*, INITIAL_CALL_TREES_SIZE);
@@ -279,7 +279,7 @@ VALUE prof_call_trees_load(VALUE self, VALUE data)
     return data;
 }
 
-void rp_init_call_trees()
+void rp_init_call_trees(void)
 {
     cRpCallTrees = rb_define_class_under(mProf, "CallTrees", rb_cObject);
     rb_undef_method(CLASS_OF(cRpCallTrees), "new");

data/ext/ruby_prof/rp_call_trees.h

@@ -18,8 +18,8 @@ typedef struct prof_call_trees_t
 } prof_call_trees_t;
 
 
-void rp_init_call_trees();
-prof_call_trees_t* prof_call_trees_create();
+void rp_init_call_trees(void);
+prof_call_trees_t* prof_call_trees_create(void);
 void prof_call_trees_free(prof_call_trees_t* call_trees);
 prof_call_trees_t* prof_get_call_trees(VALUE self);
 void prof_add_call_tree(prof_call_trees_t* call_trees, prof_call_tree_t* call_tree);

data/ext/ruby_prof/rp_measure_allocations.c

@@ -38,7 +38,7 @@ prof_measurer_t* prof_measurer_allocations(bool track_allocations)
     return measure;
 }
 
-void rp_init_measure_allocations()
+void rp_init_measure_allocations(void)
 {
     total_allocated_objects_key = ID2SYM(rb_intern("total_allocated_objects"));
     rb_define_const(mProf, "ALLOCATIONS", INT2NUM(MEASURE_ALLOCATIONS));

data/ext/ruby_prof/rp_measure_memory.c

@@ -1,46 +1,46 @@
-/* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
-   Please see the LICENSE file for copyright and distribution information */
-
-/* :nodoc: */
-
-#include "rp_measurement.h"
-
-static VALUE cMeasureMemory;
-
-static double measure_memory(rb_trace_arg_t* trace_arg)
-{
-    static double result = 0;
-
-    if (trace_arg)
-    {
-        // Only process creation of new objects
-        rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
-        if (event == RUBY_INTERNAL_EVENT_NEWOBJ)
-        {
-            // Don't count allocations of internal IMemo objects
-            VALUE object = rb_tracearg_object(trace_arg);
-            if (BUILTIN_TYPE(object) != T_IMEMO)
-                result += rb_obj_memsize_of(object);
-        }
-    }
-
-    return result;
-}
-
-prof_measurer_t* prof_measurer_memory(bool track_allocations)
-{
-  prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->mode = MEASURE_MEMORY;
-  measure->measure = measure_memory;
-  measure->multiplier = 1;
-  // Need to track allocations to get RUBY_INTERNAL_EVENT_NEWOBJ event
-  measure->track_allocations = true;
-  return measure;
-}
-
-void rp_init_measure_memory()
-{
-    rb_define_const(mProf, "MEMORY", INT2NUM(MEASURE_MEMORY));
-
-    cMeasureMemory = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
-}
+/* Copyright (C) 2005-2013 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+/* :nodoc: */
+
+#include "rp_measurement.h"
+
+static VALUE cMeasureMemory;
+
+static double measure_memory(rb_trace_arg_t* trace_arg)
+{
+    static double result = 0;
+
+    if (trace_arg)
+    {
+        // Only process creation of new objects
+        rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
+        if (event == RUBY_INTERNAL_EVENT_NEWOBJ)
+        {
+            // Don't count allocations of internal IMemo objects
+            VALUE object = rb_tracearg_object(trace_arg);
+            if (BUILTIN_TYPE(object) != T_IMEMO)
+                result += rb_obj_memsize_of(object);
+        }
+    }
+
+    return result;
+}
+
+prof_measurer_t* prof_measurer_memory(bool track_allocations)
+{
+  prof_measurer_t* measure = ALLOC(prof_measurer_t);
+  measure->mode = MEASURE_MEMORY;
+  measure->measure = measure_memory;
+  measure->multiplier = 1;
+  // Need to track allocations to get RUBY_INTERNAL_EVENT_NEWOBJ event
+  measure->track_allocations = true;
+  return measure;
+}
+
+void rp_init_measure_memory(void)
+{
+    rb_define_const(mProf, "MEMORY", INT2NUM(MEASURE_MEMORY));
+
+    cMeasureMemory = rb_define_class_under(mMeasure, "Allocations", rb_cObject);
+}

data/ext/ruby_prof/rp_measure_process_time.c

@@ -57,7 +57,7 @@ prof_measurer_t* prof_measurer_process_time(bool track_allocations)
     return measure;
 }
 
-void rp_init_measure_process_time()
+void rp_init_measure_process_time(void)
 {
     rb_define_const(mProf, "CLOCKS_PER_SEC", INT2NUM(CLOCKS_PER_SEC));
     rb_define_const(mProf, "PROCESS_TIME", INT2NUM(MEASURE_PROCESS_TIME));

data/ext/ruby_prof/rp_measure_wall_time.c

@@ -56,7 +56,7 @@ prof_measurer_t* prof_measurer_wall_time(bool track_allocations)
     return measure;
 }
 
-void rp_init_measure_wall_time()
+void rp_init_measure_wall_time(void)
 {
     rb_define_const(mProf, "WALL_TIME", INT2NUM(MEASURE_WALL_TIME));