1001 lines
22 KiB
C
1001 lines
22 KiB
C
/*
|
|
* script parser for finsh shell.
|
|
*
|
|
* COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
|
|
*
|
|
* This file is part of RT-Thread (http://www.rt-thread.org)
|
|
* Maintainer: bernard.xiong <bernard.xiong at gmail.com>
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2010-03-22 Bernard first version
|
|
*/
|
|
#include <finsh.h>
|
|
|
|
#include "finsh_token.h"
|
|
#include "finsh_node.h"
|
|
#include "finsh_error.h"
|
|
#include "finsh_parser.h"
|
|
#include "finsh_var.h"
|
|
|
|
/*
|
|
* the structure of abstract syntax tree:
|
|
* root____________
|
|
* | \
|
|
* child__ sibling__
|
|
* | \ | \
|
|
* child sibling child sibling
|
|
* ...
|
|
*/
|
|
static enum finsh_type proc_type(struct finsh_parser* self);
|
|
static int proc_identifier(struct finsh_parser* self, char* id);
|
|
static struct finsh_node* proc_variable_decl(struct finsh_parser* self);
|
|
static struct finsh_node* proc_expr(struct finsh_parser* self);
|
|
static struct finsh_node* proc_assign_expr(struct finsh_parser* self);
|
|
static struct finsh_node* proc_inclusive_or_expr(struct finsh_parser* self);
|
|
static struct finsh_node* proc_exclusive_or_expr(struct finsh_parser* self);
|
|
static struct finsh_node* proc_and_expr(struct finsh_parser* self);
|
|
static struct finsh_node* proc_shift_expr(struct finsh_parser* self);
|
|
static struct finsh_node* proc_additive_expr(struct finsh_parser* self);
|
|
static struct finsh_node* proc_multiplicative_expr(struct finsh_parser* self);
|
|
static struct finsh_node* proc_cast_expr(struct finsh_parser* self);
|
|
static struct finsh_node* proc_unary_expr(struct finsh_parser* self);
|
|
static struct finsh_node* proc_postfix_expr(struct finsh_parser* self);
|
|
static struct finsh_node* proc_primary_expr(struct finsh_parser* self);
|
|
static struct finsh_node* proc_param_list(struct finsh_parser* self);
|
|
static struct finsh_node* proc_expr_statement(struct finsh_parser* self);
|
|
static struct finsh_node* make_sys_node(u_char type, struct finsh_node* node1,
|
|
struct finsh_node* node2);
|
|
|
|
/* check token */
|
|
#define check_token(token, lex, type) if ( (token) != (type) ) \
|
|
{ \
|
|
finsh_error_set(FINSH_ERROR_INVALID_TOKEN); \
|
|
finsh_token_replay(lex); \
|
|
}
|
|
|
|
/* is the token a data type? */
|
|
#define is_base_type(token) ((token) == finsh_token_type_void \
|
|
|| (token) == finsh_token_type_char \
|
|
|| (token) == finsh_token_type_short \
|
|
|| (token) == finsh_token_type_int \
|
|
|| (token) == finsh_token_type_long)
|
|
|
|
/* get the next token */
|
|
#define next_token(token, lex) (token) = finsh_token_token(lex)
|
|
|
|
/* match a specified token */
|
|
#define match_token(token, lex, type) next_token(token, lex); \
|
|
check_token(token, lex, type)
|
|
|
|
/*
|
|
process for function and variable declaration.
|
|
decl_variable -> type declaration_list ';'
|
|
declarator_list -> declarator_list ',' declarator
|
|
| declarator
|
|
declarator -> identifier
|
|
| identifier ASSIGN expr_assign
|
|
*/
|
|
static struct finsh_node* proc_variable_decl(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
enum finsh_type type;
|
|
char id[FINSH_NAME_MAX + 1];
|
|
|
|
struct finsh_node *node;
|
|
struct finsh_node *end;
|
|
struct finsh_node *assign;
|
|
|
|
node = NULL;
|
|
end = NULL;
|
|
|
|
/* get type */
|
|
type = proc_type(self);
|
|
|
|
/*process id.*/
|
|
if (proc_identifier(self, id) == 0)
|
|
{
|
|
/* if add variable failed */
|
|
if (finsh_var_insert(id, type) < 0)
|
|
{
|
|
finsh_error_set(FINSH_ERROR_VARIABLE_EXIST);
|
|
}
|
|
}
|
|
|
|
next_token(token, &(self->token));
|
|
switch ( token )
|
|
{
|
|
case finsh_token_type_comma:/*',', it's a variable_list declaration.*/
|
|
if (proc_identifier(self, id) == 0)
|
|
{
|
|
/* if add variable failed */
|
|
if (finsh_var_insert(id, type) < 0)
|
|
{
|
|
finsh_error_set(FINSH_ERROR_VARIABLE_EXIST);
|
|
}
|
|
}
|
|
|
|
next_token(token, &(self->token));
|
|
if ( token == finsh_token_type_assign )
|
|
{
|
|
/* get the right side of assign expression */
|
|
assign = proc_assign_expr(self);
|
|
|
|
if (assign != NULL)
|
|
{
|
|
struct finsh_node* idnode;
|
|
|
|
idnode = finsh_node_new_id(id);
|
|
end = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign);
|
|
node = end;
|
|
|
|
next_token(token, &(self->token));
|
|
}
|
|
}
|
|
|
|
while ( token == finsh_token_type_comma )
|
|
{
|
|
if (proc_identifier(self, id) == 0)
|
|
{
|
|
/* if add variable failed */
|
|
if (finsh_var_insert(id, type) < 0)
|
|
{
|
|
finsh_error_set(FINSH_ERROR_VARIABLE_EXIST);
|
|
}
|
|
}
|
|
|
|
next_token(token, &(self->token));
|
|
if ( token == finsh_token_type_assign )
|
|
{
|
|
/* get the right side of assign expression */
|
|
assign = proc_assign_expr(self);
|
|
|
|
if (assign != NULL)
|
|
{
|
|
struct finsh_node* idnode;
|
|
|
|
idnode = finsh_node_new_id(id);
|
|
|
|
/* make assign expression node */
|
|
if (node != NULL)
|
|
{
|
|
finsh_node_sibling(end) = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign);
|
|
end = finsh_node_sibling(end);
|
|
}
|
|
else
|
|
{
|
|
end = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign);
|
|
node = end;
|
|
}
|
|
|
|
next_token(token, &(self->token));
|
|
}
|
|
}
|
|
}
|
|
|
|
check_token(token, &(self->token), finsh_token_type_semicolon);
|
|
return node;
|
|
|
|
case finsh_token_type_assign:/*'=', it's a variable with assign declaration.*/
|
|
{
|
|
struct finsh_node *idnode;
|
|
|
|
assign = proc_assign_expr(self);
|
|
if (assign != NULL)
|
|
{
|
|
idnode = finsh_node_new_id(id);
|
|
|
|
/* make assign expression node */
|
|
end = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign);
|
|
node = end;
|
|
|
|
next_token(token, &(self->token));
|
|
}
|
|
|
|
while ( token == finsh_token_type_comma )
|
|
{
|
|
if (proc_identifier(self, id) == 0)
|
|
{
|
|
/* if add variable failed */
|
|
if (finsh_var_insert(id, type) < 0)
|
|
{
|
|
finsh_error_set(FINSH_ERROR_VARIABLE_EXIST);
|
|
}
|
|
}
|
|
|
|
next_token(token, &(self->token));
|
|
if (token == finsh_token_type_assign)
|
|
{
|
|
/* get the right side of assign expression */
|
|
assign = proc_assign_expr(self);
|
|
|
|
if (assign != NULL)
|
|
{
|
|
idnode = finsh_node_new_id(id);
|
|
|
|
/* make assign expression node */
|
|
if (node != NULL)
|
|
{
|
|
finsh_node_sibling(end) = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign);
|
|
end = finsh_node_sibling(end);
|
|
}
|
|
else
|
|
{
|
|
end = make_sys_node(FINSH_NODE_SYS_ASSIGN, idnode, assign);
|
|
node = end;
|
|
}
|
|
|
|
next_token(token, &(self->token));
|
|
}
|
|
}
|
|
}
|
|
|
|
check_token(token, &(self->token), finsh_token_type_semicolon);
|
|
return node;
|
|
}
|
|
|
|
case finsh_token_type_semicolon:/*';', it's a variable declaration.*/
|
|
return node;
|
|
|
|
default:
|
|
finsh_error_set(FINSH_ERROR_EXPECT_TYPE);
|
|
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
type -> type_prefix type_basic | type_basic
|
|
type_prefix -> UNSIGNED
|
|
type_basic -> VOID
|
|
| CHAR
|
|
| SHORT
|
|
| INT
|
|
| STRING
|
|
*/
|
|
static enum finsh_type proc_type(struct finsh_parser* self)
|
|
{
|
|
enum finsh_type type;
|
|
enum finsh_token_type token;
|
|
|
|
/* set init type */
|
|
type = finsh_type_unknown;
|
|
|
|
next_token(token, &(self->token));
|
|
if ( is_base_type(token) ) /* base_type */
|
|
{
|
|
switch (token)
|
|
{
|
|
case finsh_token_type_void:
|
|
type = finsh_type_void;
|
|
break;
|
|
|
|
case finsh_token_type_char:
|
|
type = finsh_type_char;
|
|
break;
|
|
|
|
case finsh_token_type_short:
|
|
type = finsh_type_short;
|
|
break;
|
|
|
|
case finsh_token_type_int:
|
|
type = finsh_type_int;
|
|
break;
|
|
|
|
case finsh_token_type_long:
|
|
type = finsh_type_long;
|
|
break;
|
|
|
|
default:
|
|
goto __return;
|
|
}
|
|
}
|
|
else if ( token == finsh_token_type_unsigned ) /* unsigned base_type */
|
|
{
|
|
next_token(token, &(self->token));
|
|
if ( is_base_type(token) )
|
|
{
|
|
switch (token)
|
|
{
|
|
case finsh_token_type_char:
|
|
type = finsh_type_uchar;
|
|
break;
|
|
|
|
case finsh_token_type_short:
|
|
type = finsh_type_ushort;
|
|
break;
|
|
|
|
case finsh_token_type_int:
|
|
type = finsh_type_uint;
|
|
break;
|
|
|
|
case finsh_token_type_long:
|
|
type = finsh_type_ulong;
|
|
break;
|
|
|
|
default:
|
|
goto __return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
finsh_token_replay(&(self->token));
|
|
finsh_error_set(FINSH_ERROR_EXPECT_TYPE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
goto __return;
|
|
}
|
|
|
|
/* parse for pointer */
|
|
next_token(token, &(self->token));
|
|
if (token == finsh_token_type_mul)
|
|
{
|
|
switch (type)
|
|
{
|
|
case finsh_type_void:
|
|
type = finsh_type_voidp;
|
|
break;
|
|
|
|
case finsh_type_char:
|
|
case finsh_type_uchar:
|
|
type = finsh_type_charp;
|
|
break;
|
|
|
|
case finsh_type_short:
|
|
case finsh_type_ushort:
|
|
type = finsh_type_shortp;
|
|
break;
|
|
|
|
case finsh_type_int:
|
|
case finsh_type_uint:
|
|
type = finsh_type_intp;
|
|
break;
|
|
|
|
case finsh_type_long:
|
|
case finsh_type_ulong:
|
|
type = finsh_type_longp;
|
|
break;
|
|
|
|
default:
|
|
type = finsh_type_voidp;
|
|
break;
|
|
}
|
|
}
|
|
else finsh_token_replay(&(self->token));
|
|
|
|
return type;
|
|
|
|
__return:
|
|
finsh_token_replay(&(self->token));
|
|
finsh_error_set(FINSH_ERROR_UNKNOWN_TYPE);
|
|
|
|
return type;
|
|
}
|
|
|
|
/*
|
|
identifier -> IDENTIFIER
|
|
*/
|
|
static int proc_identifier(struct finsh_parser* self, char* id)
|
|
{
|
|
enum finsh_token_type token;
|
|
|
|
match_token(token, &(self->token), finsh_token_type_identifier);
|
|
|
|
strncpy(id, (char*)self->token.string, FINSH_NAME_MAX);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
statement_expr -> ';'
|
|
| expr ';'
|
|
*/
|
|
static struct finsh_node* proc_expr_statement(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node* expr;
|
|
|
|
expr = NULL;
|
|
next_token(token, &(self->token));
|
|
if ( token != finsh_token_type_semicolon )
|
|
{
|
|
finsh_token_replay(&(self->token));
|
|
expr = proc_expr(self);
|
|
|
|
match_token(token, &(self->token), finsh_token_type_semicolon);
|
|
}
|
|
|
|
return expr;
|
|
}
|
|
|
|
/*
|
|
expr -> expr_assign
|
|
*/
|
|
static struct finsh_node* proc_expr(struct finsh_parser* self)
|
|
{
|
|
return proc_assign_expr(self);
|
|
}
|
|
|
|
/*
|
|
expr_assign -> expr_inclusive_or
|
|
| expr_unary ASSIGN expr_assign
|
|
*/
|
|
static struct finsh_node* proc_assign_expr(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node* or;
|
|
struct finsh_node* assign;
|
|
|
|
or = proc_inclusive_or_expr(self);
|
|
|
|
next_token(token, &(self->token));
|
|
|
|
if (token == finsh_token_type_assign)
|
|
{
|
|
assign = proc_assign_expr(self);
|
|
|
|
return make_sys_node(FINSH_NODE_SYS_ASSIGN, or, assign);
|
|
}
|
|
else finsh_token_replay(&(self->token));
|
|
|
|
return or;
|
|
}
|
|
|
|
/*
|
|
expr_inclusive_or -> expr_exclusive_or
|
|
| expr_inclusive_or '|' expr_exclusive_or
|
|
*/
|
|
static struct finsh_node* proc_inclusive_or_expr(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node* xor;
|
|
struct finsh_node* xor_new;
|
|
|
|
xor = proc_exclusive_or_expr(self);
|
|
|
|
next_token(token, &(self->token));
|
|
while ( token == finsh_token_type_or )
|
|
{
|
|
xor_new = proc_exclusive_or_expr(self);
|
|
|
|
if (xor_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR);
|
|
else xor = make_sys_node(FINSH_NODE_SYS_OR, xor, xor_new);
|
|
|
|
next_token(token, &(self->token));
|
|
}
|
|
|
|
finsh_token_replay(&(self->token));
|
|
return xor;
|
|
}
|
|
|
|
/*
|
|
expr_exclusive_or -> expr_and
|
|
| expr_exclusive '^' expr_and
|
|
*/
|
|
static struct finsh_node* proc_exclusive_or_expr(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node* and;
|
|
struct finsh_node* and_new;
|
|
|
|
and = proc_and_expr(self);
|
|
next_token(token, &(self->token));
|
|
while ( token == finsh_token_type_xor )
|
|
{
|
|
and_new = proc_and_expr(self);
|
|
if (and_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR);
|
|
else and = make_sys_node(FINSH_NODE_SYS_XOR, and, and_new);
|
|
|
|
next_token(token, &(self->token));
|
|
}
|
|
|
|
finsh_token_replay(&(self->token));
|
|
return and;
|
|
}
|
|
|
|
/*
|
|
expr_and -> expr_shift
|
|
| expr_and '&' expr_shift
|
|
*/
|
|
static struct finsh_node* proc_and_expr(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node* shift;
|
|
struct finsh_node* shift_new;
|
|
|
|
shift = proc_shift_expr(self);
|
|
|
|
next_token(token, &(self->token));
|
|
while ( token == finsh_token_type_and )
|
|
{
|
|
shift_new = proc_shift_expr(self);
|
|
|
|
if (shift_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR);
|
|
else shift = make_sys_node(FINSH_NODE_SYS_AND, shift, shift_new);
|
|
|
|
next_token(token, &(self->token));
|
|
}
|
|
|
|
finsh_token_replay(&(self->token));
|
|
return shift;
|
|
}
|
|
|
|
/*
|
|
expr_shift -> expr_additive
|
|
| expr_shift '<<' expr_additive
|
|
| expr_shift '>>' expr_additive
|
|
*/
|
|
static struct finsh_node* proc_shift_expr(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node* add;
|
|
struct finsh_node* add_new;
|
|
|
|
add = proc_additive_expr(self);
|
|
|
|
next_token(token, &(self->token));
|
|
while ( token == finsh_token_type_shl || token == finsh_token_type_shr)
|
|
{
|
|
add_new = proc_additive_expr(self);
|
|
if (add_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR);
|
|
else
|
|
{
|
|
switch (token)
|
|
{
|
|
case finsh_token_type_shl:
|
|
add = make_sys_node(FINSH_NODE_SYS_SHL, add, add_new);
|
|
break;
|
|
case finsh_token_type_shr:
|
|
add = make_sys_node(FINSH_NODE_SYS_SHR, add, add_new);
|
|
break;
|
|
default:
|
|
finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR);
|
|
break;
|
|
}
|
|
}
|
|
next_token(token, &(self->token));
|
|
}
|
|
|
|
finsh_token_replay(&(self->token));
|
|
return add;
|
|
}
|
|
|
|
/*
|
|
expr_additive -> expr_multiplicative
|
|
| expr_additive SUB expr_multiplicative
|
|
| expr_additive ADD expr_multiplicative
|
|
*/
|
|
static struct finsh_node* proc_additive_expr(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node* mul;
|
|
struct finsh_node* mul_new;
|
|
|
|
mul = proc_multiplicative_expr(self);
|
|
|
|
next_token(token, &(self->token));
|
|
while ( token == finsh_token_type_sub || token == finsh_token_type_add )
|
|
{
|
|
mul_new = proc_multiplicative_expr(self);
|
|
if (mul_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR);
|
|
else
|
|
{
|
|
switch (token)
|
|
{
|
|
case finsh_token_type_sub:
|
|
mul = make_sys_node(FINSH_NODE_SYS_SUB, mul, mul_new);
|
|
break;
|
|
case finsh_token_type_add:
|
|
mul = make_sys_node(FINSH_NODE_SYS_ADD, mul, mul_new);
|
|
break;
|
|
default:
|
|
finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR);
|
|
break;
|
|
}
|
|
}
|
|
next_token(token, &(self->token));
|
|
}
|
|
|
|
finsh_token_replay(&(self->token));
|
|
return mul;
|
|
}
|
|
|
|
/*
|
|
expr_multiplicative -> expr_cast
|
|
| expr_multiplicative '*' expr_cast
|
|
| expr_multiplicative '/' expr_cast
|
|
| expr_multiplicative '%' expr_cast
|
|
*/
|
|
static struct finsh_node* proc_multiplicative_expr(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node* cast;
|
|
struct finsh_node* cast_new;
|
|
|
|
cast = proc_cast_expr(self);
|
|
next_token(token, &(self->token));
|
|
while (token == finsh_token_type_mul ||
|
|
token == finsh_token_type_div ||
|
|
token == finsh_token_type_mod )
|
|
{
|
|
cast_new = proc_cast_expr(self);
|
|
if (cast_new == NULL) finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR);
|
|
else
|
|
{
|
|
switch (token)
|
|
{
|
|
case finsh_token_type_mul:
|
|
cast = make_sys_node(FINSH_NODE_SYS_MUL, cast, cast_new);
|
|
break;
|
|
|
|
case finsh_token_type_div:
|
|
cast = make_sys_node(FINSH_NODE_SYS_DIV, cast, cast_new);
|
|
break;
|
|
|
|
case finsh_token_type_mod:
|
|
cast = make_sys_node(FINSH_NODE_SYS_MOD, cast, cast_new);
|
|
break;
|
|
|
|
default:
|
|
finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR);
|
|
break;
|
|
}
|
|
}
|
|
next_token(token, &(self->token));
|
|
}
|
|
|
|
finsh_token_replay(&(self->token));
|
|
return cast;
|
|
}
|
|
|
|
/*
|
|
20060313, add recast parse
|
|
expr_cast -> expr_unary
|
|
| '(' type ')' expr_cast
|
|
*/
|
|
static struct finsh_node* proc_cast_expr(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
enum finsh_type type;
|
|
struct finsh_node* cast;
|
|
|
|
next_token(token, &(self->token));
|
|
if (token == finsh_token_type_left_paren)
|
|
{
|
|
type = proc_type(self);
|
|
match_token(token, &(self->token), finsh_token_type_right_paren);
|
|
|
|
cast = proc_cast_expr(self);
|
|
if (cast != NULL)
|
|
{
|
|
cast->data_type = type;
|
|
return cast;
|
|
}
|
|
}
|
|
|
|
finsh_token_replay(&(self->token));
|
|
return proc_unary_expr(self);
|
|
}
|
|
|
|
/*
|
|
20050921, add '*' and '&'
|
|
expr_unary -> expr_postfix
|
|
| ADD expr_cast
|
|
| INC expr_cast
|
|
| SUB expr_cast
|
|
| DEC expr_cast
|
|
| '~' expr_cast
|
|
| '*' expr_cast
|
|
| '&' expr_cast
|
|
*/
|
|
static struct finsh_node* proc_unary_expr(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node *cast;
|
|
|
|
next_token(token, &(self->token));
|
|
switch (token)
|
|
{
|
|
case finsh_token_type_add: /* + */
|
|
cast = proc_cast_expr(self);
|
|
return cast;
|
|
|
|
case finsh_token_type_inc: /* ++ */
|
|
cast = proc_cast_expr(self);
|
|
return make_sys_node(FINSH_NODE_SYS_PREINC, cast, NULL);
|
|
|
|
case finsh_token_type_sub: /* - */
|
|
cast = proc_cast_expr(self);
|
|
return make_sys_node(FINSH_NODE_SYS_SUB, finsh_node_new_long(0), cast);
|
|
|
|
case finsh_token_type_dec: /* -- */
|
|
cast = proc_cast_expr(self);
|
|
return make_sys_node(FINSH_NODE_SYS_PREDEC, cast, NULL);
|
|
|
|
case finsh_token_type_bitwise: /* ~ */
|
|
cast = proc_cast_expr(self);
|
|
return make_sys_node(FINSH_NODE_SYS_BITWISE, cast, NULL);
|
|
|
|
case finsh_token_type_mul: /* * */
|
|
cast = proc_cast_expr(self);
|
|
return make_sys_node(FINSH_NODE_SYS_GETVALUE, cast, NULL);
|
|
|
|
case finsh_token_type_and: /* & */
|
|
cast = proc_cast_expr(self);
|
|
return make_sys_node(FINSH_NODE_SYS_GETADDR, cast, NULL);
|
|
|
|
default:
|
|
finsh_token_replay(&(self->token));
|
|
return proc_postfix_expr(self);
|
|
}
|
|
}
|
|
|
|
/*
|
|
expr_postfix -> expr_primary
|
|
| expr_postfix INC
|
|
| expr_postfix DEC
|
|
| expr_postfix '(' param_list ')'
|
|
*/
|
|
static struct finsh_node* proc_postfix_expr(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node* postfix;
|
|
|
|
postfix = proc_primary_expr(self);
|
|
|
|
next_token(token, &(self->token));
|
|
while ( token == finsh_token_type_inc ||
|
|
token == finsh_token_type_dec ||
|
|
token == finsh_token_type_left_paren )
|
|
{
|
|
switch (token)
|
|
{
|
|
case finsh_token_type_inc :/* '++' */
|
|
postfix = make_sys_node(FINSH_NODE_SYS_INC, postfix, NULL);
|
|
break;
|
|
|
|
case finsh_token_type_dec :/* '--' */
|
|
postfix = make_sys_node(FINSH_NODE_SYS_DEC, postfix, NULL);
|
|
break;
|
|
|
|
case finsh_token_type_left_paren :/* '(' */
|
|
{
|
|
struct finsh_node* param_list;
|
|
|
|
param_list = NULL;
|
|
next_token(token, &(self->token));
|
|
if (token != finsh_token_type_right_paren)
|
|
{
|
|
finsh_token_replay(&(self->token));
|
|
param_list = proc_param_list(self);
|
|
|
|
match_token(token, &(self->token), finsh_token_type_right_paren);
|
|
}
|
|
|
|
postfix = make_sys_node(FINSH_NODE_SYS_FUNC, postfix, param_list);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
next_token(token, &(self->token));
|
|
}
|
|
|
|
finsh_token_replay(&(self->token));
|
|
return postfix;
|
|
}
|
|
|
|
/*
|
|
expr_primary -> literal
|
|
| '(' expr ')'
|
|
| identifier
|
|
*/
|
|
static struct finsh_node* proc_primary_expr(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node* expr;
|
|
|
|
next_token(token, &(self->token));
|
|
switch ( token )
|
|
{
|
|
case finsh_token_type_identifier:
|
|
{
|
|
char id[FINSH_NAME_MAX + 1];
|
|
|
|
finsh_token_replay(&(self->token));
|
|
proc_identifier(self, id);
|
|
return finsh_node_new_id(id);
|
|
}
|
|
|
|
case finsh_token_type_left_paren:
|
|
expr = proc_expr(self);
|
|
match_token(token, &(self->token), finsh_token_type_right_paren);
|
|
return expr;
|
|
|
|
case finsh_token_type_value_int:
|
|
return finsh_node_new_int(self->token.value.int_value);
|
|
|
|
case finsh_token_type_value_long:
|
|
return finsh_node_new_long(self->token.value.long_value);
|
|
|
|
case finsh_token_type_value_char:
|
|
return finsh_node_new_char(self->token.value.char_value);
|
|
|
|
case finsh_token_type_value_string:
|
|
return finsh_node_new_string((char*)self->token.string);
|
|
|
|
case finsh_token_type_value_null:
|
|
return finsh_node_new_ptr(NULL);
|
|
|
|
default:
|
|
finsh_error_set(FINSH_ERROR_INVALID_TOKEN);
|
|
break;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
param_list -> empty
|
|
| expr_assign
|
|
| param_list ',' expr_assign
|
|
*/
|
|
static struct finsh_node* proc_param_list(struct finsh_parser* self)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node *node, *assign;
|
|
|
|
assign = proc_assign_expr(self);
|
|
if (assign == NULL) return NULL;
|
|
node = assign;
|
|
|
|
next_token(token, &(self->token));
|
|
while (token == finsh_token_type_comma )
|
|
{
|
|
finsh_node_sibling(assign) = proc_assign_expr(self);
|
|
|
|
if (finsh_node_sibling(assign) != NULL) assign = finsh_node_sibling(assign);
|
|
else finsh_error_set(FINSH_ERROR_EXPECT_OPERATOR);
|
|
|
|
next_token(token, &(self->token));
|
|
}
|
|
|
|
finsh_token_replay(&(self->token));
|
|
|
|
return node;
|
|
}
|
|
|
|
/*
|
|
make a new node as following tree:
|
|
new_node
|
|
|
|
|
node1__
|
|
\
|
|
node2
|
|
*/
|
|
static struct finsh_node* make_sys_node(u_char type, struct finsh_node* node1, struct finsh_node* node2)
|
|
{
|
|
struct finsh_node* node;
|
|
|
|
node = finsh_node_allocate(type);
|
|
|
|
if ((node1 != NULL) && (node != NULL))
|
|
{
|
|
finsh_node_child(node) = node1;
|
|
finsh_node_sibling(node1) = node2;
|
|
}
|
|
else finsh_error_set(FINSH_ERROR_NULL_NODE);
|
|
|
|
return node;
|
|
}
|
|
|
|
/*
|
|
start -> statement_expr | decl_variable
|
|
*/
|
|
void finsh_parser_run(struct finsh_parser* self, const u_char* string)
|
|
{
|
|
enum finsh_token_type token;
|
|
struct finsh_node *node;
|
|
|
|
node = NULL;
|
|
|
|
/* init parser */
|
|
self->parser_string = (u_char*)string;
|
|
|
|
/* init token */
|
|
finsh_token_init(&(self->token), self->parser_string);
|
|
|
|
/* get next token */
|
|
next_token(token, &(self->token));
|
|
while (token != finsh_token_type_eof && token != finsh_token_type_bad)
|
|
{
|
|
switch (token)
|
|
{
|
|
case finsh_token_type_identifier:
|
|
/* process expr_statement */
|
|
finsh_token_replay(&(self->token));
|
|
|
|
if (self->root != NULL)
|
|
{
|
|
finsh_node_sibling(node) = proc_expr_statement(self);
|
|
if (finsh_node_sibling(node) != NULL)
|
|
node = finsh_node_sibling(node);
|
|
}
|
|
else
|
|
{
|
|
node = proc_expr_statement(self);
|
|
self->root = node;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if (is_base_type(token) || token == finsh_token_type_unsigned)
|
|
{
|
|
/* variable decl */
|
|
finsh_token_replay(&(self->token));
|
|
|
|
if (self->root != NULL)
|
|
{
|
|
finsh_node_sibling(node) = proc_variable_decl(self);
|
|
if (finsh_node_sibling(node) != NULL)
|
|
node = finsh_node_sibling(node);
|
|
}
|
|
else
|
|
{
|
|
node = proc_variable_decl(self);
|
|
self->root = node;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* process expr_statement */
|
|
finsh_token_replay(&(self->token));
|
|
|
|
if (self->root != NULL)
|
|
{
|
|
finsh_node_sibling(node) = proc_expr_statement(self);
|
|
if (finsh_node_sibling(node) != NULL)
|
|
node = finsh_node_sibling(node);
|
|
else next_token(token, &(self->token));
|
|
}
|
|
else
|
|
{
|
|
node = proc_expr_statement(self);
|
|
self->root = node;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
/* get next token */
|
|
next_token(token, &(self->token));
|
|
}
|
|
}
|
|
|
|
int finsh_parser_init(struct finsh_parser* self)
|
|
{
|
|
memset(self, 0, sizeof(struct finsh_parser));
|
|
|
|
return 0;
|
|
}
|