From c094a95f8a454f4e4654da241786676c57f1b6aa Mon Sep 17 00:00:00 2001 From: uint256_t Date: Sun, 14 Jan 2018 00:14:00 +0900 Subject: [PATCH] refine code --- src/codegen.rs | 31 +++++++++++++++++-------------- src/parser.rs | 12 +++++------- src/types.rs | 14 ++++++++------ 3 files changed, 30 insertions(+), 27 deletions(-) diff --git a/src/codegen.rs b/src/codegen.rs index b1448d6..7706562 100644 --- a/src/codegen.rs +++ b/src/codegen.rs @@ -16,7 +16,7 @@ use self::llvm::prelude::*; use node; use node::Bits; use lexer::Pos; -use types::{Sign, StorageClass, Type}; +use types::{RectypeName, Sign, StorageClass, Type}; macro_rules! matches { ($e:expr, $p:pat) => { @@ -99,7 +99,7 @@ pub struct Codegen { local_varmap: Vec>, label_map: HashMap, switch_list: VecDeque<(LLVMValueRef, LLVMBasicBlockRef, LLVMTypeRef)>, - llvm_struct_map: HashMap, + llvm_struct_map: HashMap, break_labels: VecDeque, continue_labels: VecDeque, cur_func: Option, @@ -237,7 +237,10 @@ impl Codegen { node::ASTKind::VariableDecl(ref ty, ref name, ref sclass, ref init) => { self.gen_global_var_decl(ty, name, sclass, init) } - _ => panic!(format!("codegen: unknown ast (given {:?})", ast)), + _ => panic!(format!( + "given ast which shouldn't be contained in toplevels: {:?}", + ast + )), }; result.or_else(|cr: Error| match cr { @@ -447,10 +450,9 @@ impl Codegen { } else { // default initialization - match *ty { - // function is not initialized - Type::Func(_, _, _) => return Ok((gvar, Some(ty.clone()))), - _ => {} + if let Type::Func(_, _, _) = *ty { + // function must not be initialized + return Ok((gvar, Some(ty.clone()))); } LLVMSetLinkage( @@ -503,13 +505,14 @@ impl Codegen { let elem = try!(self.gen(e)).0; elems.push(self.typecast(elem, llvm_elem_ty)); } + let elems_len = elems.len(); Ok(( LLVMConstArray( llvm_elem_ty, elems.as_mut_slice().as_mut_ptr(), - elems.len() as u32, + elems_len as u32, ), - Some(Type::Array(Box::new(elem_ty.unwrap()), elems.len() as i32)), + Some(Type::Array(Box::new(elem_ty.unwrap()), elems_len as i32)), )) } unsafe fn gen_const_array_for_global_init( @@ -599,7 +602,7 @@ impl Codegen { try!(self.fill_with_0(var, ty)); for (i, e) in elems_ast.iter().enumerate() { - // TODO: makes very very no sense... + // TODO: makes no sense... let load = LLVMBuildGEP( self.builder, var, @@ -1638,11 +1641,11 @@ impl Codegen { expr: &node::AST, field_name: String, ) -> CodegenR<(LLVMValueRef, Option)> { - let (strct, ptr_ty_w) = try!(self.gen(expr)); - let ptr_ty = ptr_ty_w.unwrap(); + let (strct, ptr_ty) = try!(self.gen(expr)); + let ptr_ty = ptr_ty.unwrap(); let ty = ptr_ty .get_elem_ty() - .or_else(|| panic!("gen_assign: ptr_dst_ty must be a pointer to the value's type")) + .or_else(|| panic!("gen_assign: must be a pointer to the value's type")) .unwrap(); let strct_name = ty.get_name(); assert!(strct_name.is_some()); @@ -1762,7 +1765,6 @@ impl Codegen { for arg in &*args { maybe_correct_args_val.push(try!(self.gen(arg)).0); } - let args_len = args.len(); let func = match retrieve_from_load(ast) { &node::AST { @@ -1825,6 +1827,7 @@ impl Codegen { LLVMGetParamTypes(llvm_functy, ptr_params_types); let llvm_params_types = Vec::from_raw_parts(ptr_params_types, params_count, 0); + let args_len = args.len(); if !func_is_vararg && params_count < args_len { return Err(Error::MsgWithPos( "too many arguments".to_string(), diff --git a/src/parser.rs b/src/parser.rs index e192323..5da0af9 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -601,10 +601,10 @@ impl<'a> Parser<'a> { } } fn read_string_initializer(&mut self, ty: &mut Type, string: String) -> ParseR { - let mut char_ary = Vec::new(); - for c in string.chars() { - char_ary.push(AST::new(ASTKind::Char(c as i32), Pos::new(0, 0))); - } + let char_ary = string + .chars() + .map(|c| AST::new(ASTKind::Char(c as i32), Pos::new(0, 0))) + .collect::>(); if let &mut Type::Array(_, ref mut len) = ty { *len = char_ary.len() as i32 + 1; } else { @@ -643,9 +643,7 @@ impl<'a> Parser<'a> { self.lexer.get_cur_pos(), )) } else { - // maybe, this block never reach though. - self.show_error("initializer of array must be array"); - Err(Error::Something) + panic!() } } fn read_struct_initializer(&mut self, ty: &mut Type) -> ParseR { diff --git a/src/types.rs b/src/types.rs index 067adee..e15d337 100644 --- a/src/types.rs +++ b/src/types.rs @@ -27,13 +27,15 @@ pub enum Type { Float, Double, Ptr(Box), - Array(Box, i32), // ary elem type, size - Func(Box, Vec, bool), // return type, param types, vararg - Struct(String, Vec), // name, fields - Union(String, Vec, usize), // name, fields, means size of nth field is size of the union - Enum, // as same as Int + Array(Box, i32), // ary elem type, size + Func(Box, Vec, bool), // return type, param types, vararg + Struct(RectypeName, Vec), // name, fields + Union(RectypeName, Vec, usize), // name, fields, means size of nth field is size of the union + Enum, // as same as Int } +pub type RectypeName = String; + impl Type { pub fn get_elem_ty<'a>(&'a self) -> Option<&'a Type> { match self { @@ -92,7 +94,7 @@ impl Type { _ => None, } } - // TODO: I can't come up with a good name... + // TODO: any good name? pub fn conversion(self) -> Type { match self { Type::Array(elem_ty, _) => Type::Ptr(elem_ty),