1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
/*
** mirb - Embeddable Interactive Ruby Shell
**
** This program takes code from the user in
** an interactive way and executes it
** immediately. It's a REPL...
*/
#include <string.h>
#include <stdbool.h>
#include <unistd.h>
#include <fcntl.h>
#include <mruby.h>
#include <mruby/proc.h>
#include <mruby/data.h>
#include <compile.h>
/* Guess if the user might want to enter more
* or if he wants an evaluation of his code now */
bool is_code_block_open(struct mrb_parser_state *parser) {
bool code_block_open = false;
switch (parser->lstate) {
// all states which need more code
case EXPR_BEG:
// an expression was just started,
// we can't end it like this
code_block_open = true;
break;
case EXPR_DOT:
// a message dot was the last token,
// there has to come more
code_block_open = true;
break;
case EXPR_CLASS:
// a class keyword is not enough!
// we need also a name of the class
code_block_open = true;
break;
case EXPR_FNAME:
// a method name is necessary
code_block_open = true;
break;
case EXPR_VALUE:
// if, elsif, etc. without condition
code_block_open = true;
break;
// now all the states which are closed
case EXPR_ARG:
// an argument is the last token
code_block_open = false;
break;
case EXPR_CMDARG:
code_block_open = false;
break;
// all states which are unsure
case EXPR_END:
// an expression was ended
break;
case EXPR_ENDARG:
// closing parenthese
break;
case EXPR_ENDFN:
// definition end
break;
case EXPR_MID:
// jump keyword like break, return, ...
break;
case EXPR_MAX_STATE:
// don't know what to do with this token
break;
default:
// this state is unexpected!
break;
}
if (!code_block_open) {
// based on the last parser state the code
// block seems to be closed
// now check if parser error are available
if (0 < parser->nerr) {
// a parser error occur, we have to check if
// we need to read one more line or if there is
// a different issue which we have to show to
// the user
if (strcmp(parser->error_buffer[0].message,
"syntax error, unexpected $end, expecting ';' or '\\n'") == 0) {
code_block_open = true;
} else if (strcmp(parser->error_buffer[0].message,
"syntax error, unexpected $end, expecting keyword_end") == 0) {
code_block_open = true;
} else if (strcmp(parser->error_buffer[0].message,
"syntax error, unexpected $end, expecting '<' or ';' or '\\n'") == 0) {
code_block_open = true;
} else if (strcmp(parser->error_buffer[0].message,
"syntax error, unexpected keyword_end") == 0) {
code_block_open = true;
} else if (strcmp(parser->error_buffer[0].message,
"syntax error, unexpected $end, expecting keyword_then or ';' or '\\n'") == 0) {
code_block_open = true;
} else if (strcmp(parser->error_buffer[0].message,
"syntax error, unexpected tREGEXP_BEG") == 0) {
code_block_open = true;
}
}
} else {
// last parser state suggest that this code
// block is open, WE NEED MORE CODE!!
}
return code_block_open;
}
/* Print a short remark for the user */
void print_hint(void)
{
printf("mirb - Embeddable Interactive Ruby Shell\n");
printf("\nThis is a very early version, please test and report errors.\n");
printf("Thanks :)\n\n");
}
/* Print the command line prompt of the REPL */
void print_cmdline(bool code_block_open) {
if (code_block_open) {
printf("* ");
} else {
printf("> ");
}
}
int main(void)
{
char last_char, ruby_code[1024], last_code_line[1024];
int char_index;
struct mrb_parser_state *parser;
mrb_state *mrb_interpreter;
mrb_value mrb_return_value;
int byte_code;
bool code_block_open = false;
print_hint();
// new interpreter instance
mrb_interpreter = mrb_open();
memset(ruby_code, 0, sizeof(*ruby_code));
memset(last_code_line, 0, sizeof(*last_code_line));
while (true) {
print_cmdline(code_block_open);
char_index = 0;
while ((last_char = getchar()) != '\n') {
if (last_char == EOF) break;
last_code_line[char_index++] = last_char;
}
if (last_char == EOF) {
printf("\n");
break;
}
last_code_line[char_index] = '\0';
if (strcmp(last_code_line, "exit") == 0) {
if (code_block_open) {
// cancel the current block and reset
code_block_open = false;
memset(ruby_code, 0, sizeof(*ruby_code));
memset(last_code_line, 0, sizeof(*last_code_line));
continue;
} else {
// quit the program
break;
}
} else {
if (code_block_open) {
strcat(ruby_code, "\n");
strcat(ruby_code, last_code_line);
} else {
memset(ruby_code, 0, sizeof(*ruby_code));
strcat(ruby_code, last_code_line);
}
// parse code
parser = mrb_parse_nstring_ext(mrb_interpreter, ruby_code, strlen(ruby_code));
code_block_open = is_code_block_open(parser);
if (code_block_open) {
// no evaluation of code
} else {
if (0 < parser->nerr) {
// syntax error
printf("%s\n", parser->error_buffer[0].message);
} else {
// generate bytecode
byte_code = mrb_generate_code(mrb_interpreter, parser->tree);
// evaluate the bytecode
mrb_return_value = mrb_run(mrb_interpreter,
// pass a proc for evaulation
mrb_proc_new(mrb_interpreter, mrb_interpreter->irep[byte_code]),
mrb_top_self(mrb_interpreter));
//mrb_nil_value());
// did an exception occur?
if (mrb_interpreter->exc) {
mrb_p(mrb_interpreter, mrb_obj_value(mrb_interpreter->exc));
mrb_interpreter->exc = 0;
} else {
// no
printf(" => ");
mrb_p(mrb_interpreter, mrb_return_value);
}
}
memset(ruby_code, 0, sizeof(*ruby_code));
memset(ruby_code, 0, sizeof(*last_code_line));
}
}
}
return 0;
}
|
