kjuulh/rhai
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects Releases Wiki Activity

Minor code refactor.

Browse Source
This commit is contained in:
Stephen Chung
2020-11-02 23:54:19 +08:00
parent cc304ba513
commit b9de8eaa7f
8 changed files with 145 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
src/parser.rs
View File

@@ -267,7 +267,7 @@ fn parse_fn_call(
lib: &mut FunctionsLib,
id: String,
capture: bool,
mut namespace: Option<ModuleRef>,
mut namespace: Option<Box<ModuleRef>>,
settings: ParseSettings,
) -> Result<Expr, ParseError> {
let (token, token_pos) = input.peek().unwrap();
@@ -788,7 +788,7 @@ fn parse_primary(
{
state.allow_capture = true;
}
Expr::Variable(Box::new((Ident::new(s, settings.pos), None, 0, None)))
Expr::Variable(Box::new((None, None, 0, Ident::new(s, settings.pos))))
}
// Module qualification
#[cfg(not(feature = "no_module"))]
@@ -798,18 +798,18 @@ fn parse_primary(
{
state.allow_capture = true;
}
Expr::Variable(Box::new((Ident::new(s, settings.pos), None, 0, None)))
Expr::Variable(Box::new((None, None, 0, Ident::new(s, settings.pos))))
}
// Normal variable access
Token::Identifier(s) => {
let index = state.access_var(&s, settings.pos);
Expr::Variable(Box::new((Ident::new(s, settings.pos), None, 0, index)))
Expr::Variable(Box::new((index, None, 0, Ident::new(s, settings.pos))))
}
// Function call is allowed to have reserved keyword
Token::Reserved(s) if *next_token == Token::LeftParen || *next_token == Token::Bang => {
if is_keyword_function(&s) {
Expr::Variable(Box::new((Ident::new(s, settings.pos), None, 0, None)))
Expr::Variable(Box::new((None, None, 0, Ident::new(s, settings.pos))))
} else {
return Err(PERR::Reserved(s).into_err(settings.pos));
}
@@ -824,7 +824,7 @@ fn parse_primary(
)))
.into_err(settings.pos));
} else {
Expr::Variable(Box::new((Ident::new(s, settings.pos), None, 0, None)))
Expr::Variable(Box::new((None, None, 0, Ident::new(s, settings.pos))))
}
}
@@ -883,13 +883,13 @@ fn parse_primary(
.into_err(pos));
}
let (Ident { name, pos }, modules, _, _) = *x;
let (_, modules, _, Ident { name, pos }) = *x;
settings.pos = pos;
parse_fn_call(input, state, lib, name, true, modules, settings.level_up())?
}
// Function call
(Expr::Variable(x), Token::LeftParen) => {
let (Ident { name, pos }, modules, _, _) = *x;
let (_, modules, _, Ident { name, pos }) = *x;
settings.pos = pos;
parse_fn_call(input, state, lib, name, false, modules, settings.level_up())?
}
@@ -897,17 +897,17 @@ fn parse_primary(
// module access
(Expr::Variable(x), Token::DoubleColon) => match input.next().unwrap() {
(Token::Identifier(id2), pos2) => {
let (var_name_def, mut modules, _, index) = *x;
let (index, mut modules, _, var_name_def) = *x;
if let Some(ref mut modules) = modules {
modules.push(var_name_def);
} else {
let mut m: ModuleRef = Default::default();
m.push(var_name_def);
modules = Some(m);
modules = Some(Box::new(m));
}
Expr::Variable(Box::new((Ident::new(id2, pos2), modules, 0, index)))
Expr::Variable(Box::new((index, modules, 0, Ident::new(id2, pos2))))
}
(Token::Reserved(id2), pos2) if is_valid_identifier(id2.chars()) => {
return Err(PERR::Reserved(id2).into_err(pos2));
@@ -931,7 +931,7 @@ fn parse_primary(
match &mut root_expr {
// Cache the hash key for module-qualified variables
Expr::Variable(x) if x.1.is_some() => {
let (Ident { name, .. }, modules, hash, _) = x.as_mut();
let (_, modules, hash, Ident { name, .. }) = x.as_mut();
let modules = modules.as_mut().unwrap();
// Qualifiers + variable name
@@ -1087,19 +1087,19 @@ fn make_assignment_stmt<'a>(
) -> Result<Stmt, ParseError> {
match &lhs {
// var (non-indexed) = rhs
Expr::Variable(x) if x.3.is_none() => {
Expr::Variable(x) if x.1.is_none() => {
Ok(Stmt::Assignment(Box::new((lhs, fn_name.into(), rhs)), pos))
}
// var (indexed) = rhs
Expr::Variable(x) => {
let (
index,
_,
_,
Ident {
name,
pos: name_pos,
},
_,
_,
index,
) = x.as_ref();
match state.stack[(state.stack.len() - index.unwrap().get())].1 {
ScopeEntryType::Normal => {
@@ -1114,19 +1114,19 @@ fn make_assignment_stmt<'a>(
// xxx[???] = rhs, xxx.??? = rhs
Expr::Index(x, _) | Expr::Dot(x, _) => match &x.lhs {
// var[???] (non-indexed) = rhs, var.??? (non-indexed) = rhs
Expr::Variable(x) if x.3.is_none() => {
Expr::Variable(x) if x.1.is_none() => {
Ok(Stmt::Assignment(Box::new((lhs, fn_name.into(), rhs)), pos))
}
// var[???] (indexed) = rhs, var.??? (indexed) = rhs
Expr::Variable(x) => {
let (
index,
_,
_,
Ident {
name,
pos: name_pos,
},
_,
_,
index,
) = x.as_ref();
match state.stack[(state.stack.len() - index.unwrap().get())].1 {
ScopeEntryType::Normal => {
@@ -1204,10 +1204,10 @@ fn make_dot_expr(lhs: Expr, rhs: Expr, op_pos: Position) -> Result<Expr, ParseEr
}
// lhs.id
(lhs, Expr::Variable(x)) if x.1.is_none() => {
let ident = x.0;
let ident = x.3;
let getter = make_getter(&ident.name);
let setter = make_setter(&ident.name);
let rhs = Expr::Property(Box::new((ident.into(), (getter, setter))));
let rhs = Expr::Property(Box::new(((getter, setter), ident.into())));
Expr::Dot(Box::new(BinaryExpr { lhs, rhs }), op_pos)
}
@@ -1642,10 +1642,10 @@ fn parse_custom_syntax(
(Token::Identifier(s), pos) => {
segments.push(s.clone());
exprs.push(Expr::Variable(Box::new((
Ident::new(s, pos),
None,
None,
0,
None,
Ident::new(s, pos),
))));
}
(Token::Reserved(s), pos) if is_valid_identifier(s.chars()) => {
@@ -2500,12 +2500,12 @@ fn make_curry_from_externals(fn_expr: Expr, externals: StaticVec<Ident>, pos: Po
#[cfg(not(feature = "no_closure"))]
externals.iter().for_each(|x| {
args.push(Expr::Variable(Box::new((x.clone(), None, 0, None))));
args.push(Expr::Variable(Box::new((None, None, 0, x.clone()))));
});
#[cfg(feature = "no_closure")]
externals.into_iter().for_each(|x| {
args.push(Expr::Variable(Box::new((x.clone(), None, 0, None))));
args.push(Expr::Variable(Box::new((None, None, 0, x.clone()))));
});
let hash = calc_script_fn_hash(empty(), KEYWORD_FN_PTR_CURRY, num_externals + 1);