Skip to content

Commit a4d092b

Browse files
hurricuphurricup
committed
Added sources for ruby 3.0
1 parent efd5dbb commit a4d092b

108 files changed

Lines changed: 39199 additions & 0 deletions

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎lib/debase/ruby_core_source/ruby-3.0.0-p0/addr2line.h‎

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
#ifndef RUBY_ADDR2LINE_H
2+
#define RUBY_ADDR2LINE_H
3+
/**********************************************************************
4+
5+
addr2line.h -
6+
7+
$Author$
8+
9+
Copyright (C) 2010 Shinichiro Hamaji
10+
11+
**********************************************************************/
12+
13+
#if (defined(USE_ELF) || defined(HAVE_MACH_O_LOADER_H))
14+
15+
void
16+
rb_dump_backtrace_with_lines(int num_traces, void **traces);
17+
18+
#endif /* USE_ELF */
19+
20+
#endif /* RUBY_ADDR2LINE_H */

‎lib/debase/ruby_core_source/ruby-3.0.0-p0/builtin.h‎

Lines changed: 83 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,83 @@
1+
#ifndef BUILTIN_H_INCLUDED
2+
#define BUILTIN_H_INCLUDED
3+
4+
// invoke
5+
6+
struct rb_builtin_function {
7+
// for invocation
8+
const void * const func_ptr;
9+
const int argc;
10+
11+
// for load
12+
const int index;
13+
const char * const name;
14+
15+
// for jit
16+
void (*compiler)(FILE *, long, unsigned, bool);
17+
};
18+
19+
#define RB_BUILTIN_FUNCTION(_i, _name, _fname, _arity, _compiler) {\
20+
.name = #_name, \
21+
.func_ptr = (void *)_fname, \
22+
.argc = _arity, \
23+
.index = _i, \
24+
.compiler = _compiler, \
25+
}
26+
27+
void rb_load_with_builtin_functions(const char *feature_name, const struct rb_builtin_function *table);
28+
29+
#ifndef rb_execution_context_t
30+
typedef struct rb_execution_context_struct rb_execution_context_t;
31+
#define rb_execution_context_t rb_execution_context_t
32+
#endif
33+
34+
/* The following code is generated by the following Ruby script:
35+
36+
16.times{|i|
37+
args = (i > 0 ? ', ' : '') + (0...i).map{"VALUE"}.join(', ')
38+
puts "static inline void rb_builtin_function_check_arity#{i}(VALUE (*f)(rb_execution_context_t *ec, VALUE self#{args})){}"
39+
}
40+
*/
41+
42+
static inline void rb_builtin_function_check_arity0(VALUE (*f)(rb_execution_context_t *ec, VALUE self)){}
43+
static inline void rb_builtin_function_check_arity1(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE)){}
44+
static inline void rb_builtin_function_check_arity2(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE)){}
45+
static inline void rb_builtin_function_check_arity3(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE)){}
46+
static inline void rb_builtin_function_check_arity4(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE)){}
47+
static inline void rb_builtin_function_check_arity5(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE)){}
48+
static inline void rb_builtin_function_check_arity6(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
49+
static inline void rb_builtin_function_check_arity7(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
50+
static inline void rb_builtin_function_check_arity8(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
51+
static inline void rb_builtin_function_check_arity9(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
52+
static inline void rb_builtin_function_check_arity10(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
53+
static inline void rb_builtin_function_check_arity11(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
54+
static inline void rb_builtin_function_check_arity12(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
55+
static inline void rb_builtin_function_check_arity13(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
56+
static inline void rb_builtin_function_check_arity14(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
57+
static inline void rb_builtin_function_check_arity15(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
58+
59+
VALUE rb_vm_lvar_exposed(rb_execution_context_t *ec, int index);
60+
61+
// __builtin_inline!
62+
63+
PUREFUNC(static inline VALUE rb_vm_lvar(rb_execution_context_t *ec, int index));
64+
65+
static inline VALUE
66+
rb_vm_lvar(rb_execution_context_t *ec, int index)
67+
{
68+
#if VM_CORE_H_EC_DEFINED
69+
return ec->cfp->ep[index];
70+
#else
71+
return rb_vm_lvar_exposed(ec, index);
72+
#endif
73+
}
74+
75+
// dump/load
76+
77+
struct builtin_binary {
78+
const char *feature; // feature name
79+
const unsigned char *bin; // binary by ISeq#to_binary
80+
size_t bin_size;
81+
};
82+
83+
#endif // BUILTIN_H_INCLUDED

‎lib/debase/ruby_core_source/ruby-3.0.0-p0/ccan/build_assert/build_assert.h‎

Lines changed: 40 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
2+
#ifndef CCAN_BUILD_ASSERT_H
3+
#define CCAN_BUILD_ASSERT_H
4+
5+
/**
6+
* BUILD_ASSERT - assert a build-time dependency.
7+
* @cond: the compile-time condition which must be true.
8+
*
9+
* Your compile will fail if the condition isn't true, or can't be evaluated
10+
* by the compiler. This can only be used within a function.
11+
*
12+
* Example:
13+
* #include <stddef.h>
14+
* ...
15+
* static char *foo_to_char(struct foo *foo)
16+
* {
17+
* // This code needs string to be at start of foo.
18+
* BUILD_ASSERT(offsetof(struct foo, string) == 0);
19+
* return (char *)foo;
20+
* }
21+
*/
22+
#define BUILD_ASSERT(cond) \
23+
do { (void) sizeof(char [1 - 2*!(cond)]); } while(0)
24+
25+
/**
26+
* BUILD_ASSERT_OR_ZERO - assert a build-time dependency, as an expression.
27+
* @cond: the compile-time condition which must be true.
28+
*
29+
* Your compile will fail if the condition isn't true, or can't be evaluated
30+
* by the compiler. This can be used in an expression: its value is "0".
31+
*
32+
* Example:
33+
* #define foo_to_char(foo) \
34+
* ((char *)(foo) \
35+
* + BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0))
36+
*/
37+
#define BUILD_ASSERT_OR_ZERO(cond) \
38+
(sizeof(char [1 - 2*!(cond)]) - 1)
39+
40+
#endif /* CCAN_BUILD_ASSERT_H */

‎lib/debase/ruby_core_source/ruby-3.0.0-p0/ccan/check_type/check_type.h‎

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,63 @@
1+
/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
2+
#ifndef CCAN_CHECK_TYPE_H
3+
#define CCAN_CHECK_TYPE_H
4+
5+
/**
6+
* check_type - issue a warning or build failure if type is not correct.
7+
* @expr: the expression whose type we should check (not evaluated).
8+
* @type: the exact type we expect the expression to be.
9+
*
10+
* This macro is usually used within other macros to try to ensure that a macro
11+
* argument is of the expected type. No type promotion of the expression is
12+
* done: an unsigned int is not the same as an int!
13+
*
14+
* check_type() always evaluates to 0.
15+
*
16+
* If your compiler does not support typeof, then the best we can do is fail
17+
* to compile if the sizes of the types are unequal (a less complete check).
18+
*
19+
* Example:
20+
* // They should always pass a 64-bit value to _set_some_value!
21+
* #define set_some_value(expr) \
22+
* _set_some_value((check_type((expr), uint64_t), (expr)))
23+
*/
24+
25+
/**
26+
* check_types_match - issue a warning or build failure if types are not same.
27+
* @expr1: the first expression (not evaluated).
28+
* @expr2: the second expression (not evaluated).
29+
*
30+
* This macro is usually used within other macros to try to ensure that
31+
* arguments are of identical types. No type promotion of the expressions is
32+
* done: an unsigned int is not the same as an int!
33+
*
34+
* check_types_match() always evaluates to 0.
35+
*
36+
* If your compiler does not support typeof, then the best we can do is fail
37+
* to compile if the sizes of the types are unequal (a less complete check).
38+
*
39+
* Example:
40+
* // Do subtraction to get to enclosing type, but make sure that
41+
* // pointer is of correct type for that member.
42+
* #define container_of(mbr_ptr, encl_type, mbr) \
43+
* (check_types_match((mbr_ptr), &((encl_type *)0)->mbr), \
44+
* ((encl_type *) \
45+
* ((char *)(mbr_ptr) - offsetof(enclosing_type, mbr))))
46+
*/
47+
#if HAVE_TYPEOF
48+
#define check_type(expr, type) \
49+
((typeof(expr) *)0 != (type *)0)
50+
51+
#define check_types_match(expr1, expr2) \
52+
((typeof(expr1) *)0 != (typeof(expr2) *)0)
53+
#else
54+
#include "ccan/build_assert/build_assert.h"
55+
/* Without typeof, we can only test the sizes. */
56+
#define check_type(expr, type) \
57+
BUILD_ASSERT_OR_ZERO(sizeof(expr) == sizeof(type))
58+
59+
#define check_types_match(expr1, expr2) \
60+
BUILD_ASSERT_OR_ZERO(sizeof(expr1) == sizeof(expr2))
61+
#endif /* HAVE_TYPEOF */
62+
63+
#endif /* CCAN_CHECK_TYPE_H */

‎lib/debase/ruby_core_source/ruby-3.0.0-p0/ccan/container_of/container_of.h‎

Lines changed: 142 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,142 @@
1+
/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
2+
#ifndef CCAN_CONTAINER_OF_H
3+
#define CCAN_CONTAINER_OF_H
4+
#include "ccan/check_type/check_type.h"
5+
6+
/**
7+
* container_of - get pointer to enclosing structure
8+
* @member_ptr: pointer to the structure member
9+
* @containing_type: the type this member is within
10+
* @member: the name of this member within the structure.
11+
*
12+
* Given a pointer to a member of a structure, this macro does pointer
13+
* subtraction to return the pointer to the enclosing type.
14+
*
15+
* Example:
16+
* struct foo {
17+
* int fielda, fieldb;
18+
* // ...
19+
* };
20+
* struct info {
21+
* int some_other_field;
22+
* struct foo my_foo;
23+
* };
24+
*
25+
* static struct info *foo_to_info(struct foo *foo)
26+
* {
27+
* return container_of(foo, struct info, my_foo);
28+
* }
29+
*/
30+
#define container_of(member_ptr, containing_type, member) \
31+
((containing_type *) \
32+
((char *)(member_ptr) \
33+
- container_off(containing_type, member)) \
34+
+ check_types_match(*(member_ptr), ((containing_type *)0)->member))
35+
36+
37+
/**
38+
* container_of_or_null - get pointer to enclosing structure, or NULL
39+
* @member_ptr: pointer to the structure member
40+
* @containing_type: the type this member is within
41+
* @member: the name of this member within the structure.
42+
*
43+
* Given a pointer to a member of a structure, this macro does pointer
44+
* subtraction to return the pointer to the enclosing type, unless it
45+
* is given NULL, in which case it also returns NULL.
46+
*
47+
* Example:
48+
* struct foo {
49+
* int fielda, fieldb;
50+
* // ...
51+
* };
52+
* struct info {
53+
* int some_other_field;
54+
* struct foo my_foo;
55+
* };
56+
*
57+
* static struct info *foo_to_info_allowing_null(struct foo *foo)
58+
* {
59+
* return container_of_or_null(foo, struct info, my_foo);
60+
* }
61+
*/
62+
static inline char *container_of_or_null_(void *member_ptr, size_t offset)
63+
{
64+
return member_ptr ? (char *)member_ptr - offset : NULL;
65+
}
66+
#define container_of_or_null(member_ptr, containing_type, member) \
67+
((containing_type *) \
68+
container_of_or_null_(member_ptr, \
69+
container_off(containing_type, member)) \
70+
+ check_types_match(*(member_ptr), ((containing_type *)0)->member))
71+
72+
/**
73+
* container_off - get offset to enclosing structure
74+
* @containing_type: the type this member is within
75+
* @member: the name of this member within the structure.
76+
*
77+
* Given a pointer to a member of a structure, this macro does
78+
* typechecking and figures out the offset to the enclosing type.
79+
*
80+
* Example:
81+
* struct foo {
82+
* int fielda, fieldb;
83+
* // ...
84+
* };
85+
* struct info {
86+
* int some_other_field;
87+
* struct foo my_foo;
88+
* };
89+
*
90+
* static struct info *foo_to_info(struct foo *foo)
91+
* {
92+
* size_t off = container_off(struct info, my_foo);
93+
* return (void *)((char *)foo - off);
94+
* }
95+
*/
96+
#define container_off(containing_type, member) \
97+
offsetof(containing_type, member)
98+
99+
/**
100+
* container_of_var - get pointer to enclosing structure using a variable
101+
* @member_ptr: pointer to the structure member
102+
* @container_var: a pointer of same type as this member's container
103+
* @member: the name of this member within the structure.
104+
*
105+
* Given a pointer to a member of a structure, this macro does pointer
106+
* subtraction to return the pointer to the enclosing type.
107+
*
108+
* Example:
109+
* static struct info *foo_to_i(struct foo *foo)
110+
* {
111+
* struct info *i = container_of_var(foo, i, my_foo);
112+
* return i;
113+
* }
114+
*/
115+
#if HAVE_TYPEOF
116+
#define container_of_var(member_ptr, container_var, member) \
117+
container_of(member_ptr, typeof(*container_var), member)
118+
#else
119+
#define container_of_var(member_ptr, container_var, member) \
120+
((void *)((char *)(member_ptr) - \
121+
container_off_var(container_var, member)))
122+
#endif
123+
124+
/**
125+
* container_off_var - get offset of a field in enclosing structure
126+
* @container_var: a pointer to a container structure
127+
* @member: the name of a member within the structure.
128+
*
129+
* Given (any) pointer to a structure and a its member name, this
130+
* macro does pointer subtraction to return offset of member in a
131+
* structure memory layout.
132+
*
133+
*/
134+
#if HAVE_TYPEOF
135+
#define container_off_var(var, member) \
136+
container_off(typeof(*var), member)
137+
#else
138+
#define container_off_var(var, member) \
139+
((const char *)&(var)->member - (const char *)(var))
140+
#endif
141+
142+
#endif /* CCAN_CONTAINER_OF_H */

0 commit comments

Comments
 (0)