fix: call

src/ast.rs

@@ -2,7 +2,7 @@
 // mod super::token::TokenKeywords;
 use std::io;
 
-use crate::{ast_token::{get_token_keyword, Token, get_token_literal}, ast_node::{ Expression, NumberLiteral, LetVariableStatement}, ast_utils::{get_hex_number_value, chars_to_string}};
+use crate::{ast_token::{get_token_keyword, Token, get_token_literal}, ast_node::{ Expression, NumberLiteral, LetVariableStatement, StringLiteral, LetVariableDeclaration, Statement}, ast_utils::{get_hex_number_value, chars_to_string}};
 pub struct AST {
  // 当前字符
  char: char,
@@ -45,10 +45,12 @@ impl AST{
  fn parse_program(&mut self) -> Program {
  // 开启一个作用域
  self.open_scope();
- self.parse_statements();
+ let body = self.parse_statements();
  // 关闭一个作用域
  self.close_scope();
- Program {}
+ Program {
+ body
+ }
  }
  // 开启一个作用域
  fn open_scope(&mut self) {
@@ -60,66 +62,70 @@ impl AST{
 
  }
 
- fn parse_statements(&mut self) {
- let mut i = 0;
+ fn parse_statements(&mut self) -> Vec<Statement> {
+ let mut statements: Vec<Statement> = vec![];
  loop {
 
- if let Token::EOF = self.token  {
+ if let Token::EOF = self.token {
  // end of file
  break;
- } else {
- self.parse_statement()
  }
- i = i + 1;
- if i > 1000 {
+ let statement = self.parse_statement();
+ if let Statement::Unknown = statement {
+ // TODO: unknown statement
  break;
  }
+ statements.push(statement);
  }
+ return statements;
  }
 
  // 解析生成 statement
- fn parse_statement(&mut self) {
+ fn parse_statement(&mut self) -> Statement {
  match self.token {
  Token::Let => self.parse_let_statement(),
- _ => {},
+ _ => Statement::Unknown,
  }
  }
 
  // 解析 let 
- fn parse_let_statement(&mut self) {
+ fn parse_let_statement(&mut self) -> Statement {
  self.check_token_and_next(Token::Let);
+ let mut let_statement = LetVariableStatement {
+ list: vec![],
+ };
  loop {
- self.parse_variable_declaration();
- println!("let {:?} {}", self.token, self.literal);
+ let expression = self.parse_variable_declaration();
+ let_statement.list.push(expression);
  // let a= 1, b = 2;
  if self.token != Token::Comma {
  break;
  }
  self.next();
  }
  self.semicolon();
+ return Statement::Let(let_statement);
  }
 
  // 解析变量定义 a = 123,b,c = true 
- fn parse_variable_declaration(&mut self) {
+ fn parse_variable_declaration(&mut self) -> Expression {
  if Token::Identifier != self.token {
  // TODO: throw error 需要一个identifier
- return;
+ return Expression::Unknown;
  }
  let literal = self.literal.clone();
  self.next();
- println!("nexg:{}", self.char);
- let node = LetVariableStatement{
- name: literal
+ let mut node = LetVariableDeclaration{
+  name: literal,
+ initializer: Box::new(Expression::Undefined),
  };
 
  if self.token == Token::Assign {
+ // TODO:
  self.next();
- self.parse_assignment_expression();
+ node.initializer = Box::new(self.parse_assignment_expression());
  }
- println!("literal:{:?}", node);
- return
-
+ return Expression::Let(node)
  }
 
  fn check_token_and_next(&mut self, token: Token) {
@@ -140,7 +146,7 @@ impl AST{
  let scan_res = self.scan();
  self.token = scan_res.0;
  self.literal = scan_res.1;
- println!("next:{:?}, {}", self.token, self.literal)
+ println!("next: >{:?}<, >{}<, >{}<", self.token, self.literal, self.char);
  }
 
  // 扫描获取符号
@@ -216,7 +222,7 @@ impl AST{
  } else {
  self.next_char_index = self.length
  }
- println!("read:{}, {}, {}", self.char, self.cur_char_index,self.next_char_index)
+ // println!("read:{}, {}, {}", self.char, self.cur_char_index,self.next_char_index)
  }
 
  // 获取标识符
@@ -244,7 +250,7 @@ impl AST{
  self.read();
  match self.char {
  'x' | 'X' => {
- // 十六进制
+ // TODO: 十六进制
  // 自动读取下一个字符
  self.read_number(16);
  let number_len = self.cur_char_index - start_index;
@@ -255,7 +261,10 @@ impl AST{
 
  },
  'b' | 'B' => {
- // 二进制
+ // TODO: 二进制
+ },
+ '.' => {
+ // TODO: 浮点数
  },
  _ => {
 
@@ -264,8 +273,12 @@ impl AST{
  }
  // 十进制
  self.read_number(10);
- println!("number{}", start_index);
- return (Token::Number, chars_to_string(&self.code, start_index, self.next_char_index))
+ // 浮点数
+ if self.char == '.' {
+ self.read();
+ self.read_number(10);
+ }
+ return (Token::Number, chars_to_string(&self.code, start_index, self.cur_char_index))
  }
 
  fn read_number(&mut self, binary: i32) {
@@ -283,16 +296,13 @@ impl AST{
  let start_index = self.cur_char_index;
  let str_start = self.char.clone();
  self.read();
- let mut i = 0;
  while self.char != str_start {
- if i > 10 {
- break;
- }
- i = i + 1;
+ // TODO: '\'aa\''
  self.read();
  }
+ let literal = chars_to_string(&self.code, start_index, self.next_char_index);
  self.read();
- return (Token::String, chars_to_string(&self.code, start_index, self.next_char_index))
+ return (Token::String, literal);
  }
 
  // 查看是否是 标识符的首字符
@@ -348,16 +358,22 @@ impl AST{
  let literal = self.literal.clone();
  match self.token {
  Token::Number => {
- println!("literal {}", literal);
  return Expression::Number(NumberLiteral {
-
+ literal,
+ value: 1.0, // TODO
+ })
+ },
+ Token::String => {
+ let str_len = literal.len();
+ let slice = String::from(&self.literal[1..str_len-1]);
+ return Expression::String(StringLiteral{
+ literal,
+ value: slice
  })
  },
  _ => ()
  }
- return Expression::Number(NumberLiteral {
-
- })
+ return Expression::Unknown
  }
 
  // 跳过空白字符
@@ -385,7 +401,9 @@ impl AST{
  }
 }
 #[derive(Debug)]
-pub struct Program {}
+pub struct Program {
+ pub body: Vec<Statement>
+}
 
 
 impl Program {}

src/ast_node.rs

@@ -1,17 +1,24 @@
 use crate::ast_token::Token;
 
-
+#[derive(Debug)]
+pub enum Statement {
+ Let(LetVariableStatement),
+ Unknown,
+}
 
 #[derive(Debug)]
 pub enum Expression {
- // Let(LetVariableStatement),
+ Let(LetVariableDeclaration),
  // Assign(AssignExpression),
  Number(NumberLiteral),
+ String(StringLiteral),
+ Undefined,
+ Unknown,
 }
 
 #[derive(Debug)]
 pub struct LetVariableStatement {
- pub name: String,
+ pub list: Vec<Expression>
 }
 #[derive(Debug)]
 pub struct AssignExpression {
@@ -22,5 +29,18 @@ pub struct AssignExpression {
 
 #[derive(Debug)]
 pub struct NumberLiteral {
+ pub literal: String,
+ pub value: f64,
+}
 
+#[derive(Debug)]
+pub struct StringLiteral {
+ pub literal: String,
+ pub value: String
+}
+
+#[derive(Debug)]
+pub struct LetVariableDeclaration {
+ pub name: String,
+ pub initializer: Box<Expression>
 }

src/context.rs

@@ -1,3 +1,5 @@
+use crate::{ast::Program, ast_node::Statement, ast_node::{Expression}, value::Value};
+
 use super::ast::AST;
 pub struct Context {
 }
@@ -10,7 +12,40 @@ impl Context {
  pub fn run(&self, code: String) {
  let mut ast = AST::new(code);
  let program = ast.parse();
+ self.call(program);
+ }
+
+ fn call(&self, program: Program) {
+ // 创建全局作用域
+ // 绑定函数声明
+ // 绑定变量声明
+ // 执行 statement
+ for statement in program.body.iter() {
+ match statement {
+ Statement::Let(let_statement) => {
+ for variable in let_statement.list.iter() {
+ if let Expression::Let(let_var) = variable {
+ let value = self.execute_expression(&let_var.initializer);
+ println!("initiallize:{:?}, {:?}",let_var.name, value);
+ }
+ }
+ },
+ _ => {}
+ }
+ }
+ // 关闭全局作用域
+ }
 
- println!("{:?}", program)
+ fn execute_expression(&self, expression: &Expression) -> Value {
+ println!("expression: {:?}", expression);
+ match expression {
+ Expression::String(string) => {
+ return Value::String(string.value.clone());
+ },
+ Expression::Number(number) => {
+ return Value::Number(number.value);
+ },
+ _ => Value::Undefined,
+ }
  }
-}
+} 

src/lib.rs

@@ -3,18 +3,20 @@ mod ast;
 mod ast_token;
 mod ast_node;
 mod ast_utils;
+mod value;
+
 use context::Context;
 pub struct JSI {
-  context: Context,
+ context: Context,
 }
 
 impl JSI {
-  pub fn new() -> JSI {
-  JSI {
-  context: Context::new()
-  }
-  }
-  pub fn run(&self, code: String) {
-  return self.context.run(code)
-  }
-}
+ pub fn new() -> JSI {
+ JSI {
+ context: Context::new()
+ }
+ }
+ pub fn run(&self, code: String) {
+ return self.context.run(code)
+ }
+}

src/value.rs

@@ -0,0 +1,6 @@
+#[derive(Debug)]
+pub enum Value {
+ String(String),
+ Number(f64),
+ Undefined,
+}

tests/jsi_test.rs

@@ -3,5 +3,5 @@ use jsi::JSI;
 #[test]
 fn jsi_new() {
  let jsi_vm = JSI::new();
- jsi_vm.run(String::from("let test = 123;let test2 = 'abc'; console.log(1 > 2 ? test : test2"));
+ jsi_vm.run(String::from("let test = 123.456;let test2 = 'abc'; console.log(1 > 2 ? test : test2)"));
 }