feat: impl http 1.1 basic feature

Chronostasys · Chronostasys · commit ff6cb7338b78 · 2025-03-27T10:12:11.000+08:00
fixed a bug causing `if let..`'s condition eval twice during exe.
update bin op parser so that bin op can eat new line
diff --git a/planglib/std/task/http.pi b/planglib/std/task/http.pi
@@ -1,12 +1,16 @@
 use std::task::Task;
 use std::task::tcp;
+use std::task::dns;
 use std::string::StringBuilder;
 use std::string::StringExt;
+use std::cols::arr;
 
 pub struct HttpResponse {
     status_code: i32;
     headers: string;
-    body: [u8];
+    socket: tcp::TCPSocket;
+    body_read: bool;
+    cached_body: arr::Array<u8>; // 新增:缓存已读取的body内容
 }
 
 pub struct HttpClient {
@@ -19,6 +23,7 @@ pub fn new_http_client() HttpClient {
     };
 }
 
+use std::io;
 impl HttpClient {
     pub async fn get_async(url: string) Task<HttpResponse> {
         // 构建HTTP GET请求
@@ -34,51 +39,89 @@ impl HttpClient {
         
         let request = sb.str();
         let bytes = request.bytes();
-        let status = await self.socket.connect_async("127.0.0.1", 5500 as i32);
+        let resolver = dns::new_dns_resolver();
+        let ip = await resolver.resolve_async(url);
+        let status = await self.socket.connect_async(ip, 80 as i32);
         // 发送请求
         await self.socket.write_async(bytes);
         
-        // 读取响应
-        let response_buf = [u8*4096;];
-        let read_len = await self.socket.read_async(response_buf);
-        
-        // let response_str = string_from_bytes(arr_slice(response_buf, 0, read_len));
+        // 使用1k缓冲区读取header
+        let response_buf = [u8*1024;];
+        let  total_read = 0;
+        let header_end = -1;
         
-        // 手动解析响应
-        let header_end = 0;
-        // 查找headers和body的分隔符 \r\n\r\n
-        for let i = 0; i < read_len - 3; i = i + 1 {
-            if response_buf[i] == '\r' as u8 && response_buf[i+1] == '\n' as u8 &&response_buf[i+2] == '\r' as u8 &&response_buf[i+3] == '\n' as u8 {
-                header_end = i;
+        while header_end == -1 {
+            let read_len = await self.socket.read_async(response_buf);
+            if read_len == 0 {
                 break;
             }
+            
+            // 查找header结束位置
+            for let i = 0; i < read_len - 3; i = i + 1 {
+                if response_buf[i] as char == '\r' && 
+                    response_buf[i+1] as char == '\n' && 
+                    response_buf[i+2] as char == '\r' && 
+                    response_buf[i+3] as char == '\n' {
+                    header_end = total_read + i;
+                    break;
+                }
+            }
+            total_read = total_read + read_len;
         }
         
         let headers = string_from_bytes(arr_slice(response_buf, 0, header_end));
-        let body = arr_slice(response_buf, header_end + 4, read_len - (header_end + 4));
+        
+        // 缓存已读取的body内容
+        let body_start = header_end + 4;
+        let cached_body = arr::from_slice<u8>(arr_slice(response_buf, body_start, total_read - body_start));
         
         // 解析状态码
-        let status_start = 9; // "HTTP/1.1 "的长度
-        let status_end = status_start;
-        for let i = status_start; i < header_end; i = i + 1 {
-            if response_buf[i] == ' ' as u8 {
-                status_end = i;
-                break;
-            }
-        }
-        let status_str = string_from_bytes(arr_slice(response_buf, status_start, status_end - status_start));
-        // TODO: 将status_str转换为整数
+        let status_str = string_from_bytes(arr_slice(response_buf, 9, 12));
         
         return HttpResponse{
             status_code: 200 as i32,
             headers: headers,
-            body: body,
+            socket: self.socket,
+            body_read: false,
+            cached_body: cached_body,
         };
     }
 }
 
+use std::math::*;
+use std::slice::SliceExt;
+
 impl HttpResponse {
-    pub fn get_body_string() string {
-        return string_from_bytes(self.body);
+    
+    pub async fn read_async(buf: [u8]) Task<Option<i64>> {
+        if self.body_read {
+            return None{} as Option<i64>;
+        }
+        // 先读取缓存的body内容
+        if self.cached_body.length() > 0 {
+            let copy_len = min(buf.len(), self.cached_body.length() as i64);
+            arr_copy(self.cached_body.get_slice(), buf, copy_len);
+            self.cached_body = arr::from_slice(arr_slice(self.cached_body.get_slice(), copy_len, self.cached_body.length() as i64 - copy_len));
+            return copy_len as Option<i64>;
+        }
+        // 继续从socket读取
+        let n = await self.socket.read_async(buf);
+        if n == 0 {
+            self.body_read = true;
+        }
+        return n as Option<i64>;
+    }
+
+    pub async fn read_all_async() Task<[u8]> {
+        let content = arr::new<u8>();
+        let buf = [u8*4096;];
+        while true {
+            if let n = (await self.read_async(buf)) as i64 {
+                content.append(arr::from_slice(arr_slice(buf, 0, n)));
+            } else {
+                break;
+            }
+        }
+        return content.get_slice();
     }
 }
diff --git a/src/ast/builder/llvmbuilder.rs b/src/ast/builder/llvmbuilder.rs
@@ -2212,14 +2212,15 @@ impl<'a, 'ctx> IRBuilder<'a, 'ctx> for LLVMBuilder<'a, 'ctx> {
     }
     fn build_dbg_location(&self, pos: Pos) {
         // assert_ne!(pos.line, 0, "debug location's line number should not be 0");
-        if self
-            .builder
-            .get_insert_block()
-            .unwrap()
-            .get_parent()
-            .unwrap()
-            .get_subprogram()
-            .is_none()
+        if self.builder.get_insert_block().is_none()
+            || self
+                .builder
+                .get_insert_block()
+                .unwrap()
+                .get_parent()
+                .unwrap()
+                .get_subprogram()
+                .is_none()
         {
             return;
         }
diff --git a/src/ast/fmt.rs b/src/ast/fmt.rs
@@ -10,6 +10,7 @@ use super::{
         global::{GlobalConstNode, GlobalNode},
         implement::ImplNode,
         interface::{MultiTraitNode, TraitBoundNode, TraitDefNode},
+        intermediate_node::IntermediateNode,
         macro_nodes::{MacroCallNode, MacroLoopStatementNode, MacroNode, MacroRuleNode},
         operator::{BinOpNode, TakeOpNode, UnaryOpNode},
         pkg::{ExternIdNode, UseNode},
@@ -941,4 +942,6 @@ impl FmtBuilder {
             super::node::control::MatchArmCondition::TypedDeconstruct(_, _) => todo!(),
         }
     }
+
+    pub fn parse_intermediate_node(&mut self, _node: &IntermediateNode) {}
 }
diff --git a/src/ast/node/control.rs b/src/ast/node/control.rs
@@ -73,8 +73,11 @@ impl Node for IfNode {
                                 .clone(),
                         );
                     }
+
+                    // we need to evaluate the expr first, to avoid it run twice
+                    let inter = IntermediateNode::new(a.expr.clone().emit(ctx, builder));
                     let mut transformed_is = NodeEnum::IsNode(IsNode {
-                        expr: a.expr.clone(),
+                        expr: Box::new(NodeEnum::InterNode(inter.clone())),
                         target_type: a.target_type.clone(),
                         range: a.range(),
                     });
@@ -88,7 +91,7 @@ impl Node for IfNode {
                     );
                     ctx.position_at_end(then_block, builder);
                     let transformed_as = NodeEnum::AsNode(AsNode {
-                        expr: a.expr.clone(),
+                        expr: Box::new(NodeEnum::InterNode(inter)),
                         target_type: a.target_type.clone(),
                         range: a.range(),
                         tail: Some((TokenType::NOT, Default::default())),
@@ -105,8 +108,10 @@ impl Node for IfNode {
                                 .clone(),
                         );
                     }
+                    // we need to evaluate the expr first, to avoid it run twice
+                    let inter = IntermediateNode::new(a.expr.clone().emit(ctx, builder));
                     let mut transformed_is = NodeEnum::ImplCastNode(ImplCastNode {
-                        expr: a.expr.clone(),
+                        expr: Box::new(NodeEnum::InterNode(inter.clone())),
                         target_type: a.target_type.clone(),
                         range: a.range(),
                         tail: Some((TokenType::QUESTION, Default::default())),
@@ -128,7 +133,7 @@ impl Node for IfNode {
                     }
                     ctx.position_at_end(then_block, builder);
                     let transformed_as = NodeEnum::ImplCastNode(ImplCastNode {
-                        expr: a.expr.clone(),
+                        expr: Box::new(NodeEnum::InterNode(inter)),
                         target_type: a.target_type.clone(),
                         range: a.range(),
                         tail: Some((TokenType::NOT, Default::default())),
diff --git a/src/ast/node/intermediate_node.rs b/src/ast/node/intermediate_node.rs
@@ -0,0 +1,41 @@
+use crate::ast::{ctx::Ctx, range::Range};
+use internal_macro::node;
+
+use crate::ast::builder::BuilderEnum;
+
+use super::node_result::NodeResult;
+use super::{Node, PrintTrait};
+
+#[node]
+pub struct IntermediateNode {
+    value: NodeResult,
+}
+
+// this node will never be shared between threads
+unsafe impl Send for IntermediateNode {}
+unsafe impl Sync for IntermediateNode {}
+
+impl IntermediateNode {
+    pub fn new(value: NodeResult) -> Self {
+        Self {
+            value,
+            range: Range::default(),
+        }
+    }
+}
+
+impl PrintTrait for IntermediateNode {
+    fn print(&self, _tabs: usize, _end: bool, _line: Vec<bool>) {
+        unreachable!()
+    }
+}
+
+impl Node for IntermediateNode {
+    fn emit<'a, 'b>(
+        &mut self,
+        _ctx: &'b mut Ctx<'a>,
+        _builder: &'b BuilderEnum<'a, '_>,
+    ) -> NodeResult {
+        self.value.clone()
+    }
+}
diff --git a/src/ast/node/mod.rs b/src/ast/node/mod.rs
@@ -9,6 +9,7 @@ use crate::ast::builder::IRBuilder;
 use cast::ImplCastNode;
 use enum_dispatch::enum_dispatch;
 
+use intermediate_node::IntermediateNode;
 use lsp_types::SemanticTokenType;
 
 use self::cast::AsNode;
@@ -54,6 +55,7 @@ pub mod function;
 pub mod global;
 pub mod implement;
 pub mod interface;
+pub mod intermediate_node;
 pub mod macro_nodes;
 pub mod node_result;
 pub mod operator;
@@ -148,6 +150,7 @@ pub enum NodeEnum {
     ClosureNode(ClosureNode),
     GlobalConstNode(GlobalConstNode),
     MatchNode(MatchNode),
+    InterNode(IntermediateNode),
 }
 // ANCHOR: range
 #[enum_dispatch]
diff --git a/src/ast/node/node_result.rs b/src/ast/node/node_result.rs
@@ -22,14 +22,14 @@ impl TerminatorEnum {
     }
 }
 
-#[derive(Default, Clone)]
+#[derive(Default, Clone, PartialEq, Eq, Debug)]
 pub struct NodeOutput {
     value: Option<NodeValue>,
     term: TerminatorEnum,
     pub compile_time_result: CompileTimeResult,
 }
 
-#[derive(Debug, Clone, Default, Copy)]
+#[derive(Debug, Clone, Default, Copy, PartialEq, Eq)]
 pub enum CompileTimeResult {
     #[default]
     None,
@@ -140,7 +140,7 @@ impl NodeOutput {
 }
 
 /// NodeValue is the output of the builder
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct NodeValue {
     /// the index which maps the real value stored inside the LLVMBuilder
     value: ValueHandle,
diff --git a/src/nomparser/array.rs b/src/nomparser/array.rs
@@ -29,20 +29,20 @@ use super::*;
 pub fn array_init(input: Span) -> IResult<Span, Box<NodeEnum>> {
     map_res(
         tuple((
-            tag_token_symbol(TokenType::LBRACKET),
+            tag_token_symbol_ex(TokenType::LBRACKET),
             opt(pair(
                 type_name,
                 delimited(
-                    tag_token_symbol(TokenType::MUL),
+                    tag_token_symbol_ex(TokenType::MUL),
                     general_exp,
-                    tag_token_symbol(TokenType::SEMI),
+                    tag_token_symbol_ex(TokenType::SEMI),
                 ),
             )),
             separated_list0(
-                tag_token_symbol(TokenType::COMMA),
+                tag_token_symbol_ex(TokenType::COMMA),
                 del_newline_or_space!(general_exp),
             ),
-            tag_token_symbol(TokenType::RBRACKET),
+            tag_token_symbol_ex(TokenType::RBRACKET),
         )),
         // lb and rb are used to mark the boundaries of an arry.
         |((_, lb), tp, exps, (_, rb))| {
@@ -57,9 +57,9 @@ pub fn array_init(input: Span) -> IResult<Span, Box<NodeEnum>> {
 pub fn array_element_op(input: Span) -> IResult<Span, (ComplexOp, Vec<Box<NodeEnum>>)> {
     delspace(map_res(
         tuple((
-            tag_token_symbol(TokenType::LBRACKET),
+            tag_token_symbol_ex(TokenType::LBRACKET),
             opt(general_exp),
-            tag_token_symbol(TokenType::RBRACKET),
+            tag_token_symbol_ex(TokenType::RBRACKET),
             many0(comment),
         )),
         |(_, idx, (_, rr), com)| {
diff --git a/src/nomparser/control.rs b/src/nomparser/control.rs
@@ -23,6 +23,14 @@ pub use _match::*;
     a = 2;
 }"
 )]
+#[test_parser(
+    "if a > 1 ||
+    b > 2 { 
+    a = 1;
+} else {
+    a = 2;
+}"
+)]
 #[test_parser(
     "if true {
     a = 1;
diff --git a/src/nomparser/expression.rs b/src/nomparser/expression.rs
@@ -29,6 +29,14 @@ pub fn general_exp(input: Span) -> IResult<Span, Box<NodeEnum>> {
 #[test_parser("a&&b")]
 #[test_parser("a||b")]
 #[test_parser("a &&  b")]
+#[test_parser(
+    "a && 
+ b"
+)]
+#[test_parser(
+    "a || 
+b"
+)]
 #[test_parser("a  || b")]
 #[test_parser("a&&b||c")]
 #[test_parser("a||b&&c")]
diff --git a/src/nomparser/macros.rs b/src/nomparser/macros.rs
@@ -29,7 +29,7 @@ macro_rules! parse_bin_ops {
                 many0(tuple((
                     alt((
                         $(
-                            tag_token_symbol(TokenType::$op),
+                            tag_token_symbol_ex(TokenType::$op),
                         )*
                     )),
                     $exp,
diff --git a/test/main.pi b/test/main.pi
diff --git a/test/test/std_test.pi b/test/test/std_test.pi

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ use super::{`
`10`	`10`	`global::{GlobalConstNode, GlobalNode},`
`11`	`11`	`implement::ImplNode,`
`12`	`12`	`interface::{MultiTraitNode, TraitBoundNode, TraitDefNode},`
	`13`	`+ intermediate_node::IntermediateNode,`
`13`	`14`	`macro_nodes::{MacroCallNode, MacroLoopStatementNode, MacroNode, MacroRuleNode},`
`14`	`15`	`operator::{BinOpNode, TakeOpNode, UnaryOpNode},`
`15`	`16`	`pkg::{ExternIdNode, UseNode},`
`@@ -941,4 +942,6 @@ impl FmtBuilder {`
`941`	`942`	`super::node::control::MatchArmCondition::TypedDeconstruct(_, _) => todo!(),`
`942`	`943`	`}`
`943`	`944`	`}`
	`945`	`+`
	`946`	`+ pub fn parse_intermediate_node(&mut self, _node: &IntermediateNode) {}`
`944`	`947`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,14 +22,14 @@ impl TerminatorEnum {`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`		`-#[derive(Default, Clone)]`
	`25`	`+#[derive(Default, Clone, PartialEq, Eq, Debug)]`
`26`	`26`	`pub struct NodeOutput {`
`27`	`27`	`value: Option<NodeValue>,`
`28`	`28`	`term: TerminatorEnum,`
`29`	`29`	`pub compile_time_result: CompileTimeResult,`
`30`	`30`	`}`
`31`	`31`
`32`		`-#[derive(Debug, Clone, Default, Copy)]`
	`32`	`+#[derive(Debug, Clone, Default, Copy, PartialEq, Eq)]`
`33`	`33`	`pub enum CompileTimeResult {`
`34`	`34`	`#[default]`
`35`	`35`	`None,`
`@@ -140,7 +140,7 @@ impl NodeOutput {`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`/// NodeValue is the output of the builder`
`143`		`-#[derive(Debug, Clone)]`
	`143`	`+#[derive(Debug, Clone, PartialEq, Eq)]`
`144`	`144`	`pub struct NodeValue {`
`145`	`145`	`/// the index which maps the real value stored inside the LLVMBuilder`
`146`	`146`	`value: ValueHandle,`