void
parse_ioctl(int ioctype, void *iocdata)
{
switch (ioctype) {
case TCSETA:
parse_termio(ioctype, (struct termio *) iocdata);
break;
case TCSETAW:
parse_termio(ioctype, (struct termio *) iocdata);
break;
case TCSETAF:
parse_termio(ioctype, (struct termio *) iocdata);
break;
case TCSBRK:
parse_break((int *) iocdata);
break;
case TCFLSH:
parse_iocflush((int *) iocdata);
break;
case TCSETS:
parse_termios(ioctype, (struct termios *) iocdata);
break;
case TCSETSW:
parse_termios(ioctype, (struct termios *) iocdata);
break;
case TCSETSF:
parse_termios(ioctype, (struct termios *) iocdata);
break;
default:
sysmessage(MSG_WARNING, "Unsupported ioctl: %c %d\n",
(ioctype & IOCTYPE) >> 8, ioctype & 0xFF);
}
}
/** Parse statement.
*
* @param parse Parser object.
* @return New syntax tree node.
*/
stree_stat_t *parse_stat(parse_t *parse)
{
stree_stat_t *stat;
stree_vdecl_t *vdecl_s;
stree_if_t *if_s;
stree_switch_t *switch_s;
stree_while_t *while_s;
stree_for_t *for_s;
stree_raise_t *raise_s;
stree_break_t *break_s;
stree_return_t *return_s;
stree_wef_t *wef_s;
stree_exps_t *exp_s;
#ifdef DEBUG_PARSE_TRACE
printf("Parse statement.\n");
#endif
switch (lcur_lc(parse)) {
case lc_var:
vdecl_s = parse_vdecl(parse);
stat = stree_stat_new(st_vdecl);
stat->u.vdecl_s = vdecl_s;
break;
case lc_if:
if_s = parse_if(parse);
stat = stree_stat_new(st_if);
stat->u.if_s = if_s;
break;
case lc_switch:
switch_s = parse_switch(parse);
stat = stree_stat_new(st_switch);
stat->u.switch_s = switch_s;
break;
case lc_while:
while_s = parse_while(parse);
stat = stree_stat_new(st_while);
stat->u.while_s = while_s;
break;
case lc_for:
for_s = parse_for(parse);
stat = stree_stat_new(st_for);
stat->u.for_s = for_s;
break;
case lc_raise:
raise_s = parse_raise(parse);
stat = stree_stat_new(st_raise);
stat->u.raise_s = raise_s;
break;
case lc_break:
break_s = parse_break(parse);
stat = stree_stat_new(st_break);
stat->u.break_s = break_s;
break;
case lc_return:
return_s = parse_return(parse);
stat = stree_stat_new(st_return);
stat->u.return_s = return_s;
break;
case lc_do:
case lc_with:
wef_s = parse_wef(parse);
stat = stree_stat_new(st_wef);
stat->u.wef_s = wef_s;
break;
default:
exp_s = parse_exps(parse);
stat = stree_stat_new(st_exps);
stat->u.exp_s = exp_s;
break;
}
#ifdef DEBUG_PARSE_TRACE
printf("Parsed statement %p\n", stat);
#endif
return stat;
}
struct node *parse_factor(struct compiler *compiler)
{
switch (lexer_current(compiler))
{
case T_BEGIN:
return parse_begin(compiler);
case T_IF:
return parse_if(compiler);
case T_UNLESS:
return parse_unless(compiler);
case T_CASE:
return parse_case(compiler);
case T_CLASS:
return parse_class(compiler);
case T_MODULE:
return parse_module(compiler);
case T_DEF:
return parse_method(compiler);
case T_YIELD:
return parse_yield(compiler);
case T_RETURN:
return parse_return(compiler);
case T_BREAK:
return parse_break(compiler);
case T_NEXT:
return parse_next(compiler);
case T_REDO:
return parse_redo(compiler);
case T_SQUARE_OPEN:
{
struct node *result = alloc_node(compiler, N_ARRAY);
lexer_next(compiler);
if(lexer_current(compiler) == T_SQUARE_CLOSE)
result->left = 0;
else
result->left = parse_array_element(compiler);
lexer_match(compiler, T_SQUARE_CLOSE);
return result;
}
case T_STRING:
{
struct node *result = alloc_node(compiler, N_STRING);
result->left = (void *)lexer_token(compiler)->start;
lexer_next(compiler);
return result;
}
case T_STRING_START:
{
struct node *result = alloc_node(compiler, N_STRING_CONTINUE);
result->left = 0;
result->middle = (void *)lexer_token(compiler)->start;
lexer_next(compiler);
result->right = parse_statements(compiler);
while(lexer_current(compiler) == T_STRING_CONTINUE)
{
struct node *node = alloc_node(compiler, N_STRING_CONTINUE);
node->left = result;
node->middle = (void *)lexer_token(compiler)->start;
lexer_next(compiler);
node->right = parse_statements(compiler);
result = node;
}
if(lexer_require(compiler, T_STRING_END))
{
struct node *node = alloc_node(compiler, N_STRING_START);
node->left = result;
node->right = (void *)lexer_token(compiler)->start;
lexer_next(compiler);
return node;
}
return result;
}
case T_SELF:
{
lexer_next(compiler);
return &self_node;
}
case T_TRUE:
{
lexer_next(compiler);
return alloc_node(compiler, N_TRUE);
}
case T_FALSE:
{
lexer_next(compiler);
return alloc_node(compiler, N_FALSE);
}
case T_NIL:
{
lexer_next(compiler);
return &nil_node;
}
case T_NUMBER:
{
struct node *result = alloc_node(compiler, N_NUMBER);
char *text = get_token_str(lexer_token(compiler));
result->left = (void* )atoi(text);
lexer_next(compiler);
return result;
}
case T_IVAR:
{
rt_value symbol = rt_symbol_from_lexer(compiler);
lexer_next(compiler);
switch (lexer_current(compiler))
{
case T_ASSIGN_ADD:
case T_ASSIGN_SUB:
case T_ASSIGN_MUL:
case T_ASSIGN_DIV:
{
struct node *result;
enum token_type op_type = lexer_current(compiler) - OP_TO_ASSIGN;
lexer_next(compiler);
result = alloc_node(compiler, N_IVAR_ASSIGN);
result->right = alloc_node(compiler, N_BINARY_OP);
result->right->op = op_type;
result->right->left = alloc_node(compiler, N_IVAR);
result->right->left->left = (void *)symbol;
result->right->right = parse_expression(compiler);
result->left = (void *)symbol;
return result;
}
case T_ASSIGN:
{
struct node *result;
lexer_next(compiler);
result = alloc_node(compiler, N_IVAR_ASSIGN);
result->left = (void *)symbol;
result->right = parse_expression(compiler);
return result;
}
default:
{
struct node *result = alloc_node(compiler, N_IVAR);
result->left = (void *)symbol;
return result;
}
}
}
case T_IDENT:
return parse_identifier(compiler);
case T_EXT_IDENT:
return parse_call(compiler, 0, &self_node, false);
case T_PARAM_OPEN:
{
lexer_next(compiler);
struct node *result = parse_statements(compiler);
lexer_match(compiler, T_PARAM_CLOSE);
return result;
}
default:
{
COMPILER_ERROR(compiler, "Expected expression but found %s", token_type_names[lexer_current(compiler)]);
lexer_next(compiler);
return 0;
}
}
}
bool Parser::parse_statement(StatementList *list)
{
lexer.identify_keywords();
switch(lexeme())
{
case Lexeme::KW_IF:
parse_if(list);
break;
case Lexeme::KW_WHILE:
parse_while(list);
break;
case Lexeme::KW_DO:
parse_do(list);
parse_terminator();
break;
case Lexeme::KW_RETURN:
parse_return(list);
parse_terminator();
break;
case Lexeme::KW_BREAK:
parse_break(list);
parse_terminator();
break;
case Lexeme::KW_CONTINUE:
parse_continue(list);
parse_terminator();
break;
case Lexeme::KW_CONST:
step();
parse_local(true, parse_expression(), list);
parse_terminator();
break;
case Lexeme::BRACET_OPEN:
list->append(parse_block<true, false>(Scope::EMPTY));
break;
case Lexeme::SEMICOLON:
step();
break;
case Lexeme::END:
case Lexeme::BRACET_CLOSE:
return false;
default:
if(is_expression(lexeme()))
{
ExpressionNode *node = parse_expression();
if(lexeme() == Lexeme::IDENT && node->is_type_name(document, false))
parse_local(false, node, list);
else
list->append(node);
parse_terminator();
}
else
return false;
}
return true;
}
