├── README.md ├── example ├── Cargo.toml └── src │ └── main.rs ├── src ├── lib.rs ├── serde_bin.rs ├── toml.rs ├── serde_json.rs └── serde_ron.rs ├── derive ├── Cargo.toml └── src │ ├── lib.rs │ ├── derive_bin.rs │ ├── derive_ron.rs │ ├── derive_json.rs │ └── macro_lib.rs ├── Cargo.toml ├── .gitignore └── LICENSE /README.md: -------------------------------------------------------------------------------- 1 | # microserde 2 | Micro replacement for Serde that compiles much faster but keeps a lot of its functionality 3 | -------------------------------------------------------------------------------- /example/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "microserde_example" 3 | version = "0.1.0" 4 | edition = "2018" 5 | 6 | [workspace] 7 | 8 | [dependencies] 9 | 10 | [dependencies.microserde] 11 | path="../" 12 | -------------------------------------------------------------------------------- /src/lib.rs: -------------------------------------------------------------------------------- 1 | pub use microserde_derive::*; 2 | 3 | mod serde_bin; 4 | pub use crate::serde_bin::*; 5 | 6 | mod serde_json; 7 | pub use crate::serde_json::*; 8 | 9 | mod serde_ron; 10 | pub use crate::serde_ron::*; 11 | 12 | mod toml; 13 | pub use crate::toml::*; 14 | -------------------------------------------------------------------------------- /derive/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "microserde-derive" 3 | version = "0.1.0" 4 | authors = ["Makepad "] 5 | edition = "2018" 6 | description = "microserde derive" 7 | license = "MIT" 8 | 9 | [lib] 10 | proc-macro = true 11 | 12 | [dependencies] 13 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "microserde" 3 | version = "0.1.0" 4 | authors = ["makepad "] 5 | license = "MIT OR Apache-2.0" 6 | description = "microserde." 7 | edition = "2018" 8 | 9 | [dependencies] 10 | microserde-derive = { path = "derive", version = "0.1" } 11 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Generated by Cargo 2 | # will have compiled files and executables 3 | /target/ 4 | 5 | # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries 6 | # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html 7 | Cargo.lock 8 | 9 | # These are backup files generated by rustfmt 10 | **/*.rs.bk 11 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 makepad 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /derive/src/lib.rs: -------------------------------------------------------------------------------- 1 | extern crate proc_macro; 2 | use proc_macro::{TokenStream}; 3 | 4 | mod macro_lib; 5 | 6 | mod derive_bin; 7 | use crate::derive_bin::*; 8 | 9 | mod derive_ron; 10 | use crate::derive_ron::*; 11 | 12 | mod derive_json; 13 | use crate::derive_json::*; 14 | 15 | #[proc_macro_derive(SerBin)] 16 | pub fn derive_ser_bin(input: TokenStream) -> TokenStream { 17 | derive_ser_bin_impl(input) 18 | } 19 | 20 | #[proc_macro_derive(DeBin)] 21 | pub fn derive_de_bin(input: TokenStream) -> TokenStream { 22 | derive_de_bin_impl(input) 23 | } 24 | 25 | #[proc_macro_derive(SerJson)] 26 | pub fn derive_ser_json(input: TokenStream) -> TokenStream { 27 | derive_ser_json_impl(input) 28 | } 29 | 30 | #[proc_macro_derive(DeJson)] 31 | pub fn derive_de_json(input: TokenStream) -> TokenStream { 32 | derive_de_json_impl(input) 33 | } 34 | 35 | 36 | #[proc_macro_derive(SerRon)] 37 | pub fn derive_ser_ron(input: TokenStream) -> TokenStream { 38 | derive_ser_ron_impl(input) 39 | } 40 | 41 | #[proc_macro_derive(DeRon)] 42 | pub fn derive_de_ron(input: TokenStream) -> TokenStream { 43 | derive_de_ron_impl(input) 44 | } 45 | 46 | -------------------------------------------------------------------------------- /example/src/main.rs: -------------------------------------------------------------------------------- 1 | // lets make tinyserde dep free too! 2 | 3 | use microserde::*; 4 | 5 | #[derive(SerBin, DeBin, SerJson, DeJson, SerRon, DeRon, PartialEq)] 6 | struct MyStruct where T: Clone { 7 | pub a: T, 8 | b: u32, 9 | c: Option>, 10 | d: Option>, 11 | e: MyEnum, 12 | f: MyEnum, 13 | g: MyEnum, 14 | h: MyEnum, 15 | i: MyEnum, 16 | j: String, 17 | k: [u32;2], 18 | l: (u64, u32, u16, u8), 19 | m: MyAnomStruct, 20 | } 21 | 22 | #[derive(SerBin, DeBin, SerJson, DeJson, SerRon, DeRon, PartialEq)] 23 | struct MyAnomStruct(f32, pub f64); 24 | 25 | #[derive(SerBin, DeBin, SerJson, DeJson, SerRon, DeRon, PartialEq)] 26 | enum MyEnum where T: Clone { 27 | One, 28 | Two(T, u32), 29 | Three {x: u32, y: T}, 30 | Four {z: Option, w: T}, 31 | } 32 | 33 | fn main() { 34 | //let a = MyStruct{step1:1,step2:None}; 35 | //let x = MyStruct2(1,2); 36 | let x = MyStruct { 37 | a: 1, 38 | b: 2, 39 | c: Some(vec![3]), 40 | d: None, 41 | e: MyEnum::One, 42 | f: MyEnum::Two(4, 5), 43 | g: MyEnum::Three {x: 6, y: 7}, 44 | h: MyEnum::Four {z: None, w: 8}, 45 | i: MyEnum::Four {z: Some(9), w: 8}, 46 | j: "Hello".to_string(), 47 | k: [10,11], 48 | l: (1, 2, 3, 4), 49 | m: MyAnomStruct(2.0,3.0), 50 | }; 51 | let bin = x.serialize_bin(); 52 | println!("Bin len: {}", bin.len()); 53 | let y:MyStruct = DeBin::deserialize_bin(&bin).unwrap(); 54 | println!("Bin roundtrip equality {}", x == y); 55 | 56 | let json = x.serialize_json(); 57 | println!("JSON Output {}", json); 58 | let y:MyStruct = DeJson::deserialize_json(&json).unwrap(); 59 | println!("JSON roundtrip equality {}", x == y); 60 | 61 | let ron = x.serialize_ron(); 62 | println!("RON Output {}", ron); 63 | let y:MyStruct = DeRon::deserialize_ron(&ron).unwrap(); 64 | println!("RON roundtrip equality {}", x == y); 65 | } 66 | -------------------------------------------------------------------------------- /derive/src/derive_bin.rs: -------------------------------------------------------------------------------- 1 | use proc_macro::{TokenStream}; 2 | use crate::macro_lib::*; 3 | 4 | pub fn derive_ser_bin_impl(input: TokenStream) -> TokenStream { 5 | 6 | let mut parser = TokenParser::new(input); 7 | let mut tb = TokenBuilder::new(); 8 | 9 | parser.eat_ident("pub"); 10 | if parser.eat_ident("struct"){ 11 | if let Some(name) = parser.eat_any_ident(){ 12 | let generic = parser.eat_generic(); 13 | let types = parser.eat_all_types(); 14 | let where_clause = parser.eat_where_clause(Some("SerBin")); 15 | 16 | tb.add("impl").stream(generic.clone()); 17 | tb.add("SerBin for").ident(&name).stream(generic).stream(where_clause); 18 | tb.add("{ fn ser_bin ( & self , s : & mut Vec < u8 > ) {"); 19 | 20 | if let Some(types) = types{ 21 | for i in 0..types.len(){ 22 | tb.add("self .").unsuf_usize(i).add(". ser_bin ( s ) ;"); 23 | } 24 | } 25 | else if let Some(fields) = parser.eat_all_struct_fields(){ 26 | for (field,_ty) in fields{ 27 | tb.add("self .").ident(&field).add(". ser_bin ( s ) ;"); 28 | } 29 | } 30 | else{ 31 | return parser.unexpected() 32 | } 33 | tb.add("} } ;"); 34 | return tb.end(); 35 | } 36 | } 37 | else if parser.eat_ident("enum"){ 38 | if let Some(name) = parser.eat_any_ident(){ 39 | let generic = parser.eat_generic(); 40 | let where_clause = parser.eat_where_clause(Some("SerBin")); 41 | 42 | tb.add("impl").stream(generic.clone()); 43 | tb.add("SerBin for").ident(&name).stream(generic).stream(where_clause); 44 | tb.add("{ fn ser_bin ( & self , s : & mut Vec < u8 > ) {"); 45 | tb.add("match self {"); 46 | 47 | if !parser.open_brace(){ 48 | return parser.unexpected() 49 | } 50 | let mut index = 0; 51 | while !parser.eat_eot(){ 52 | // parse ident 53 | if let Some(variant) = parser.eat_any_ident(){ 54 | if let Some(types) = parser.eat_all_types(){ 55 | tb.add("Self ::").ident(&variant).add("("); 56 | for i in 0..types.len(){ 57 | tb.ident(&format!("n{}", i)).add(","); 58 | } 59 | tb.add(") => {").suf_u16(index).add(". ser_bin ( s ) ;"); 60 | for i in 0..types.len(){ 61 | tb.ident(&format!("n{}", i)).add(". ser_bin ( s ) ;"); 62 | } 63 | tb.add("}"); 64 | } 65 | else if let Some(fields) = parser.eat_all_struct_fields(){ // named variant 66 | tb.add("Self ::").ident(&variant).add("{"); 67 | for (field, _ty) in fields.iter(){ 68 | tb.ident(field).add(","); 69 | } 70 | tb.add("} => {").suf_u16(index).add(". ser_bin ( s ) ;"); 71 | for (field, _ty) in fields{ 72 | tb.ident(&field).add(". ser_bin ( s ) ;"); 73 | } 74 | tb.add("}"); 75 | } 76 | else if parser.is_punct(',') || parser.is_eot(){ // bare variant 77 | tb.add("Self ::").ident(&variant).add("=> {"); 78 | tb.suf_u16(index).add(". ser_bin ( s ) ; }"); 79 | } 80 | else{ 81 | return parser.unexpected(); 82 | } 83 | index += 1; 84 | parser.eat_punct(','); 85 | } 86 | else{ 87 | return parser.unexpected() 88 | } 89 | } 90 | tb.add("} } } ;"); 91 | return tb.end(); 92 | } 93 | } 94 | return parser.unexpected() 95 | } 96 | 97 | pub fn derive_de_bin_impl(input: TokenStream) -> TokenStream { 98 | let mut parser = TokenParser::new(input); 99 | let mut tb = TokenBuilder::new(); 100 | 101 | parser.eat_ident("pub"); 102 | if parser.eat_ident("struct"){ 103 | if let Some(name) = parser.eat_any_ident(){ 104 | let generic = parser.eat_generic(); 105 | let types = parser.eat_all_types(); 106 | let where_clause = parser.eat_where_clause(Some("DeBin")); 107 | 108 | tb.add("impl").stream(generic.clone()); 109 | tb.add("DeBin for").ident(&name).stream(generic).stream(where_clause); 110 | tb.add("{ fn de_bin ( o : & mut usize , d : & [ u8 ] )"); 111 | tb.add("-> std :: result :: Result < Self , microserde :: DeBinErr > { "); 112 | tb.add("std :: result :: Result :: Ok ( Self"); 113 | 114 | if let Some(types) = types{ 115 | tb.add("("); 116 | for _ in 0..types.len(){ 117 | tb.add("DeBin :: de_bin ( o , d ) ? ,"); 118 | } 119 | tb.add(")"); 120 | } 121 | else if let Some(fields) = parser.eat_all_struct_fields(){ 122 | tb.add("{"); 123 | for (field,_ty) in fields{ 124 | tb.ident(&field).add(": DeBin :: de_bin ( o , d ) ? ,"); 125 | } 126 | tb.add("}"); 127 | } 128 | else{ 129 | return parser.unexpected() 130 | } 131 | tb.add(") } } ;"); 132 | return tb.end(); 133 | } 134 | } 135 | else if parser.eat_ident("enum"){ 136 | if let Some(name) = parser.eat_any_ident(){ 137 | let generic = parser.eat_generic(); 138 | let where_clause = parser.eat_where_clause(Some("DeBin")); 139 | 140 | tb.add("impl").stream(generic.clone()); 141 | tb.add("DeBin for").ident(&name).stream(generic).stream(where_clause); 142 | tb.add("{ fn de_bin ( o : & mut usize , d : & [ u8 ] )"); 143 | tb.add("-> std :: result :: Result < Self , microserde :: DeBinErr > {"); 144 | tb.add("let id : u16 = DeBin :: de_bin ( o , d ) ? ;"); 145 | tb.add("match id {"); 146 | 147 | if !parser.open_brace(){ 148 | return parser.unexpected() 149 | } 150 | let mut index = 0; 151 | while !parser.eat_eot(){ 152 | // parse ident 153 | if let Some(variant) = parser.eat_any_ident(){ 154 | tb.suf_u16(index as u16).add("=> {"); 155 | tb.add("std :: result :: Result :: Ok ( Self ::"); 156 | if let Some(types) = parser.eat_all_types(){ 157 | tb.ident(&variant).add("("); 158 | for _ in 0..types.len(){ 159 | tb.add("DeBin :: de_bin ( o , d ) ? ,"); 160 | } 161 | tb.add(")"); 162 | } 163 | else if let Some(fields) = parser.eat_all_struct_fields(){ // named variant 164 | tb.ident(&variant).add("{"); 165 | for (field, _ty) in fields.iter(){ 166 | tb.ident(field).add(": DeBin :: de_bin ( o , d ) ? ,"); 167 | } 168 | tb.add("}"); 169 | } 170 | else if parser.is_punct(',') || parser.is_eot(){ // bare variant 171 | tb.ident(&variant); 172 | } 173 | else{ 174 | return parser.unexpected(); 175 | } 176 | 177 | tb.add(") }"); 178 | index += 1; 179 | parser.eat_punct(','); 180 | } 181 | else{ 182 | return parser.unexpected() 183 | } 184 | } 185 | tb.add("_ => std :: result :: Result :: Err ( microserde :: DeBinErr { o : * o , l :"); 186 | tb.unsuf_usize(1).add(", s : d . len ( ) } )"); 187 | tb.add("} } } ;"); 188 | return tb.end(); 189 | } 190 | } 191 | return parser.unexpected() 192 | } 193 | -------------------------------------------------------------------------------- /src/serde_bin.rs: -------------------------------------------------------------------------------- 1 | use std::collections::{HashMap}; 2 | use std::hash::Hash; 3 | 4 | pub trait SerBin { 5 | fn serialize_bin(&self)->Vec{ 6 | let mut s = Vec::new(); 7 | self.ser_bin(&mut s); 8 | s 9 | } 10 | 11 | fn ser_bin(&self, s: &mut Vec); 12 | } 13 | 14 | pub trait DeBin:Sized { 15 | fn deserialize_bin(d:&[u8])->Result{ 16 | DeBin::de_bin(&mut 0, d) 17 | } 18 | 19 | fn de_bin(o:&mut usize, d:&[u8]) -> Result; 20 | } 21 | 22 | 23 | pub struct DeBinErr{ 24 | pub o:usize, 25 | pub l: usize, 26 | pub s: usize 27 | } 28 | 29 | impl std::fmt::Debug for DeBinErr { 30 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 31 | write!(f, "Bin deserialize error at:{} wanted:{} bytes but max size is {}", self.o, self.l, self.s) 32 | } 33 | } 34 | 35 | macro_rules! impl_ser_de_bin_for { 36 | ($ty:ident) => { 37 | impl SerBin for $ty { 38 | fn ser_bin(&self, s: &mut Vec) { 39 | let du8 = unsafe {std::mem::transmute::<&$ty, &[u8; std::mem::size_of::<$ty>()]>(&self)}; 40 | s.extend_from_slice(du8); 41 | } 42 | } 43 | 44 | impl DeBin for $ty { 45 | fn de_bin(o:&mut usize, d:&[u8]) -> Result<$ty, DeBinErr> { 46 | let l = std::mem::size_of::<$ty>(); 47 | if *o + l > d.len(){ 48 | return Err(DeBinErr{o:*o, l:l, s:d.len()}) 49 | } 50 | let mut m = [0 as $ty]; 51 | unsafe {std::ptr::copy_nonoverlapping(d.as_ptr().offset(*o as isize) as *const $ty, m.as_mut_ptr() as *mut $ty, 1)} 52 | *o += l; 53 | Ok(m[0]) 54 | } 55 | } 56 | }; 57 | } 58 | 59 | impl_ser_de_bin_for!(f64); 60 | impl_ser_de_bin_for!(f32); 61 | impl_ser_de_bin_for!(u64); 62 | impl_ser_de_bin_for!(i64); 63 | impl_ser_de_bin_for!(u32); 64 | impl_ser_de_bin_for!(i32); 65 | impl_ser_de_bin_for!(u16); 66 | impl_ser_de_bin_for!(i16); 67 | 68 | impl SerBin for usize { 69 | fn ser_bin(&self, s: &mut Vec) { 70 | let u64usize = *self as u64; 71 | let du8 = unsafe {std::mem::transmute::<&u64, &[u8; std::mem::size_of::()]>(&u64usize)}; 72 | s.extend_from_slice(du8); 73 | } 74 | } 75 | 76 | impl DeBin for usize { 77 | fn de_bin(o:&mut usize, d:&[u8]) -> Result { 78 | let l = std::mem::size_of::(); 79 | if *o + l > d.len(){ 80 | return Err(DeBinErr{o:*o, l:l, s:d.len()}) 81 | } 82 | let mut m = [0 as u64]; 83 | unsafe {std::ptr::copy_nonoverlapping(d.as_ptr().offset(*o as isize) as *const u64, m.as_mut_ptr() as *mut u64, 1)} 84 | *o += l; 85 | Ok(m[0] as usize) 86 | } 87 | } 88 | 89 | impl DeBin for u8 { 90 | fn de_bin(o:&mut usize, d:&[u8]) -> Result { 91 | if *o + 1 > d.len(){ 92 | return Err(DeBinErr{o:*o, l:1, s:d.len()}) 93 | } 94 | let m = d[*o]; 95 | *o += 1; 96 | Ok(m) 97 | } 98 | } 99 | 100 | impl SerBin for u8 { 101 | fn ser_bin(&self, s: &mut Vec) { 102 | s.push(*self); 103 | } 104 | } 105 | 106 | impl SerBin for bool { 107 | fn ser_bin(&self, s: &mut Vec) { 108 | s.push(if *self {1} else {0}); 109 | } 110 | } 111 | 112 | impl DeBin for bool { 113 | fn de_bin(o:&mut usize, d:&[u8]) -> Result { 114 | if *o + 1 > d.len(){ 115 | return Err(DeBinErr{o:*o, l:1, s:d.len()}) 116 | } 117 | let m = d[*o]; 118 | *o += 1; 119 | if m == 0{Ok(false)} else {Ok(true)} 120 | } 121 | } 122 | 123 | impl SerBin for String { 124 | fn ser_bin(&self, s: &mut Vec) { 125 | let len = self.len(); 126 | len.ser_bin(s); 127 | s.extend_from_slice(self.as_bytes()); 128 | } 129 | } 130 | 131 | impl DeBin for String { 132 | fn de_bin(o:&mut usize, d:&[u8])->Result { 133 | let len:usize = DeBin::de_bin(o,d)?; 134 | if *o + len > d.len(){ 135 | return Err(DeBinErr{o:*o, l:1, s:d.len()}) 136 | } 137 | let r = std::str::from_utf8(&d[*o..(*o+len)]).unwrap().to_string(); 138 | *o += len; 139 | Ok(r) 140 | } 141 | } 142 | 143 | impl SerBin for Vec where T: SerBin { 144 | fn ser_bin(&self, s: &mut Vec) { 145 | let len = self.len(); 146 | len.ser_bin(s); 147 | for item in self { 148 | item.ser_bin(s); 149 | } 150 | } 151 | } 152 | 153 | impl DeBin for Vec where T:DeBin{ 154 | fn de_bin(o:&mut usize, d:&[u8])->Result, DeBinErr> { 155 | let len:usize = DeBin::de_bin(o,d)?; 156 | let mut out = Vec::new(); 157 | for _ in 0..len{ 158 | out.push(DeBin::de_bin(o,d)?) 159 | } 160 | Ok(out) 161 | } 162 | } 163 | 164 | impl SerBin for Option where T: SerBin { 165 | fn ser_bin(&self, s: &mut Vec) { 166 | if let Some(v) = self{ 167 | s.push(1); 168 | v.ser_bin(s); 169 | } 170 | else{ 171 | s.push(0); 172 | } 173 | } 174 | } 175 | 176 | impl DeBin for Option where T:DeBin{ 177 | fn de_bin(o:&mut usize, d:&[u8])->Result, DeBinErr> { 178 | if *o + 1 > d.len(){ 179 | return Err(DeBinErr{o:*o, l:1, s:d.len()}) 180 | } 181 | let m = d[*o]; 182 | *o += 1; 183 | if m == 1{ 184 | Ok(Some(DeBin::de_bin(o,d)?)) 185 | } 186 | else{ 187 | Ok(None) 188 | } 189 | } 190 | } 191 | 192 | impl SerBin for [T] where T: SerBin { 193 | fn ser_bin(&self, s: &mut Vec) { 194 | for item in self { 195 | item.ser_bin(s); 196 | } 197 | } 198 | } 199 | 200 | 201 | unsafe fn de_bin_array_impl_inner(top: *mut T, count: usize, o:&mut usize, d:&[u8]) -> Result<(), DeBinErr> where T:DeBin{ 202 | for c in 0..count { 203 | top.add(c).write(DeBin::de_bin(o, d) ?); 204 | } 205 | Ok(()) 206 | } 207 | 208 | macro_rules!de_bin_array_impl { 209 | ( $($count:expr),*) => { 210 | $( 211 | impl DeBin for [T; $count] where T: DeBin { 212 | fn de_bin(o:&mut usize, d:&[u8]) -> Result { 214 | unsafe{ 215 | let mut to = std::mem::MaybeUninit::<[T; $count]>::uninit(); 216 | let top: *mut T = std::mem::transmute(&mut to); 217 | de_bin_array_impl_inner(top, $count, o, d)?; 218 | Ok(to.assume_init()) 219 | } 220 | } 221 | } 222 | )* 223 | } 224 | } 225 | 226 | de_bin_array_impl!(2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32); 227 | 228 | impl SerBin for (A,B) where A: SerBin, B:SerBin { 229 | fn ser_bin(&self, s: &mut Vec) { 230 | self.0.ser_bin(s); 231 | self.1.ser_bin(s); 232 | } 233 | } 234 | 235 | impl DeBin for (A,B) where A:DeBin, B:DeBin{ 236 | fn de_bin(o:&mut usize, d:&[u8])->Result<(A,B), DeBinErr> {Ok((DeBin::de_bin(o,d)?,DeBin::de_bin(o,d)?))} 237 | } 238 | 239 | impl SerBin for (A,B,C) where A: SerBin, B:SerBin, C:SerBin { 240 | fn ser_bin(&self, s: &mut Vec) { 241 | self.0.ser_bin(s); 242 | self.1.ser_bin(s); 243 | self.2.ser_bin(s); 244 | } 245 | } 246 | 247 | impl DeBin for (A,B,C) where A:DeBin, B:DeBin, C:DeBin{ 248 | fn de_bin(o:&mut usize, d:&[u8])->Result<(A,B,C), DeBinErr> {Ok((DeBin::de_bin(o,d)?,DeBin::de_bin(o,d)?,DeBin::de_bin(o,d)?))} 249 | } 250 | 251 | impl SerBin for (A,B,C,D) where A: SerBin, B:SerBin, C:SerBin, D:SerBin { 252 | fn ser_bin(&self, s: &mut Vec) { 253 | self.0.ser_bin(s); 254 | self.1.ser_bin(s); 255 | self.2.ser_bin(s); 256 | self.3.ser_bin(s); 257 | } 258 | } 259 | 260 | impl DeBin for (A,B,C,D) where A:DeBin, B:DeBin, C:DeBin, D:DeBin{ 261 | fn de_bin(o:&mut usize, d:&[u8])->Result<(A,B,C,D), DeBinErr> {Ok((DeBin::de_bin(o,d)?,DeBin::de_bin(o,d)?,DeBin::de_bin(o,d)?,DeBin::de_bin(o,d)?))} 262 | } 263 | 264 | impl SerBin for HashMap where K: SerBin, 265 | V: SerBin { 266 | fn ser_bin(&self, s: &mut Vec) { 267 | let len = self.len(); 268 | len.ser_bin(s); 269 | for (k, v) in self { 270 | k.ser_bin(s); 271 | v.ser_bin(s); 272 | } 273 | } 274 | } 275 | 276 | impl DeBin for HashMap where K: DeBin + Eq + Hash, 277 | V: DeBin { 278 | fn de_bin(o:&mut usize, d:&[u8])->Result{ 279 | let len:usize = DeBin::de_bin(o,d)?; 280 | let mut h = HashMap::new(); 281 | for _ in 0..len{ 282 | let k = DeBin::de_bin(o,d)?; 283 | let v = DeBin::de_bin(o,d)?; 284 | h.insert(k, v); 285 | } 286 | Ok(h) 287 | } 288 | } 289 | 290 | 291 | impl SerBin for Box where T: SerBin { 292 | fn ser_bin(&self, s: &mut Vec) { 293 | (**self).ser_bin(s) 294 | } 295 | } 296 | 297 | impl DeBin for Box where T: DeBin { 298 | fn de_bin(o:&mut usize, d:&[u8])->Result, DeBinErr> { 299 | Ok(Box::new(DeBin::de_bin(o,d)?)) 300 | } 301 | } -------------------------------------------------------------------------------- /src/toml.rs: -------------------------------------------------------------------------------- 1 | use std::collections::{HashMap}; 2 | use std::str::Chars; 3 | 4 | #[derive(Default)] 5 | pub struct TomlParser { 6 | pub cur: char, 7 | pub line: usize, 8 | pub col: usize 9 | } 10 | 11 | #[derive(PartialEq, Debug)] 12 | pub enum TomlTok { 13 | Ident(String), 14 | Str(String), 15 | U64(u64), 16 | I64(i64), 17 | F64(f64), 18 | Bool(bool), 19 | Nan(bool), 20 | Inf(bool), 21 | Date(String), 22 | Equals, 23 | BlockOpen, 24 | BlockClose, 25 | Comma, 26 | Bof, 27 | Eof 28 | } 29 | 30 | pub enum Toml{ 31 | Str(String), 32 | Bool(bool), 33 | Num(f64), 34 | Date(String), 35 | Array(Vec), 36 | } 37 | 38 | pub struct TomlErr{ 39 | pub msg:String, 40 | pub line:usize, 41 | pub col:usize 42 | } 43 | 44 | impl std::fmt::Debug for TomlErr { 45 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 46 | write!(f, "Toml error: {}, line:{} col:{}", self.msg, self.line+1, self.col+1) 47 | } 48 | } 49 | 50 | impl TomlParser { 51 | pub fn to_val(&mut self, tok:TomlTok, i: &mut Chars)->Result{ 52 | match tok{ 53 | TomlTok::BlockOpen=>{ 54 | let mut vals = Vec::new(); 55 | loop{ 56 | let tok = self.next_tok(i)?; 57 | if tok == TomlTok::BlockClose || tok == TomlTok::Eof{ 58 | break 59 | } 60 | if tok != TomlTok::Comma{ 61 | vals.push(self.to_val(tok, i)?); 62 | } 63 | } 64 | Ok(Toml::Array(vals)) 65 | }, 66 | TomlTok::Str(v)=>Ok(Toml::Str(v)), 67 | TomlTok::U64(v)=>Ok(Toml::Num(v as f64)), 68 | TomlTok::I64(v)=>Ok(Toml::Num(v as f64)), 69 | TomlTok::F64(v)=>Ok(Toml::Num(v as f64)), 70 | TomlTok::Bool(v)=>Ok(Toml::Bool(v)), 71 | TomlTok::Nan(v)=>Ok(Toml::Num(if v{-std::f64::NAN}else{std::f64::NAN})), 72 | TomlTok::Inf(v)=>Ok(Toml::Num(if v{-std::f64::INFINITY}else{std::f64::INFINITY})), 73 | TomlTok::Date(v)=>Ok(Toml::Date(v)), 74 | _=>Err(self.err_token(tok)) 75 | } 76 | } 77 | 78 | pub fn parse_key_value(&mut self, local_scope:&String, key:String, i: &mut Chars, out:&mut HashMap)->Result<(), TomlErr>{ 79 | let tok = self.next_tok(i)?; 80 | if tok != TomlTok::Equals{ 81 | return Err(self.err_token(tok)); 82 | } 83 | let tok = self.next_tok(i)?; 84 | let val = self.to_val(tok, i)?; 85 | let key = if local_scope.len()>0{ 86 | format!("{}.{}", local_scope, key) 87 | } 88 | else{ 89 | key 90 | }; 91 | out.insert(key, val); 92 | Ok(()) 93 | } 94 | 95 | pub fn parse(data:&str)->Result, TomlErr>{ 96 | let i = &mut data.chars(); 97 | let mut t = TomlParser::default(); 98 | t.next(i); 99 | let mut out = HashMap::new(); 100 | let mut local_scope = String::new(); 101 | loop{ 102 | let tok = t.next_tok(i)?; 103 | match tok{ 104 | TomlTok::Eof=>{ // at eof. 105 | return Ok(out); 106 | }, 107 | TomlTok::BlockOpen=>{ // its a scope 108 | // we should expect an ident or a string 109 | let tok = t.next_tok(i)?; 110 | match tok{ 111 | TomlTok::Str(key)=>{ // a key 112 | local_scope = key; 113 | }, 114 | TomlTok::Ident(key)=>{ // also a key 115 | local_scope = key; 116 | }, 117 | _=>return Err(t.err_token(tok)) 118 | } 119 | let tok = t.next_tok(i)?; 120 | if tok != TomlTok::BlockClose{ 121 | return Err(t.err_token(tok)) 122 | } 123 | }, 124 | TomlTok::Str(key)=>{ // a key 125 | t.parse_key_value(&local_scope, key, i, &mut out)?; 126 | }, 127 | TomlTok::Ident(key)=>{ // also a key 128 | t.parse_key_value(&local_scope, key, i, &mut out)?; 129 | }, 130 | _=>return Err(t.err_token(tok)) 131 | } 132 | } 133 | } 134 | 135 | pub fn next(&mut self, i: &mut Chars) { 136 | if let Some(c) = i.next() { 137 | self.cur = c; 138 | if self.cur == '\n' { 139 | self.line += 1; 140 | self.col = 0; 141 | } 142 | else { 143 | self.col = 0; 144 | } 145 | } 146 | else { 147 | self.cur = '\0'; 148 | } 149 | } 150 | 151 | pub fn err_token(&self, tok:TomlTok) -> TomlErr { 152 | TomlErr{msg:format!("Unexpected token {:?} ", tok), line:self.line, col:self.col} 153 | } 154 | 155 | pub fn err_parse(&self, what:&str) -> TomlErr { 156 | TomlErr{msg:format!("Cannot parse toml {} ", what), line:self.line, col:self.col} 157 | } 158 | 159 | pub fn next_tok(&mut self, i: &mut Chars) -> Result { 160 | while self.cur == '\n' || self.cur == '\r' || self.cur == '\t' || self.cur == ' ' { 161 | self.next(i); 162 | } 163 | loop{ 164 | if self.cur == '\0' { 165 | return Ok(TomlTok::Eof) 166 | } 167 | match self.cur { 168 | ',' => { 169 | self.next(i); 170 | return Ok(TomlTok::Comma) 171 | } 172 | '[' => { 173 | self.next(i); 174 | return Ok(TomlTok::BlockOpen) 175 | } 176 | ']' => { 177 | self.next(i); 178 | return Ok(TomlTok::BlockClose) 179 | } 180 | '=' => { 181 | self.next(i); 182 | return Ok(TomlTok::Equals) 183 | } 184 | '+' | '-' | '0'..='9' => { 185 | let mut num = String::new(); 186 | let is_neg = if self.cur == '-' { 187 | num.push(self.cur); 188 | self.next(i); 189 | true 190 | } 191 | else { 192 | if self.cur == '+' { 193 | self.next(i); 194 | } 195 | false 196 | }; 197 | if self.cur == 'n' { 198 | self.next(i); 199 | if self.cur == 'a' { 200 | self.next(i); 201 | if self.cur == 'n' { 202 | self.next(i); 203 | return Ok(TomlTok::Nan(is_neg)) 204 | } 205 | else { 206 | return Err(self.err_parse("nan")) 207 | } 208 | } 209 | else { 210 | return Err(self.err_parse("nan")) 211 | } 212 | } 213 | if self.cur == 'i' { 214 | self.next(i); 215 | if self.cur == 'n' { 216 | self.next(i); 217 | if self.cur == 'f' { 218 | self.next(i); 219 | return Ok(TomlTok::Inf(is_neg)) 220 | } 221 | else { 222 | return Err(self.err_parse("inf")) 223 | } 224 | } 225 | else { 226 | return Err(self.err_parse("nan")) 227 | } 228 | } 229 | while self.cur >= '0' && self.cur <= '9' || self.cur == '_' { 230 | if self.cur != '_' { 231 | num.push(self.cur); 232 | } 233 | self.next(i); 234 | } 235 | if self.cur == '.' { 236 | num.push(self.cur); 237 | self.next(i); 238 | while self.cur >= '0' && self.cur <= '9' || self.cur == '_' { 239 | if self.cur != '_' { 240 | num.push(self.cur); 241 | } 242 | self.next(i); 243 | } 244 | if let Ok(num) = num.parse() { 245 | return Ok(TomlTok::F64(num)) 246 | } 247 | else { 248 | return Err(self.err_parse("number")); 249 | } 250 | } 251 | else if self.cur == '-' { // lets assume its a date. whatever. i don't feel like more parsing today 252 | num.push(self.cur); 253 | self.next(i); 254 | while self.cur >= '0' && self.cur <= '9' || self.cur == ':' || self.cur == '-' || self.cur == 'T' { 255 | num.push(self.cur); 256 | self.next(i); 257 | } 258 | return Ok(TomlTok::Date(num)) 259 | } 260 | else { 261 | if is_neg { 262 | if let Ok(num) = num.parse() { 263 | return Ok(TomlTok::I64(num)) 264 | } 265 | else { 266 | return Err(self.err_parse("number")); 267 | } 268 | } 269 | if let Ok(num) = num.parse() { 270 | return Ok(TomlTok::U64(num)) 271 | } 272 | else { 273 | return Err(self.err_parse("number")); 274 | } 275 | } 276 | }, 277 | 'a'..='z' | 'A'..='Z' | '_' => { 278 | let mut ident = String::new(); 279 | while self.cur >= 'a' && self.cur <= 'z' 280 | || self.cur >= 'A' && self.cur <= 'Z' 281 | || self.cur == '_' || self.cur == '-' { 282 | ident.push(self.cur); 283 | self.next(i); 284 | } 285 | if self.cur == '.' { 286 | while self.cur == '.' { 287 | self.next(i); 288 | while self.cur >= 'a' && self.cur <= 'z' 289 | || self.cur >= 'A' && self.cur <= 'Z' 290 | || self.cur == '_' || self.cur == '-' { 291 | ident.push(self.cur); 292 | self.next(i); 293 | } 294 | } 295 | return Ok(TomlTok::Ident(ident)) 296 | } 297 | if ident == "true" { 298 | return Ok(TomlTok::Bool(true)) 299 | } 300 | if ident == "false" { 301 | return Ok(TomlTok::Bool(false)) 302 | } 303 | if ident == "inf" { 304 | return Ok(TomlTok::Inf(false)) 305 | } 306 | if ident == "nan" { 307 | return Ok(TomlTok::Nan(false)) 308 | } 309 | return Ok(TomlTok::Ident(ident)) 310 | }, 311 | '#' =>{ 312 | while self.cur !='\n' && self.cur != '\0'{ 313 | self.next(i); 314 | } 315 | }, 316 | '"' => { 317 | let mut val = String::new(); 318 | self.next(i); 319 | while self.cur != '"' { 320 | if self.cur == '\\' { 321 | self.next(i); 322 | } 323 | if self.cur == '\0' { 324 | return Err(self.err_parse("string")); 325 | } 326 | val.push(self.cur); 327 | self.next(i); 328 | } 329 | self.next(i); 330 | return Ok(TomlTok::Str(val)) 331 | }, 332 | _ => { 333 | return Err(self.err_parse("tokenizer")); 334 | } 335 | } 336 | } 337 | } 338 | } -------------------------------------------------------------------------------- /derive/src/derive_ron.rs: -------------------------------------------------------------------------------- 1 | 2 | use proc_macro::{TokenStream}; 3 | use crate::macro_lib::*; 4 | 5 | pub fn derive_ser_ron_impl(input: TokenStream) -> TokenStream { 6 | 7 | let mut parser = TokenParser::new(input); 8 | let mut tb = TokenBuilder::new(); 9 | 10 | parser.eat_ident("pub"); 11 | if parser.eat_ident("struct"){ 12 | if let Some(name) = parser.eat_any_ident(){ 13 | 14 | let generic = parser.eat_generic(); 15 | let types = parser.eat_all_types(); 16 | let where_clause = parser.eat_where_clause(Some("SerRon")); 17 | 18 | tb.add("impl").stream(generic.clone()); 19 | tb.add("SerRon for").ident(&name).stream(generic).stream(where_clause); 20 | tb.add("{ fn ser_ron ( & self , d : usize , s : & mut microserde :: SerRonState ) {"); 21 | 22 | if let Some(types) = types{ 23 | tb.add("s . out . push (").chr('(').add(") ;"); 24 | for i in 0..types.len(){ 25 | tb.add("self .").unsuf_usize(i).add(". ser_ron ( d , s ) ;"); 26 | if i != types.len() - 1{ 27 | tb.add("s . out . push_str (").string(", ").add(") ;"); 28 | } 29 | } 30 | tb.add("s . out . push (").chr(')').add(") ;"); 31 | } 32 | else if let Some(fields) = parser.eat_all_struct_fields(){ 33 | tb.add("s . st_pre ( ) ;"); 34 | // named struct 35 | for (field,ty) in fields{ 36 | if ty.into_iter().next().unwrap().to_string() == "Option"{ 37 | tb.add("if let Some ( t ) = ").add("& self .").ident(&field).add("{"); 38 | tb.add("s . field ( d + 1 ,").string(&field).add(") ;"); 39 | tb.add("t . ser_ron ( d + 1 , s ) ; s . conl ( ) ; } ;"); 40 | } 41 | else{ 42 | tb.add("s . field ( d + 1 ,").string(&field).add(" ) ;"); 43 | tb.add("self .").ident(&field).add(". ser_ron ( d + 1 , s ) ; s . conl ( ) ;"); 44 | } 45 | } 46 | tb.add("s . st_post ( d ) ;"); 47 | } 48 | else{ 49 | return parser.unexpected() 50 | } 51 | tb.add("} } ;"); 52 | return tb.end(); 53 | } 54 | } 55 | else if parser.eat_ident("enum"){ 56 | if let Some(name) = parser.eat_any_ident(){ 57 | let generic = parser.eat_generic(); 58 | let where_clause = parser.eat_where_clause(Some("SerRon")); 59 | 60 | tb.add("impl").stream(generic.clone()); 61 | tb.add("SerRon for").ident(&name).stream(generic).stream(where_clause); 62 | tb.add("{ fn ser_ron ( & self , d : usize , s : & mut microserde :: SerRonState ) {"); 63 | tb.add("match self {"); 64 | 65 | if !parser.open_brace(){ 66 | return parser.unexpected() 67 | } 68 | 69 | while !parser.eat_eot(){ 70 | // parse ident 71 | if let Some(variant) = parser.eat_any_ident(){ 72 | if let Some(types) = parser.eat_all_types(){ 73 | 74 | tb.add("Self ::").ident(&variant).add("("); 75 | for i in 0..types.len(){ 76 | tb.ident(&format!("n{}", i)).add(","); 77 | } 78 | tb.add(") => {"); 79 | tb.add("s . out . push_str (").string(&variant).add(") ;"); 80 | tb.add("s . out . push (").chr('(').add(") ;"); 81 | 82 | for i in 0..types.len(){ 83 | tb.ident(&format!("n{}", i)).add(". ser_ron ( d , s ) ;"); 84 | if i != types.len() - 1{ 85 | tb.add("s . out . push_str (").string(", ").add(") ;"); 86 | } 87 | } 88 | tb.add("s . out . push (").chr(')').add(") ;"); 89 | tb.add("}"); 90 | } 91 | else if let Some(fields) = parser.eat_all_struct_fields(){ // named variant 92 | tb.add("Self ::").ident(&variant).add("{"); 93 | for (field, _ty) in fields.iter(){ 94 | tb.ident(field).add(","); 95 | } 96 | tb.add("} => {"); 97 | 98 | tb.add("s . out . push_str (").string(&variant).add(") ;"); 99 | tb.add("s . st_pre ( ) ;"); 100 | 101 | for (field, ty) in fields{ 102 | if ty.into_iter().next().unwrap().to_string() == "Option"{ 103 | tb.add("if ").ident(&field).add(". is_some ( ) {"); 104 | tb.add("s . field ( d + 1 ,").string(&field).add(") ;"); 105 | tb.ident(&field).add(" . ser_ron ( d + 1 , s ) ; s . conl ( ) ; } ;"); 106 | } 107 | else{ 108 | tb.add("s . field ( d + 1 ,").string(&field).add(" ) ;"); 109 | tb.ident(&field).add(". ser_ron ( d + 1 , s ) ; s . conl ( ) ;"); 110 | } 111 | } 112 | tb.add("s . st_post ( d ) ; }"); 113 | } 114 | else if parser.is_punct(',') || parser.is_eot(){ // bare variant 115 | tb.add("Self ::").ident(&variant).add("=> {"); 116 | tb.add("s . out . push_str (").string(&variant).add(") ; }"); 117 | } 118 | else{ 119 | return parser.unexpected(); 120 | } 121 | parser.eat_punct(','); 122 | } 123 | else{ 124 | return parser.unexpected() 125 | } 126 | } 127 | tb.add("}"); 128 | tb.add("} } ;"); 129 | return tb.end(); 130 | } 131 | } 132 | return parser.unexpected() 133 | } 134 | 135 | pub fn derive_de_ron_impl(input: TokenStream) -> TokenStream { 136 | let mut parser = TokenParser::new(input); 137 | let mut tb = TokenBuilder::new(); 138 | parser.eat_ident("pub"); 139 | if parser.eat_ident("struct"){ 140 | if let Some(name) = parser.eat_any_ident(){ 141 | let generic = parser.eat_generic(); 142 | let types = parser.eat_all_types(); 143 | let where_clause = parser.eat_where_clause(Some("DeRon")); 144 | 145 | tb.add("impl").stream(generic.clone()); 146 | tb.add("DeRon for").ident(&name).stream(generic).stream(where_clause); 147 | tb.add("{ fn de_ron ( s : & mut microserde :: DeRonState , i : & mut std :: str :: Chars )"); 148 | tb.add("-> std :: result :: Result < Self , microserde :: DeRonErr > { "); 149 | 150 | if let Some(types) = types{ 151 | tb.add("s . paren_open ( i ) ? ;"); 152 | tb.add("let r = Self"); 153 | tb.add("("); 154 | for _ in 0..types.len(){ 155 | tb.add("{ let r = DeRon :: de_ron ( s , i ) ? ; s . eat_comma_paren ( i ) ? ; r } ,"); 156 | } 157 | tb.add(") ;"); 158 | tb.add("s . paren_close ( i ) ? ;"); 159 | tb.add("std :: result :: Result :: Ok ( r ) "); 160 | } 161 | else if let Some(fields) = parser.eat_all_struct_fields(){ 162 | tb.add("s . paren_open ( i ) ? ;"); 163 | for (field,_ty) in &fields{ 164 | tb.add("let mut").ident(&format!("_{}",field)).add("= None ;"); 165 | } 166 | tb.add("while let Some ( _ ) = s . next_ident ( ) {"); 167 | tb.add("match s . identbuf . as_ref ( ) {"); 168 | for (field,_ty) in &fields{ 169 | tb.string(&field).add("=> { s . next_colon ( i ) ? ;"); 170 | tb.ident(&format!("_{}",field)).add("= Some ( DeRon :: de_ron ( s , i ) ? ) ; } ,"); 171 | } 172 | tb.add("_ => return std :: result :: Result :: Err ( s . err_exp ( & s . identbuf ) )"); 173 | tb.add("} ; s . eat_comma_paren ( i ) ? ;"); 174 | tb.add("} ; s . paren_close ( i ) ? ;"); 175 | 176 | tb.add("std :: result :: Result :: Ok ( Self {"); 177 | for (field,ty) in fields{ 178 | tb.ident(&field).add(":"); 179 | if ty.into_iter().next().unwrap().to_string() == "Option"{ 180 | tb.add("if let Some ( t ) =").ident(&format!("_{}",field)); 181 | tb.add("{ t } else { None } ,"); 182 | } 183 | else{ 184 | tb.add("if let Some ( t ) =").ident(&format!("_{}",field)); 185 | tb.add("{ t } else { return Err ( s . err_nf ("); 186 | tb.string(&field).add(") ) } ,"); 187 | } 188 | } 189 | tb.add("} )"); 190 | } 191 | else{ 192 | return parser.unexpected() 193 | } 194 | tb.add("} } ;"); 195 | return tb.end(); 196 | } 197 | } 198 | else if parser.eat_ident("enum"){ 199 | 200 | if let Some(name) = parser.eat_any_ident(){ 201 | let generic = parser.eat_generic(); 202 | let where_clause = parser.eat_where_clause(Some("DeRon")); 203 | 204 | tb.add("impl").stream(generic.clone()); 205 | tb.add("DeRon for").ident(&name).stream(generic).stream(where_clause); 206 | tb.add("{ fn de_ron ( s : & mut microserde :: DeRonState , i : & mut std :: str :: Chars )"); 207 | tb.add("-> std :: result :: Result < Self , microserde :: DeRonErr > { "); 208 | tb.add("s . ident ( i ) ? ;"); 209 | tb.add("std :: result :: Result :: Ok ( match s . identbuf . as_ref ( ) {"); 210 | 211 | if !parser.open_brace(){ 212 | return parser.unexpected() 213 | } 214 | while !parser.eat_eot(){ 215 | // parse ident 216 | if let Some(variant) = parser.eat_any_ident(){ 217 | tb.string(&variant).add("=> {"); 218 | if let Some(types) = parser.eat_all_types(){ 219 | 220 | tb.add("s . paren_open ( i ) ? ;"); 221 | tb.add("let r = Self ::").ident(&variant).add("("); 222 | for _ in 0..types.len(){ 223 | tb.add("{ let r = DeRon :: de_ron ( s , i ) ? ; s . eat_comma_paren ( i ) ? ; r } ,"); 224 | } 225 | tb.add(") ;"); 226 | tb.add("s . paren_close ( i ) ? ; r"); 227 | } 228 | else if let Some(fields) = parser.eat_all_struct_fields(){ // named variant 229 | tb.add("s . paren_open ( i ) ? ;"); 230 | for (field,_ty) in &fields{ 231 | tb.add("let mut").ident(&format!("_{}",field)).add("= None ;"); 232 | } 233 | tb.add("while let Some ( _ ) = s . next_ident ( ) {"); 234 | tb.add("match s . identbuf . as_ref ( ) {"); 235 | for (field,_ty) in &fields{ 236 | tb.string(&field).add("=> { s . next_colon ( i ) ? ;"); 237 | tb.ident(&format!("_{}",field)).add("= Some ( DeRon :: de_ron ( s , i ) ? ) ; } ,"); 238 | } 239 | tb.add("_ => return std :: result :: Result :: Err ( s . err_exp ( & s . strbuf ) )"); 240 | tb.add("} ; s . eat_comma_paren ( i ) ? ;"); 241 | tb.add("} ; s . paren_close ( i ) ? ;"); 242 | 243 | tb.add("Self ::").ident(&variant).add("{"); 244 | for (field,ty) in fields{ 245 | tb.ident(&field).add(":"); 246 | if ty.into_iter().next().unwrap().to_string() == "Option"{ 247 | tb.add("if let Some ( t ) =").ident(&format!("_{}",field)); 248 | tb.add("{ t } else { None } ,"); 249 | } 250 | else{ 251 | tb.add("if let Some ( t ) =").ident(&format!("_{}",field)); 252 | tb.add("{ t } else { return Err ( s . err_nf ("); 253 | tb.string(&field).add(") ) } ,"); 254 | } 255 | } 256 | tb.add("}"); 257 | } 258 | else if parser.is_punct(',') || parser.is_eot(){ // bare variant 259 | tb.add("Self ::").ident(&variant); 260 | } 261 | else{ 262 | return parser.unexpected(); 263 | } 264 | 265 | tb.add("}"); 266 | parser.eat_punct(','); 267 | } 268 | else{ 269 | return parser.unexpected() 270 | } 271 | } 272 | tb.add("_ => return std :: result :: Result :: Err ( s . err_enum ( & s . identbuf ) )"); 273 | tb.add("} ) } }"); 274 | return tb.end(); 275 | } 276 | } 277 | return parser.unexpected() 278 | } 279 | -------------------------------------------------------------------------------- /derive/src/derive_json.rs: -------------------------------------------------------------------------------- 1 | use proc_macro::{TokenStream}; 2 | use crate::macro_lib::*; 3 | 4 | pub fn derive_ser_json_impl(input: TokenStream) -> TokenStream { 5 | 6 | let mut parser = TokenParser::new(input); 7 | let mut tb = TokenBuilder::new(); 8 | 9 | parser.eat_ident("pub"); 10 | if parser.eat_ident("struct"){ 11 | if let Some(name) = parser.eat_any_ident(){ 12 | 13 | let generic = parser.eat_generic(); 14 | let types = parser.eat_all_types(); 15 | let where_clause = parser.eat_where_clause(Some("SerJson")); 16 | 17 | tb.add("impl").stream(generic.clone()); 18 | tb.add("SerJson for").ident(&name).stream(generic).stream(where_clause); 19 | tb.add("{ fn ser_json ( & self , d : usize , s : & mut microserde :: SerJsonState ) {"); 20 | 21 | if let Some(types) = types{ 22 | tb.add("s . out . push (").chr('[').add(") ;"); 23 | for i in 0..types.len(){ 24 | tb.add("self .").unsuf_usize(i).add(". ser_json ( d , s ) ;"); 25 | if i != types.len() - 1{ 26 | tb.add("s . out . push (").chr(',').add(") ;"); 27 | } 28 | } 29 | tb.add("s . out . push (").chr(']').add(") ;"); 30 | } 31 | else if let Some(fields) = parser.eat_all_struct_fields(){ 32 | tb.add("s . st_pre ( ) ;"); 33 | // named struct 34 | for (field,ty) in fields{ 35 | if ty.into_iter().next().unwrap().to_string() == "Option"{ 36 | tb.add("if let Some ( t ) = ").add("& self .").ident(&field).add("{"); 37 | tb.add("s . field ( d + 1 ,").string(&field).add(") ;"); 38 | tb.add("t . ser_json ( d + 1 , s ) ; s . conl ( ) ; } ;"); 39 | } 40 | else{ 41 | tb.add("s . field ( d + 1 ,").string(&field).add(" ) ;"); 42 | tb.add("self .").ident(&field).add(". ser_json ( d + 1 , s ) ; s . conl ( ) ;"); 43 | } 44 | } 45 | tb.add("s . st_post ( d ) ;"); 46 | } 47 | else{ 48 | return parser.unexpected() 49 | } 50 | tb.add("} } ;"); 51 | return tb.end(); 52 | } 53 | } 54 | else if parser.eat_ident("enum"){ 55 | if let Some(name) = parser.eat_any_ident(){ 56 | let generic = parser.eat_generic(); 57 | let where_clause = parser.eat_where_clause(Some("SerJson")); 58 | 59 | tb.add("impl").stream(generic.clone()); 60 | tb.add("SerJson for").ident(&name).stream(generic).stream(where_clause); 61 | tb.add("{ fn ser_json ( & self , d : usize , s : & mut microserde :: SerJsonState ) {"); 62 | tb.add("s . out . push (").chr('{').add(") ;"); 63 | tb.add("match self {"); 64 | 65 | if !parser.open_brace(){ 66 | return parser.unexpected() 67 | } 68 | 69 | while !parser.eat_eot(){ 70 | // parse ident 71 | if let Some(variant) = parser.eat_any_ident(){ 72 | if let Some(types) = parser.eat_all_types(){ 73 | 74 | tb.add("Self ::").ident(&variant).add("("); 75 | for i in 0..types.len(){ 76 | tb.ident(&format!("n{}", i)).add(","); 77 | } 78 | tb.add(") => {"); 79 | tb.add("s . label (").string(&variant).add(") ;"); 80 | tb.add("s . out . push (").chr(':').add(") ;"); 81 | tb.add("s . out . push (").chr('[').add(") ;"); 82 | 83 | for i in 0..types.len(){ 84 | tb.ident(&format!("n{}", i)).add(". ser_json ( d , s ) ;"); 85 | if i != types.len() - 1{ 86 | tb.add("s . out . push (").chr(',').add(") ;"); 87 | } 88 | } 89 | tb.add("s . out . push (").chr(']').add(") ;"); 90 | tb.add("}"); 91 | } 92 | else if let Some(fields) = parser.eat_all_struct_fields(){ // named variant 93 | tb.add("Self ::").ident(&variant).add("{"); 94 | for (field, _ty) in fields.iter(){ 95 | tb.ident(field).add(","); 96 | } 97 | tb.add("} => {"); 98 | 99 | tb.add("s . label (").string(&variant).add(") ;"); 100 | tb.add("s . out . push (").chr(':').add(") ;"); 101 | tb.add("s . st_pre ( ) ;"); 102 | 103 | for (field, ty) in fields{ 104 | if ty.into_iter().next().unwrap().to_string() == "Option"{ 105 | tb.add("if let Some ( t ) = ").ident(&field).add("{"); 106 | tb.add("s . field ( d + 1 ,").string(&field).add(") ;"); 107 | tb.add("t . ser_json ( d + 1 , s ) ; s . conl ( ) ; } ;"); 108 | } 109 | else{ 110 | tb.add("s . field ( d + 1 ,").string(&field).add(" ) ;"); 111 | tb.ident(&field).add(". ser_json ( d + 1 , s ) ; s . conl ( ) ;"); 112 | } 113 | } 114 | tb.add("s . st_post ( d ) ; }"); 115 | } 116 | else if parser.is_punct(',') || parser.is_eot(){ // bare variant 117 | tb.add("Self ::").ident(&variant).add("=> {"); 118 | tb.add("s . label (").string(&variant).add(") ;"); 119 | tb.add("s . out . push_str (").string(":[]").add(") ; }"); 120 | } 121 | else{ 122 | return parser.unexpected(); 123 | } 124 | parser.eat_punct(','); 125 | } 126 | else{ 127 | return parser.unexpected() 128 | } 129 | } 130 | tb.add("}"); 131 | tb.add("s . out . push (").chr('}').add(") ;"); 132 | tb.add("} } ;"); 133 | return tb.end(); 134 | } 135 | } 136 | return parser.unexpected() 137 | } 138 | 139 | pub fn derive_de_json_impl(input: TokenStream) -> TokenStream { 140 | let mut parser = TokenParser::new(input); 141 | let mut tb = TokenBuilder::new(); 142 | 143 | parser.eat_ident("pub"); 144 | if parser.eat_ident("struct"){ 145 | if let Some(name) = parser.eat_any_ident(){ 146 | let generic = parser.eat_generic(); 147 | let types = parser.eat_all_types(); 148 | let where_clause = parser.eat_where_clause(Some("DeJson")); 149 | 150 | tb.add("impl").stream(generic.clone()); 151 | tb.add("DeJson for").ident(&name).stream(generic).stream(where_clause); 152 | tb.add("{ fn de_json ( s : & mut microserde :: DeJsonState , i : & mut std :: str :: Chars )"); 153 | tb.add("-> std :: result :: Result < Self , microserde :: DeJsonErr > { "); 154 | 155 | if let Some(types) = types{ 156 | tb.add("s . block_open ( i ) ? ;"); 157 | tb.add("let r = Self"); 158 | tb.add("("); 159 | for _ in 0..types.len(){ 160 | tb.add("{ let r = DeJson :: de_json ( s , i ) ? ; s . eat_comma_block ( i ) ? ; r } ,"); 161 | } 162 | tb.add(") ;"); 163 | tb.add("s . block_close ( i ) ? ;"); 164 | tb.add("std :: result :: Result :: Ok ( r )"); 165 | } 166 | else if let Some(fields) = parser.eat_all_struct_fields(){ 167 | tb.add("s . curly_open ( i ) ? ;"); 168 | for (field,_ty) in &fields{ 169 | tb.add("let mut").ident(&format!("_{}",field)).add("= None ;"); 170 | } 171 | tb.add("while let Some ( _ ) = s . next_str ( ) {"); 172 | tb.add("match s . strbuf . as_ref ( ) {"); 173 | for (field,_ty) in &fields{ 174 | tb.string(&field).add("=> { s . next_colon ( i ) ? ;"); 175 | tb.ident(&format!("_{}",field)).add("= Some ( DeJson :: de_json ( s , i ) ? ) ; } ,"); 176 | } 177 | tb.add("_ => return std :: result :: Result :: Err ( s . err_exp ( & s . strbuf ) )"); 178 | tb.add("} ; s . eat_comma_curly ( i ) ? ;"); 179 | tb.add("} ; s . curly_close ( i ) ? ;"); 180 | 181 | tb.add("std :: result :: Result :: Ok ( Self {"); 182 | for (field,ty) in fields{ 183 | tb.ident(&field).add(":"); 184 | if ty.into_iter().next().unwrap().to_string() == "Option"{ 185 | tb.add("if let Some ( t ) =").ident(&format!("_{}",field)); 186 | tb.add("{ t } else { None } ,"); 187 | } 188 | else{ 189 | tb.add("if let Some ( t ) =").ident(&format!("_{}",field)); 190 | tb.add("{ t } else { return Err ( s . err_nf ("); 191 | tb.string(&field).add(") ) } ,"); 192 | } 193 | } 194 | tb.add("} )"); 195 | } 196 | else{ 197 | return parser.unexpected() 198 | } 199 | tb.add("} } ;"); 200 | return tb.end(); 201 | } 202 | } 203 | else if parser.eat_ident("enum"){ 204 | 205 | if let Some(name) = parser.eat_any_ident(){ 206 | let generic = parser.eat_generic(); 207 | let where_clause = parser.eat_where_clause(Some("DeJson")); 208 | 209 | tb.add("impl").stream(generic.clone()); 210 | tb.add("DeJson for").ident(&name).stream(generic).stream(where_clause); 211 | tb.add("{ fn de_json ( s : & mut microserde :: DeJsonState , i : & mut std :: str :: Chars )"); 212 | tb.add("-> std :: result :: Result < Self , microserde :: DeJsonErr > { "); 213 | tb.add("s . curly_open ( i ) ? ;"); 214 | tb.add("let _ = s . string ( i ) ? ;"); 215 | tb.add("s . colon ( i ) ? ;"); 216 | tb.add("let r = std :: result :: Result :: Ok ( match s . strbuf . as_ref ( ) {"); 217 | 218 | if !parser.open_brace(){ 219 | return parser.unexpected() 220 | } 221 | while !parser.eat_eot(){ 222 | // parse ident 223 | if let Some(variant) = parser.eat_any_ident(){ 224 | tb.string(&variant).add("=> {"); 225 | if let Some(types) = parser.eat_all_types(){ 226 | 227 | tb.add("s . block_open ( i ) ? ;"); 228 | tb.add("let r = Self ::").ident(&variant).add("("); 229 | for _ in 0..types.len(){ 230 | tb.add("{ let r = DeJson :: de_json ( s , i ) ? ; s . eat_comma_block ( i ) ? ; r } ,"); 231 | } 232 | tb.add(") ;"); 233 | tb.add("s . block_close ( i ) ? ; r"); 234 | } 235 | else if let Some(fields) = parser.eat_all_struct_fields(){ // named variant 236 | tb.add("s . curly_open ( i ) ? ;"); 237 | for (field,_ty) in &fields{ 238 | tb.add("let mut").ident(&format!("_{}",field)).add("= None ;"); 239 | } 240 | tb.add("while let Some ( _ ) = s . next_str ( ) {"); 241 | tb.add("match s . strbuf . as_ref ( ) {"); 242 | for (field,_ty) in &fields{ 243 | tb.string(&field).add("=> { s . next_colon ( i ) ? ;"); 244 | tb.ident(&format!("_{}",field)).add("= Some ( DeJson :: de_json ( s , i ) ? ) ; } ,"); 245 | } 246 | tb.add("_ => return std :: result :: Result :: Err ( s . err_exp ( & s . strbuf ) )"); 247 | tb.add("} s . eat_comma_curly ( i ) ? ;"); 248 | tb.add("} s . curly_close ( i ) ? ;"); 249 | 250 | tb.add("Self ::").ident(&variant).add("{"); 251 | for (field,ty) in fields{ 252 | tb.ident(&field).add(":"); 253 | if ty.into_iter().next().unwrap().to_string() == "Option"{ 254 | tb.add("if let Some ( t ) =").ident(&format!("_{}",field)); 255 | tb.add("{ t } else { None } ,"); 256 | } 257 | else{ 258 | tb.add("if let Some ( t ) =").ident(&format!("_{}",field)); 259 | tb.add("{ t } else { return Err ( s . err_nf ("); 260 | tb.string(&field).add(") ) } ,"); 261 | } 262 | } 263 | tb.add("}"); 264 | } 265 | else if parser.is_punct(',') || parser.is_eot(){ // bare variant 266 | tb.add("s . block_open ( i ) ? ; s . block_close ( i ) ? ; Self ::").ident(&variant); 267 | } 268 | else{ 269 | return parser.unexpected(); 270 | } 271 | 272 | tb.add("}"); 273 | parser.eat_punct(','); 274 | } 275 | else{ 276 | return parser.unexpected() 277 | } 278 | } 279 | tb.add("_ => return std :: result :: Result :: Err ( s . err_exp ( & s . strbuf ) )"); 280 | tb.add("} ) ; s . curly_close ( i ) ? ; r } }"); 281 | return tb.end(); 282 | } 283 | } 284 | return parser.unexpected() 285 | } 286 | -------------------------------------------------------------------------------- /derive/src/macro_lib.rs: -------------------------------------------------------------------------------- 1 | #![allow(dead_code)] 2 | 3 | use proc_macro::{TokenTree, Span, TokenStream, Delimiter, Group, Literal, Ident, Punct, Spacing}; 4 | use proc_macro::token_stream::IntoIter; 5 | 6 | // little macro utility lib 7 | 8 | pub fn error_span(err: &str, span: Span) -> TokenStream { 9 | let mut tb = TokenBuilder::new(); 10 | tb.ident_with_span("compile_error", span).add("! (").string(err).add(") ;"); 11 | tb.end() 12 | } 13 | 14 | pub fn error(err: &str) -> TokenStream { 15 | let mut tb = TokenBuilder::new(); 16 | tb.add("compile_error ! (").string(err).add(") ;"); 17 | tb.end() 18 | } 19 | 20 | pub struct TokenBuilder { 21 | pub groups: Vec<(Delimiter, TokenStream)> 22 | } 23 | 24 | impl TokenBuilder { 25 | pub fn new() -> Self { 26 | Self { 27 | groups: vec![(Delimiter::None, TokenStream::new())] 28 | } 29 | } 30 | 31 | pub fn end(mut self) -> TokenStream { 32 | if self.groups.len() != 1 { 33 | panic!("Groups not empty, you missed a pop_group") 34 | } 35 | self.groups.pop().unwrap().1 36 | } 37 | 38 | pub fn eprint(&self){ 39 | eprintln!("{}", self.groups.last().unwrap().1.to_string()); 40 | } 41 | 42 | pub fn extend(&mut self, tt: TokenTree) -> &mut Self { 43 | self.groups.last_mut().unwrap().1.extend(Some(tt)); 44 | self 45 | } 46 | 47 | pub fn stream(&mut self, what: Option) -> &mut Self { 48 | if let Some(what) = what { 49 | for c in what.into_iter() { 50 | self.extend(c); 51 | } 52 | self 53 | } 54 | else { 55 | self 56 | } 57 | } 58 | 59 | pub fn add(&mut self, what: &str) -> &mut Self { 60 | for part in what.split(" ") { 61 | match part { 62 | "{" => self.push_group(Delimiter::Brace), 63 | "(" => self.push_group(Delimiter::Parenthesis), 64 | "[" => self.push_group(Delimiter::Bracket), 65 | "}" => self.pop_group(Delimiter::Brace), 66 | ")" => self.pop_group(Delimiter::Parenthesis), 67 | "]" => self.pop_group(Delimiter::Bracket), 68 | "?" | ";" | "&" | "^" | ":" | "::" | "," | "!" | "." | "<<" | ">>" | 69 | "->" | "=>" | "<" | ">" | "<=" | ">=" | "=" | "==" | "!=" | 70 | "+" | "+=" | "-" | "-=" | "*" | "*=" | "/" | "/=" => self.punct(part), 71 | _ => { 72 | if part.len() == 0{ 73 | continue 74 | } 75 | match part.chars().next().unwrap(){ 76 | '0'..='9'=>{ 77 | self.unsuf_usize(part.parse().expect(&format!("Can't parse number \"{}\"", what))) 78 | }, 79 | _=>self.ident(part) 80 | } 81 | } 82 | }; 83 | } 84 | self 85 | } 86 | 87 | pub fn ident(&mut self, id: &str) -> &mut Self { 88 | self.extend(TokenTree::from(Ident::new(id, Span::call_site()))) 89 | } 90 | 91 | pub fn ident_with_span(&mut self, id: &str, span: Span) -> &mut Self { 92 | self.extend(TokenTree::from(Ident::new(id, span))) 93 | } 94 | 95 | pub fn punct(&mut self, s: &str) -> &mut Self { 96 | for (last, c) in s.chars().identify_last() { 97 | self.extend(TokenTree::from(Punct::new(c, if last {Spacing::Alone} else {Spacing::Joint}))); 98 | } 99 | self 100 | } 101 | 102 | pub fn string(&mut self, val: &str) -> &mut Self {self.extend(TokenTree::from(Literal::string(val)))} 103 | pub fn unsuf_usize(&mut self, val: usize) -> &mut Self {self.extend(TokenTree::from(Literal::usize_unsuffixed(val)))} 104 | pub fn suf_u16(&mut self, val: u16) -> &mut Self {self.extend(TokenTree::from(Literal::u16_suffixed(val)))} 105 | pub fn unsuf_f32(&mut self, val: f32) -> &mut Self {self.extend(TokenTree::from(Literal::f32_unsuffixed(val)))} 106 | pub fn chr(&mut self, val:char) -> &mut Self {self.extend(TokenTree::from(Literal::character(val)))} 107 | pub fn _lit(&mut self, lit: Literal) -> &mut Self {self.extend(TokenTree::from(lit))} 108 | 109 | pub fn push_group(&mut self, delim: Delimiter) -> &mut Self { 110 | self.groups.push((delim, TokenStream::new())); 111 | self 112 | } 113 | 114 | pub fn stack_as_string(&self)->String{ 115 | let mut ret = String::new(); 116 | for i in (0..self.groups.len() - 1).rev(){ 117 | ret.push_str(&format!("Level {}: {}", i, self.groups[i].1.to_string())); 118 | } 119 | ret 120 | } 121 | 122 | pub fn pop_group(&mut self, delim: Delimiter) -> &mut Self { 123 | if self.groups.len() < 2 { 124 | eprintln!("Stack dump for error:\n{}", self.stack_as_string()); 125 | panic!("pop_group stack is empty {}", self.groups.len()); 126 | } 127 | let ts = self.groups.pop().unwrap(); 128 | if ts.0 != delim { 129 | eprintln!("Stack dump for error:\n{}", self.stack_as_string()); 130 | panic!("pop_group Delimiter mismatch, got {:?} expected {:?}", ts.0, delim); 131 | } 132 | self.extend(TokenTree::from(Group::new(delim, ts.1))); 133 | self 134 | } 135 | } 136 | 137 | pub trait IdentifyLast: Iterator + Sized { 138 | fn identify_last(self) -> Iter; 139 | } 140 | 141 | impl IdentifyLast for It where It: Iterator { 142 | fn identify_last(mut self) -> Iter { 143 | let e = self.next(); 144 | Iter { 145 | iter: self, 146 | buffer: e, 147 | } 148 | } 149 | } 150 | 151 | pub struct Iter where It: Iterator { 152 | iter: It, 153 | buffer: Option, 154 | } 155 | 156 | impl Iterator for Iter where It: Iterator { 157 | type Item = (bool, It::Item); 158 | 159 | fn next(&mut self) -> Option { 160 | match self.buffer.take() { 161 | None => None, 162 | Some(e) => { 163 | match self.iter.next() { 164 | None => Some((true, e)), 165 | Some(f) => { 166 | self.buffer = Some(f); 167 | Some((false, e)) 168 | }, 169 | } 170 | }, 171 | } 172 | } 173 | } 174 | 175 | pub struct TokenParser { 176 | iter_stack: Vec, 177 | current: Option 178 | } 179 | 180 | // this parser is optimized for parsing type definitions, not general Rust code 181 | 182 | impl TokenParser { 183 | pub fn new(start: TokenStream) -> Self { 184 | let mut ret = Self {iter_stack: vec![start.into_iter()], current: None}; 185 | ret.advance(); 186 | ret 187 | } 188 | 189 | pub fn advance(&mut self) { 190 | let last = self.iter_stack.last_mut().unwrap(); 191 | let value = last.next(); 192 | if let Some(tok) = value { 193 | self.current = Some(tok); 194 | } 195 | else { 196 | self.current = None; 197 | } 198 | } 199 | 200 | pub fn unexpected(&self) -> TokenStream { 201 | error("Unexpected token") 202 | } 203 | 204 | pub fn is_delim(&mut self, delim: Delimiter) -> bool { 205 | if let Some(TokenTree::Group(group)) = &self.current { 206 | group.delimiter() == delim 207 | } 208 | else { 209 | false 210 | } 211 | } 212 | 213 | pub fn is_brace(&mut self) -> bool { 214 | self.is_delim(Delimiter::Brace) 215 | } 216 | 217 | pub fn is_paren(&mut self) -> bool { 218 | self.is_delim(Delimiter::Parenthesis) 219 | } 220 | 221 | pub fn is_bracket(&mut self) -> bool { 222 | self.is_delim(Delimiter::Bracket) 223 | } 224 | 225 | pub fn open_delim(&mut self, delim: Delimiter) -> bool { 226 | if let Some(TokenTree::Group(group)) = &self.current { 227 | if group.delimiter() == delim { 228 | self.iter_stack.push(group.stream().into_iter()); 229 | self.advance(); 230 | return true 231 | } 232 | } 233 | false 234 | } 235 | 236 | pub fn open_brace(&mut self) -> bool { 237 | self.open_delim(Delimiter::Brace) 238 | } 239 | 240 | pub fn open_paren(&mut self) -> bool { 241 | self.open_delim(Delimiter::Parenthesis) 242 | } 243 | 244 | pub fn open_bracket(&mut self) -> bool { 245 | self.open_delim(Delimiter::Bracket) 246 | } 247 | 248 | pub fn is_eot(&mut self) -> bool{ 249 | if self.current.is_none() && self.iter_stack.len() != 0 { 250 | return true 251 | } 252 | else{ 253 | return false 254 | } 255 | } 256 | 257 | pub fn eat_eot(&mut self) -> bool { 258 | // current is None 259 | if self.is_eot() { 260 | self.iter_stack.pop(); 261 | if self.iter_stack.len() != 0 { 262 | self.advance() 263 | } 264 | return true; 265 | } 266 | return false 267 | } 268 | 269 | pub fn eat_ident(&mut self, what: &str) -> bool { 270 | // check if our current thing is an ident, ifso eat it. 271 | if let Some(TokenTree::Ident(ident)) = &self.current { 272 | if ident.to_string() == what { 273 | self.advance(); 274 | return true 275 | } 276 | } 277 | return false 278 | } 279 | 280 | pub fn is_literal(&mut self) -> bool { 281 | // check if our current thing is an ident, ifso eat it. 282 | if let Some(TokenTree::Literal(_)) = &self.current { 283 | return true 284 | } 285 | return false 286 | } 287 | 288 | pub fn eat_literal(&mut self) -> Option { 289 | // check if our current thing is an ident, ifso eat it. 290 | if let Some(TokenTree::Literal(lit)) = &self.current { 291 | return Some(lit.clone()) 292 | } 293 | return None 294 | } 295 | 296 | 297 | pub fn is_punct(&mut self, what: char) -> bool { 298 | // check if our punct is multichar. 299 | if let Some(TokenTree::Punct(current)) = &self.current { 300 | if current.as_char() == what && (what == '>' || current.spacing() == Spacing::Alone){ 301 | return true 302 | } 303 | else { 304 | return false 305 | } 306 | } 307 | else { 308 | return false 309 | } 310 | } 311 | 312 | pub fn eat_punct(&mut self, what: char) -> bool { 313 | if self.is_punct(what) { 314 | self.advance(); 315 | return true 316 | } 317 | false 318 | } 319 | 320 | pub fn eat_any_ident(&mut self) -> Option { 321 | if let Some(TokenTree::Ident(ident)) = &self.current { 322 | let ret = Some(ident.to_string()); 323 | self.advance(); 324 | return ret 325 | } 326 | return None 327 | } 328 | 329 | pub fn eat_where_clause(&mut self, add_where: Option<&str>) -> Option { 330 | let mut tb = TokenBuilder::new(); 331 | if self.eat_ident("where") { 332 | tb.add("where"); 333 | // ok now we parse an ident 334 | loop { 335 | if let Some(ident) = self.eat_any_ident() { 336 | tb.ident(&ident); 337 | tb.stream(self.eat_generic()); 338 | 339 | if !self.eat_punct(':') { 340 | return None 341 | } 342 | tb.add(":"); 343 | loop { 344 | if let Some(ident) = self.eat_any_ident() { 345 | tb.add(&ident); 346 | tb.stream(self.eat_generic()); 347 | // check if we have upnext 348 | // {, + or , 349 | if self.eat_punct('+') { 350 | tb.add("+"); 351 | continue 352 | } 353 | if self.eat_punct(',') { // next one 354 | if let Some(add_where) = add_where { 355 | tb.add("+"); 356 | tb.ident(add_where); 357 | } 358 | tb.add(","); 359 | break 360 | } 361 | if self.is_brace() || self.is_punct(';') { // upnext is a brace.. we're done 362 | if let Some(add_where) = add_where { 363 | tb.add("+"); 364 | tb.ident(add_where); 365 | } 366 | return Some(tb.end()) 367 | } 368 | } 369 | else { 370 | return None // unexpected 371 | } 372 | } 373 | } 374 | else { 375 | return None // unexpected 376 | } 377 | } 378 | } 379 | return None 380 | } 381 | 382 | pub fn eat_struct_field(&mut self) -> Option<(String, TokenStream)> { 383 | // letsparse an ident 384 | self.eat_ident("pub"); 385 | if let Some(field) = self.eat_any_ident() { 386 | if self.eat_punct(':') { 387 | if let Some(ty) = self.eat_type() { 388 | return Some((field, ty)) 389 | } 390 | } 391 | } 392 | return None 393 | } 394 | 395 | pub fn eat_all_struct_fields(&mut self, )->Option>{ 396 | 397 | if self.open_brace(){ 398 | let mut fields = Vec::new(); 399 | while !self.eat_eot(){ 400 | if let Some((field, ty)) = self.eat_struct_field(){ 401 | fields.push((field, ty)); 402 | self.eat_punct(','); 403 | } 404 | else{ 405 | return None 406 | } 407 | } 408 | return Some(fields) 409 | } 410 | return None 411 | } 412 | 413 | 414 | pub fn eat_generic(&mut self) -> Option { 415 | let mut tb = TokenBuilder::new(); 416 | // if we have a <, keep running and keep a < stack 417 | 418 | if self.eat_punct('<') { 419 | tb.add("<"); 420 | let mut stack = 1; 421 | // keep eating things till we are at stack 0 for a ">" 422 | while stack > 0 { 423 | if self.eat_punct('<') { 424 | tb.add("<"); 425 | stack += 1; 426 | } 427 | if self.eat_punct('>') { 428 | tb.add(">"); 429 | stack -= 1; 430 | } 431 | else if self.eat_eot() { // shits broken 432 | return None 433 | } 434 | else { // store info here in generics struct 435 | if let Some(current) = &self.current { 436 | tb.extend(current.clone()); 437 | } 438 | self.advance(); 439 | } 440 | } 441 | 442 | return Some(tb.end()) 443 | } 444 | return None 445 | } 446 | 447 | pub fn eat_all_types(&mut self)->Option>{ 448 | if self.open_paren(){ 449 | let mut ret = Vec::new(); 450 | while !self.eat_eot(){ 451 | self.eat_ident("pub"); 452 | if let Some(tt) = self.eat_type(){ 453 | ret.push(tt); 454 | self.eat_punct(','); 455 | } 456 | else{ 457 | return None 458 | } 459 | } 460 | Some(ret) 461 | } 462 | else{ 463 | None 464 | } 465 | } 466 | 467 | pub fn eat_type(&mut self) -> Option { 468 | let mut tb = TokenBuilder::new(); 469 | if self.open_bracket(){ // array type 470 | tb.add("["); 471 | while !self.eat_eot(){ 472 | if let Some(current) = &self.current { 473 | tb.extend(current.clone()); 474 | } 475 | self.advance(); 476 | } 477 | tb.add("]"); 478 | return Some(tb.end()) 479 | } 480 | else if self.open_paren(){ // tuple type 481 | tb.add("("); 482 | while !self.eat_eot(){ 483 | tb.stream(self.eat_type()); 484 | self.eat_punct(','); 485 | } 486 | tb.add(")"); 487 | return Some(tb.end()); 488 | } 489 | else if let Some(ty) = self.eat_any_ident() { 490 | tb.ident(&ty); 491 | tb.stream(self.eat_generic()); 492 | 493 | return Some(tb.end()) 494 | } 495 | return None 496 | } 497 | } 498 | -------------------------------------------------------------------------------- /src/serde_json.rs: -------------------------------------------------------------------------------- 1 | use std::collections::{HashMap}; 2 | use std::hash::Hash; 3 | use std::str::Chars; 4 | 5 | pub struct SerJsonState { 6 | pub out: String 7 | } 8 | 9 | impl SerJsonState { 10 | pub fn indent(&mut self, _d: usize) { 11 | //for _ in 0..d { 12 | // self.out.push_str(" "); 13 | //} 14 | } 15 | 16 | pub fn field(&mut self, d: usize, field: &str) { 17 | self.indent(d); 18 | self.out.push('"'); 19 | self.out.push_str(field); 20 | self.out.push('"'); 21 | self.out.push(':'); 22 | } 23 | 24 | pub fn label(&mut self, label:&str){ 25 | self.out.push('"'); 26 | self.out.push_str(label); 27 | self.out.push('"'); 28 | } 29 | 30 | pub fn conl(&mut self) { 31 | self.out.push(',') 32 | } 33 | 34 | pub fn st_pre(&mut self) { 35 | self.out.push('{'); 36 | } 37 | 38 | pub fn st_post(&mut self, d: usize) { 39 | self.indent(d); 40 | self.out.push('}'); 41 | } 42 | 43 | } 44 | 45 | pub trait SerJson { 46 | 47 | fn serialize_json(&self) -> String { 48 | let mut s = SerJsonState { 49 | out: String::new() 50 | }; 51 | self.ser_json(0, &mut s); 52 | s.out 53 | } 54 | 55 | fn ser_json(&self, d: usize, s: &mut SerJsonState); 56 | } 57 | 58 | pub trait DeJson: Sized { 59 | 60 | fn deserialize_json(input: &str) -> Result { 62 | let mut state = DeJsonState::default(); 63 | let mut chars = input.chars(); 64 | state.next(&mut chars); 65 | state.next_tok(&mut chars) ?; 66 | DeJson::de_json(&mut state, &mut chars) 67 | } 68 | 69 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result; 71 | } 72 | 73 | #[derive(PartialEq, Debug)] 74 | pub enum DeJsonTok { 75 | Str, 76 | Char(char), 77 | U64(u64), 78 | I64(i64), 79 | F64(f64), 80 | Bool(bool), 81 | BareIdent, 82 | Null, 83 | Colon, 84 | CurlyOpen, 85 | CurlyClose, 86 | BlockOpen, 87 | BlockClose, 88 | Comma, 89 | Bof, 90 | Eof 91 | } 92 | 93 | impl Default for DeJsonTok { 94 | fn default() -> Self {DeJsonTok::Bof} 95 | } 96 | 97 | #[derive(Default)] 98 | pub struct DeJsonState { 99 | pub cur: char, 100 | pub tok: DeJsonTok, 101 | pub strbuf:String, 102 | pub numbuf:String, 103 | pub identbuf:String, 104 | pub line: usize, 105 | pub col: usize 106 | } 107 | 108 | pub struct DeJsonErr{ 109 | pub msg:String, 110 | pub line:usize, 111 | pub col:usize 112 | } 113 | 114 | impl std::fmt::Debug for DeJsonErr { 115 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 116 | write!(f, "Json Deserialize error: {}, line:{} col:{}", self.msg, self.line+1, self.col+1) 117 | } 118 | } 119 | 120 | impl DeJsonState { 121 | pub fn next(&mut self, i: &mut Chars) { 122 | if let Some(c) = i.next() { 123 | self.cur = c; 124 | if self.cur == '\n'{ 125 | self.line += 1; 126 | self.col = 0; 127 | } 128 | else{ 129 | self.col += 1; 130 | } 131 | } 132 | else { 133 | self.cur = '\0'; 134 | } 135 | } 136 | 137 | pub fn err_exp(&self, name: &str) -> DeJsonErr { 138 | DeJsonErr{msg:format!("Unexpected key {}", name), line:self.line, col:self.col} 139 | } 140 | 141 | pub fn err_nf(&self, name: &str) -> DeJsonErr { 142 | DeJsonErr{msg:format!("Key not found {}", name), line:self.line, col:self.col} 143 | } 144 | 145 | pub fn err_enum(&self, name: &str) -> DeJsonErr { 146 | DeJsonErr{msg:format!("Enum not defined {}", name), line:self.line, col:self.col} 147 | } 148 | 149 | pub fn err_token(&self, what:&str) -> DeJsonErr { 150 | DeJsonErr{msg:format!("Unexpected token {:?} expected {} ", self.tok, what), line:self.line, col:self.col} 151 | } 152 | 153 | pub fn err_range(&self, what:&str) -> DeJsonErr { 154 | DeJsonErr{msg:format!("Value out of range {} ", what), line:self.line, col:self.col} 155 | } 156 | 157 | pub fn err_type(&self, what:&str) -> DeJsonErr { 158 | DeJsonErr{msg:format!("Token wrong type {} ", what), line:self.line, col:self.col} 159 | } 160 | 161 | pub fn err_parse(&self, what:&str) -> DeJsonErr { 162 | DeJsonErr{msg:format!("Cannot parse {} ", what), line:self.line, col:self.col} 163 | } 164 | 165 | pub fn eat_comma_block(&mut self, i: &mut Chars) -> Result<(), DeJsonErr> { 166 | match self.tok { 167 | DeJsonTok::Comma => { 168 | self.next_tok(i) ?; 169 | Ok(()) 170 | }, 171 | DeJsonTok::BlockClose => { 172 | Ok(()) 173 | } 174 | _ => { 175 | Err(self.err_token(", or ]")) 176 | } 177 | } 178 | } 179 | 180 | pub fn eat_comma_curly(&mut self, i: &mut Chars) -> Result<(), DeJsonErr> { 181 | match self.tok { 182 | DeJsonTok::Comma => { 183 | self.next_tok(i) ?; 184 | Ok(()) 185 | }, 186 | DeJsonTok::CurlyClose => { 187 | Ok(()) 188 | } 189 | _ => { 190 | Err(self.err_token(", or }")) 191 | } 192 | } 193 | } 194 | 195 | pub fn colon(&mut self, i: &mut Chars) -> Result<(), DeJsonErr> { 196 | match self.tok { 197 | DeJsonTok::Colon => { 198 | self.next_tok(i) ?; 199 | Ok(()) 200 | }, 201 | _ => { 202 | Err(self.err_token(":")) 203 | } 204 | } 205 | } 206 | 207 | 208 | pub fn string(&mut self, i: &mut Chars) -> Result<(), DeJsonErr> { 209 | match &mut self.tok { 210 | DeJsonTok::Str => { 211 | self.next_tok(i) ?; 212 | Ok(()) 213 | }, 214 | _ => { 215 | Err(self.err_token("String")) 216 | } 217 | } 218 | } 219 | 220 | pub fn next_colon(&mut self, i: &mut Chars) -> Result<(), DeJsonErr> { 221 | self.next_tok(i) ?; 222 | self.colon(i) ?; 223 | Ok(()) 224 | } 225 | 226 | pub fn next_str(&mut self) -> Option<()> { 227 | if let DeJsonTok::Str = &mut self.tok { 228 | //let mut s = String::new(); 229 | //std::mem::swap(&mut s, name); 230 | Some(()) 231 | } 232 | else { 233 | None 234 | } 235 | } 236 | 237 | pub fn block_open(&mut self, i: &mut Chars) -> Result<(), DeJsonErr> { 238 | if self.tok == DeJsonTok::BlockOpen { 239 | self.next_tok(i) ?; 240 | return Ok(()) 241 | } 242 | Err(self.err_token("[")) 243 | } 244 | 245 | 246 | pub fn block_close(&mut self, i: &mut Chars) -> Result<(), DeJsonErr> { 247 | if self.tok == DeJsonTok::BlockClose { 248 | self.next_tok(i) ?; 249 | return Ok(()) 250 | } 251 | Err(self.err_token("]")) 252 | } 253 | 254 | pub fn curly_open(&mut self, i: &mut Chars) -> Result<(), DeJsonErr> { 255 | if self.tok == DeJsonTok::CurlyOpen { 256 | self.next_tok(i) ?; 257 | return Ok(()) 258 | } 259 | Err(self.err_token("{")) 260 | } 261 | 262 | 263 | pub fn curly_close(&mut self, i: &mut Chars) -> Result<(), DeJsonErr> { 264 | if self.tok == DeJsonTok::CurlyClose { 265 | self.next_tok(i) ?; 266 | return Ok(()) 267 | } 268 | Err(self.err_token("}")) 269 | } 270 | 271 | pub fn u64_range(&mut self, max: u64) -> Result { 272 | if let DeJsonTok::U64(value) = self.tok { 273 | if value > max { 274 | return Err(self.err_range(&format!("{}>{}", value, max))) 275 | } 276 | return Ok(value) 277 | } 278 | Err(self.err_token("unsigned integer")) 279 | } 280 | 281 | pub fn i64_range(&mut self, min: i64, max: i64) -> Result { 282 | if let DeJsonTok::I64(value) = self.tok { 283 | if value< min { 284 | return Err(self.err_range(&format!("{}<{}", value, min))) 285 | } 286 | return Ok(value) 287 | } 288 | if let DeJsonTok::U64(value) = self.tok { 289 | if value as i64 > max { 290 | return Err(self.err_range(&format!("{}>{}", value, max))) 291 | } 292 | return Ok(value as i64) 293 | } 294 | Err(self.err_token("signed integer")) 295 | } 296 | 297 | pub fn as_f64(&mut self) -> Result { 298 | if let DeJsonTok::I64(value) = self.tok { 299 | return Ok(value as f64) 300 | } 301 | if let DeJsonTok::U64(value) = self.tok { 302 | return Ok(value as f64) 303 | } 304 | if let DeJsonTok::F64(value) = self.tok { 305 | return Ok(value) 306 | } 307 | Err(self.err_token("floating point")) 308 | } 309 | 310 | pub fn as_bool(&mut self) -> Result { 311 | if let DeJsonTok::Bool(value) = self.tok { 312 | return Ok(value) 313 | } 314 | Err(self.err_token("boolean")) 315 | } 316 | 317 | pub fn as_string(&mut self) -> Result { 318 | if let DeJsonTok::Str = &mut self.tok { 319 | let mut val = String::new(); 320 | std::mem::swap(&mut val, &mut self.strbuf); 321 | return Ok(val) 322 | } 323 | Err(self.err_token("string")) 324 | } 325 | 326 | pub fn next_tok(&mut self, i: &mut Chars) -> Result<(), DeJsonErr> { 327 | while self.cur == '\n' || self.cur == '\r' || self.cur == '\t' || self.cur == ' ' { 328 | self.next(i); 329 | } 330 | if self.cur == '\0' { 331 | self.tok = DeJsonTok::Eof; 332 | return Ok(()) 333 | } 334 | match self.cur { 335 | ':' => { 336 | self.next(i); 337 | self.tok = DeJsonTok::Colon; 338 | return Ok(()) 339 | } 340 | ',' => { 341 | self.next(i); 342 | self.tok = DeJsonTok::Comma; 343 | return Ok(()) 344 | } 345 | '[' => { 346 | self.next(i); 347 | self.tok = DeJsonTok::BlockOpen; 348 | return Ok(()) 349 | } 350 | ']' => { 351 | self.next(i); 352 | self.tok = DeJsonTok::BlockClose; 353 | return Ok(()) 354 | } 355 | '{' => { 356 | self.next(i); 357 | self.tok = DeJsonTok::CurlyOpen; 358 | return Ok(()) 359 | } 360 | '}' => { 361 | self.next(i); 362 | self.tok = DeJsonTok::CurlyClose; 363 | return Ok(()) 364 | } 365 | '-' | '0'..='9' => { 366 | self.numbuf.truncate(0); 367 | let is_neg = if self.cur == '-' { 368 | self.numbuf.push(self.cur); 369 | self.next(i); 370 | true 371 | } 372 | else { 373 | false 374 | }; 375 | while self.cur >= '0' && self.cur <= '9' { 376 | self.numbuf.push(self.cur); 377 | self.next(i); 378 | } 379 | if self.cur == '.' { 380 | self.numbuf.push(self.cur); 381 | self.next(i); 382 | while self.cur >= '0' && self.cur <= '9' { 383 | self.numbuf.push(self.cur); 384 | self.next(i); 385 | } 386 | if let Ok(num) = self.numbuf.parse() { 387 | self.tok = DeJsonTok::F64(num); 388 | return Ok(()) 389 | } 390 | else { 391 | return Err(self.err_parse("number")); 392 | } 393 | } 394 | else { 395 | if is_neg { 396 | if let Ok(num) = self.numbuf.parse() { 397 | self.tok = DeJsonTok::I64(num); 398 | return Ok(()) 399 | } 400 | else { 401 | return Err(self.err_parse("number")); 402 | } 403 | } 404 | if let Ok(num) = self.numbuf.parse() { 405 | self.tok = DeJsonTok::U64(num); 406 | return Ok(()) 407 | } 408 | else { 409 | return Err(self.err_parse("number")); 410 | } 411 | } 412 | }, 413 | 'a'..='z' | 'A'..='Z' | '_' => { 414 | self.identbuf.truncate(0); 415 | while self.cur >= 'a' && self.cur <= 'z' 416 | || self.cur >= 'A' && self.cur <= 'Z' 417 | || self.cur == '_' { 418 | self.identbuf.push(self.cur); 419 | self.next(i); 420 | } 421 | if self.identbuf == "true" { 422 | self.tok = DeJsonTok::Bool(true); 423 | return Ok(()) 424 | } 425 | if self.identbuf == "false" { 426 | self.tok = DeJsonTok::Bool(false); 427 | return Ok(()) 428 | } 429 | if self.identbuf == "null" { 430 | self.tok = DeJsonTok::Null; 431 | return Ok(()) 432 | } 433 | self.tok = DeJsonTok::BareIdent; 434 | return Err(self.err_token(&format!("Got ##{}## needed true, false, null", self.identbuf))); 435 | } 436 | '"' => { 437 | self.strbuf.truncate(0); 438 | self.next(i); 439 | while self.cur != '"' { 440 | if self.cur == '\\' { 441 | self.next(i); 442 | match self.cur{ 443 | 'n'=>self.strbuf.push('\n'), 444 | 'r'=>self.strbuf.push('\r'), 445 | 't'=>self.strbuf.push('\t'), 446 | '0'=>self.strbuf.push('\0'), 447 | '\0'=>{ 448 | return Err(self.err_parse("string")); 449 | }, 450 | _=>self.strbuf.push(self.cur) 451 | } 452 | self.next(i); 453 | } 454 | else{ 455 | if self.cur == '\0' { 456 | return Err(self.err_parse("string")); 457 | } 458 | self.strbuf.push(self.cur); 459 | self.next(i); 460 | } 461 | } 462 | self.next(i); 463 | self.tok = DeJsonTok::Str; 464 | return Ok(()) 465 | }, 466 | _ => { 467 | return Err(self.err_token("tokenizer")); 468 | } 469 | } 470 | } 471 | } 472 | 473 | macro_rules!impl_ser_de_json_unsigned { 474 | ( $ ty: ident, $ max: expr) => { 475 | impl SerJson for $ ty { 476 | fn ser_json(&self, _d: usize, s: &mut SerJsonState) { 477 | s.out.push_str(&self.to_string()); 478 | } 479 | } 480 | 481 | impl DeJson for $ ty { 482 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result< $ ty, 483 | DeJsonErr> { 484 | let val = s.u64_range( $ max as u64) ?; 485 | s.next_tok(i) ?; 486 | return Ok(val as $ ty); 487 | } 488 | } 489 | } 490 | } 491 | 492 | macro_rules!impl_ser_de_json_signed { 493 | ( $ ty: ident, $ min: expr, $ max: expr) => { 494 | impl SerJson for $ ty { 495 | fn ser_json(&self, _d: usize, s: &mut SerJsonState) { 496 | s.out.push_str(&self.to_string()); 497 | } 498 | } 499 | 500 | impl DeJson for $ ty { 501 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result< $ ty, 502 | DeJsonErr> { 503 | //s.is_prefix(p, i) ?; 504 | let val = s.i64_range( $ min as i64, $ max as i64) ?; 505 | s.next_tok(i) ?; 506 | return Ok(val as $ ty); 507 | } 508 | } 509 | } 510 | } 511 | 512 | macro_rules!impl_ser_de_json_float { 513 | ( $ ty: ident) => { 514 | impl SerJson for $ ty { 515 | fn ser_json(&self, _d: usize, s: &mut SerJsonState) { 516 | s.out.push_str(&self.to_string()); 517 | } 518 | } 519 | 520 | impl DeJson for $ ty { 521 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result< $ ty, 522 | DeJsonErr> { 523 | //s.is_prefix(p, i) ?; 524 | let val = s.as_f64() ?; 525 | s.next_tok(i) ?; 526 | return Ok(val as $ ty); 527 | } 528 | } 529 | } 530 | } 531 | 532 | impl_ser_de_json_unsigned!(usize, std::u64::MAX); 533 | impl_ser_de_json_unsigned!(u64, std::u64::MAX); 534 | impl_ser_de_json_unsigned!(u32, std::u32::MAX); 535 | impl_ser_de_json_unsigned!(u16, std::u16::MAX); 536 | impl_ser_de_json_unsigned!(u8, std::u8::MAX); 537 | impl_ser_de_json_signed!(i64, std::i64::MIN, std::i64::MAX); 538 | impl_ser_de_json_signed!(i32, std::i64::MIN, std::i64::MAX); 539 | impl_ser_de_json_signed!(i16, std::i64::MIN, std::i64::MAX); 540 | impl_ser_de_json_signed!(i8, std::i64::MIN, std::i8::MAX); 541 | impl_ser_de_json_float!(f64); 542 | impl_ser_de_json_float!(f32); 543 | 544 | impl SerJson for Option where T: SerJson { 545 | fn ser_json(&self, d: usize, s: &mut SerJsonState) { 546 | if let Some(v) = self { 547 | v.ser_json(d, s); 548 | } 549 | else { 550 | s.out.push_str("None"); 551 | } 552 | } 553 | } 554 | 555 | impl DeJson for Option where T: DeJson{ 556 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result { 558 | if let DeJsonTok::Null = s.tok { 559 | s.next_tok(i) ?; 560 | return Ok(None) 561 | } 562 | Ok(Some(DeJson::de_json(s, i) ?)) 563 | } 564 | } 565 | 566 | impl SerJson for bool { 567 | fn ser_json(&self, _d: usize, s: &mut SerJsonState) { 568 | if *self { 569 | s.out.push_str("true") 570 | } 571 | else { 572 | s.out.push_str("false") 573 | } 574 | } 575 | } 576 | 577 | impl DeJson for bool { 578 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result { 579 | let val = s.as_bool() ?; 580 | s.next_tok(i) ?; 581 | return Ok(val); 582 | } 583 | } 584 | 585 | impl SerJson for String { 586 | fn ser_json(&self, _d: usize, s: &mut SerJsonState) { 587 | s.out.push('"'); 588 | for c in self.chars() { 589 | match c{ 590 | '\n'=>{s.out.push('\\');s.out.push('n');}, 591 | '\r'=>{s.out.push('\\');s.out.push('r');}, 592 | '\t'=>{s.out.push('\\');s.out.push('t');}, 593 | '\0'=>{s.out.push('\\');s.out.push('0');}, 594 | '\\'=>{s.out.push('\\');s.out.push('\\');}, 595 | '"'=>{s.out.push('\\');s.out.push('"');}, 596 | _=>s.out.push(c) 597 | } 598 | } 599 | s.out.push('"'); 600 | } 601 | } 602 | 603 | impl DeJson for String { 604 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result { 605 | let val = s.as_string() ?; 606 | s.next_tok(i) ?; 607 | return Ok(val); 608 | } 609 | } 610 | 611 | impl SerJson for Vec where T: SerJson { 612 | fn ser_json(&self, d: usize, s: &mut SerJsonState) { 613 | s.out.push('['); 614 | if self.len() > 0{ 615 | let last = self.len() -1; 616 | for (index,item) in self.iter().enumerate() { 617 | s.indent(d + 1); 618 | item.ser_json(d + 1, s); 619 | if index != last{ 620 | s.out.push(','); 621 | } 622 | } 623 | } 624 | s.out.push(']'); 625 | } 626 | } 627 | 628 | impl DeJson for Vec where T: DeJson { 629 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result, DeJsonErr> { 630 | let mut out = Vec::new(); 631 | s.block_open(i) ?; 632 | 633 | while s.tok != DeJsonTok::BlockClose { 634 | out.push(DeJson::de_json(s, i) ?); 635 | s.eat_comma_block(i) ?; 636 | } 637 | s.block_close(i) ?; 638 | Ok(out) 639 | } 640 | } 641 | 642 | impl SerJson for [T] where T: SerJson { 643 | fn ser_json(&self, d: usize, s: &mut SerJsonState) { 644 | s.out.push('['); 645 | let last = self.len() -1; 646 | for (index,item) in self.iter().enumerate() { 647 | item.ser_json(d + 1, s); 648 | if index != last{ 649 | s.out.push(','); 650 | } 651 | } 652 | s.out.push(']'); 653 | } 654 | } 655 | 656 | unsafe fn de_json_array_impl_inner(top: *mut T, count: usize, s: &mut DeJsonState, i: &mut Chars) -> Result<(), DeJsonErr> where T:DeJson{ 657 | s.block_open(i) ?; 658 | for c in 0..count { 659 | top.add(c).write(DeJson::de_json(s, i) ?); 660 | s.eat_comma_block(i) ?; 661 | } 662 | s.block_close(i) ?; 663 | Ok(()) 664 | } 665 | 666 | macro_rules!de_json_array_impl { 667 | ( $($count:expr),*) => { 668 | $( 669 | impl DeJson for [T; $count] where T: DeJson { 670 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result { 672 | unsafe{ 673 | let mut to = std::mem::MaybeUninit::<[T; $count]>::uninit(); 674 | let top: *mut T = std::mem::transmute(&mut to); 675 | de_json_array_impl_inner(top, $count, s, i)?; 676 | Ok(to.assume_init()) 677 | } 678 | } 679 | } 680 | )* 681 | } 682 | } 683 | 684 | de_json_array_impl!(2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32); 685 | 686 | fn de_json_comma_block(s: &mut DeJsonState, i: &mut Chars) -> Result where T: DeJson { 687 | let t = DeJson::de_json(s, i); 688 | s.eat_comma_block(i) ?; 689 | t 690 | } 691 | 692 | impl SerJson for (A, B) where A: SerJson, 693 | B: SerJson { 694 | fn ser_json(&self, d: usize, s: &mut SerJsonState) { 695 | s.out.push('['); 696 | self.0.ser_json(d, s); 697 | s.out.push(','); 698 | self.1.ser_json(d, s); 699 | s.out.push(']'); 700 | } 701 | } 702 | 703 | impl DeJson for (A, B) where A: DeJson, 704 | B: DeJson { 705 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result<(A, B), DeJsonErr> { 706 | s.block_open(i) ?; 707 | let r = (de_json_comma_block(s, i) ?, de_json_comma_block(s, i) ?); 708 | s.block_close(i) ?; 709 | Ok(r) 710 | } 711 | } 712 | 713 | impl SerJson for (A, B, C) where A: SerJson, 714 | B: SerJson, 715 | C: SerJson { 716 | fn ser_json(&self, d: usize, s: &mut SerJsonState) { 717 | s.out.push('['); 718 | self.0.ser_json(d, s); 719 | s.out.push(','); 720 | self.1.ser_json(d, s); 721 | s.out.push(','); 722 | self.2.ser_json(d, s); 723 | s.out.push(']'); 724 | } 725 | } 726 | 727 | impl DeJson for (A, B, C) where A: DeJson, 728 | B: DeJson, 729 | C: DeJson { 730 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result<(A, B, C), DeJsonErr> { 731 | s.block_open(i) ?; 732 | let r = (de_json_comma_block(s, i) ?, de_json_comma_block(s, i) ?, de_json_comma_block(s, i) ?); 733 | s.block_close(i) ?; 734 | Ok(r) 735 | } 736 | } 737 | 738 | impl SerJson for (A, B, C, D) where A: SerJson, 739 | B: SerJson, 740 | C: SerJson, 741 | D: SerJson { 742 | fn ser_json(&self, d: usize, s: &mut SerJsonState) { 743 | s.out.push('['); 744 | self.0.ser_json(d, s); 745 | s.out.push(','); 746 | self.1.ser_json(d, s); 747 | s.out.push(','); 748 | self.2.ser_json(d, s); 749 | s.out.push(','); 750 | self.3.ser_json(d, s); 751 | s.out.push(']'); 752 | } 753 | } 754 | 755 | impl DeJson for (A, B, C, D) where A: DeJson, 756 | B: DeJson, 757 | C: DeJson, 758 | D: DeJson { 759 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result<(A, B, C, D), DeJsonErr> { 760 | s.block_open(i) ?; 761 | let r = (de_json_comma_block(s, i) ?, de_json_comma_block(s, i) ?, de_json_comma_block(s, i) ?, de_json_comma_block(s, i) ?); 762 | s.block_close(i) ?; 763 | Ok(r) 764 | } 765 | } 766 | 767 | impl SerJson for HashMap where K: SerJson, 768 | V: SerJson { 769 | fn ser_json(&self, d: usize, s: &mut SerJsonState) { 770 | s.out.push('{'); 771 | let last = self.len() - 1; 772 | let mut index = 0; 773 | for (k, v) in self { 774 | s.indent(d + 1); 775 | k.ser_json(d + 1, s); 776 | s.out.push(':'); 777 | v.ser_json(d + 1, s); 778 | if index != last{ 779 | s.conl(); 780 | } 781 | index += 1; 782 | } 783 | s.indent(d); 784 | s.out.push('}'); 785 | } 786 | } 787 | 788 | impl DeJson for HashMap where K: DeJson + Eq + Hash, 789 | V: DeJson { 790 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result { 792 | let mut h = HashMap::new(); 793 | s.curly_open(i) ?; 794 | while s.tok != DeJsonTok::CurlyClose { 795 | let k = DeJson::de_json(s, i) ?; 796 | s.colon(i) ?; 797 | let v = DeJson::de_json(s, i) ?; 798 | s.eat_comma_curly(i) ?; 799 | h.insert(k, v); 800 | } 801 | s.curly_close(i) ?; 802 | Ok(h) 803 | } 804 | } 805 | 806 | impl SerJson for Box where T: SerJson { 807 | fn ser_json(&self, d: usize, s: &mut SerJsonState) { 808 | (**self).ser_json(d, s) 809 | } 810 | } 811 | 812 | impl DeJson for Box where T: DeJson { 813 | fn de_json(s: &mut DeJsonState, i: &mut Chars) -> Result, DeJsonErr> { 814 | Ok(Box::new(DeJson::de_json(s, i) ?)) 815 | } 816 | } -------------------------------------------------------------------------------- /src/serde_ron.rs: -------------------------------------------------------------------------------- 1 | use std::collections::{HashMap}; 2 | use std::hash::Hash; 3 | use std::str::Chars; 4 | 5 | pub struct SerRonState { 6 | pub out: String 7 | } 8 | 9 | impl SerRonState { 10 | pub fn indent(&mut self, d: usize) { 11 | for _ in 0..d { 12 | self.out.push_str(" "); 13 | } 14 | } 15 | 16 | pub fn field(&mut self, d: usize, field: &str) { 17 | self.indent(d); 18 | self.out.push_str(field); 19 | self.out.push(':'); 20 | } 21 | 22 | pub fn conl(&mut self) { 23 | self.out.push_str(",\n") 24 | } 25 | 26 | pub fn st_pre(&mut self) { 27 | self.out.push_str("(\n"); 28 | } 29 | 30 | pub fn st_post(&mut self, d: usize) { 31 | self.indent(d); 32 | self.out.push(')'); 33 | } 34 | 35 | } 36 | 37 | pub trait SerRon { 38 | 39 | fn serialize_ron(&self) -> String { 40 | let mut s = SerRonState { 41 | out: String::new() 42 | }; 43 | self.ser_ron(0, &mut s); 44 | s.out 45 | } 46 | 47 | fn ser_ron(&self, d: usize, s: &mut SerRonState); 48 | } 49 | 50 | pub trait DeRon: Sized { 51 | 52 | fn deserialize_ron(input: &str) -> Result { 54 | let mut state = DeRonState::default(); 55 | let mut chars = input.chars(); 56 | state.next(&mut chars); 57 | state.next_tok(&mut chars) ?; 58 | DeRon::de_ron(&mut state, &mut chars) 59 | } 60 | 61 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result; 63 | } 64 | 65 | #[derive(PartialEq, Debug)] 66 | pub enum DeRonTok { 67 | Ident, 68 | Str, 69 | U64(u64), 70 | I64(i64), 71 | F64(f64), 72 | Bool(bool), 73 | Char(char), 74 | Colon, 75 | CurlyOpen, 76 | CurlyClose, 77 | ParenOpen, 78 | ParenClose, 79 | BlockOpen, 80 | BlockClose, 81 | Comma, 82 | Bof, 83 | Eof 84 | } 85 | 86 | impl Default for DeRonTok { 87 | fn default() -> Self {DeRonTok::Bof} 88 | } 89 | 90 | #[derive(Default)] 91 | pub struct DeRonState { 92 | pub cur: char, 93 | pub tok: DeRonTok, 94 | pub strbuf: String, 95 | pub numbuf: String, 96 | pub identbuf: String, 97 | pub line: usize, 98 | pub col: usize 99 | } 100 | 101 | pub struct DeRonErr { 102 | pub msg: String, 103 | pub line: usize, 104 | pub col: usize 105 | } 106 | 107 | impl std::fmt::Debug for DeRonErr { 108 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 109 | write!(f, "Ron Deserialize error: {}, line:{} col:{}", self.msg, self.line + 1, self.col + 1) 110 | } 111 | } 112 | 113 | impl DeRonState { 114 | pub fn next(&mut self, i: &mut Chars) { 115 | if let Some(c) = i.next() { 116 | self.cur = c; 117 | if self.cur == '\n' { 118 | self.line += 1; 119 | self.col = 0; 120 | } 121 | else { 122 | self.col = 0; 123 | } 124 | } 125 | else { 126 | self.cur = '\0'; 127 | } 128 | } 129 | 130 | pub fn err_exp(&self, name: &str) -> DeRonErr { 131 | DeRonErr {msg: format!("Unexpected key {}", name), line: self.line, col: self.col} 132 | } 133 | 134 | pub fn err_nf(&self, name: &str) -> DeRonErr { 135 | DeRonErr {msg: format!("Key not found {}", name), line: self.line, col: self.col} 136 | } 137 | 138 | pub fn err_enum(&self, name: &str) -> DeRonErr { 139 | DeRonErr {msg: format!("Enum not defined {}", name), line: self.line, col: self.col} 140 | } 141 | 142 | pub fn err_token(&self, what: &str) -> DeRonErr { 143 | DeRonErr {msg: format!("Unexpected token {:?} expected {} ", self.tok, what), line: self.line, col: self.col} 144 | } 145 | 146 | pub fn err_range(&self, what: &str) -> DeRonErr { 147 | DeRonErr {msg: format!("Value out of range {} ", what), line: self.line, col: self.col} 148 | } 149 | 150 | pub fn err_type(&self, what: &str) -> DeRonErr { 151 | DeRonErr {msg: format!("Token wrong type {} ", what), line: self.line, col: self.col} 152 | } 153 | 154 | pub fn err_parse(&self, what: &str) -> DeRonErr { 155 | DeRonErr {msg: format!("Cannot parse {} ", what), line: self.line, col: self.col} 156 | } 157 | 158 | pub fn eat_comma_paren(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 159 | match self.tok { 160 | DeRonTok::Comma => { 161 | self.next_tok(i) ?; 162 | Ok(()) 163 | }, 164 | DeRonTok::ParenClose => { 165 | Ok(()) 166 | } 167 | _ => { 168 | Err(self.err_token(", or )")) 169 | } 170 | } 171 | } 172 | 173 | pub fn eat_comma_block(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 174 | match self.tok { 175 | DeRonTok::Comma => { 176 | self.next_tok(i) ?; 177 | Ok(()) 178 | }, 179 | DeRonTok::BlockClose => { 180 | Ok(()) 181 | } 182 | _ => { 183 | Err(self.err_token(", or ]")) 184 | } 185 | } 186 | } 187 | 188 | pub fn eat_comma_curly(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 189 | match self.tok { 190 | DeRonTok::Comma => { 191 | self.next_tok(i) ?; 192 | Ok(()) 193 | }, 194 | DeRonTok::CurlyClose => { 195 | Ok(()) 196 | } 197 | _ => { 198 | Err(self.err_token(", or }")) 199 | } 200 | } 201 | } 202 | 203 | pub fn colon(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 204 | match self.tok { 205 | DeRonTok::Colon => { 206 | self.next_tok(i) ?; 207 | Ok(()) 208 | }, 209 | _ => { 210 | Err(self.err_token(":")) 211 | } 212 | } 213 | } 214 | 215 | pub fn ident(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 216 | match &mut self.tok { 217 | DeRonTok::Ident => { 218 | self.next_tok(i) ?; 219 | Ok(()) 220 | }, 221 | _ => { 222 | Err(self.err_token("Identifier")) 223 | } 224 | } 225 | } 226 | 227 | pub fn next_colon(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 228 | self.next_tok(i) ?; 229 | self.colon(i) ?; 230 | Ok(()) 231 | } 232 | 233 | pub fn next_ident(&mut self) -> Option<()> { 234 | if let DeRonTok::Ident = &mut self.tok { 235 | Some(()) 236 | } 237 | else { 238 | None 239 | } 240 | } 241 | 242 | pub fn paren_open(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 243 | if self.tok == DeRonTok::ParenOpen { 244 | self.next_tok(i) ?; 245 | return Ok(()) 246 | } 247 | Err(self.err_token("(")) 248 | } 249 | 250 | 251 | pub fn paren_close(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 252 | if self.tok == DeRonTok::ParenClose { 253 | self.next_tok(i) ?; 254 | return Ok(()) 255 | } 256 | Err(self.err_token(")")) 257 | } 258 | 259 | pub fn block_open(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 260 | if self.tok == DeRonTok::BlockOpen { 261 | self.next_tok(i) ?; 262 | return Ok(()) 263 | } 264 | Err(self.err_token("[")) 265 | } 266 | 267 | 268 | pub fn block_close(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 269 | if self.tok == DeRonTok::BlockClose { 270 | self.next_tok(i) ?; 271 | return Ok(()) 272 | } 273 | Err(self.err_token("]")) 274 | } 275 | 276 | pub fn curly_open(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 277 | if self.tok == DeRonTok::CurlyOpen { 278 | self.next_tok(i) ?; 279 | return Ok(()) 280 | } 281 | Err(self.err_token("{")) 282 | } 283 | 284 | 285 | pub fn curly_close(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 286 | if self.tok == DeRonTok::CurlyClose { 287 | self.next_tok(i) ?; 288 | return Ok(()) 289 | } 290 | Err(self.err_token("}")) 291 | } 292 | 293 | 294 | pub fn u64_range(&mut self, max: u64) -> Result { 295 | if let DeRonTok::U64(value) = self.tok { 296 | if value > max { 297 | return Err(self.err_range(&format!("{}>{}", value, max))) 298 | } 299 | return Ok(value) 300 | } 301 | Err(self.err_token("unsigned integer")) 302 | } 303 | 304 | pub fn i64_range(&mut self, min: i64, max: i64) -> Result { 305 | if let DeRonTok::I64(value) = self.tok { 306 | if value< min { 307 | return Err(self.err_range(&format!("{}<{}", value, min))) 308 | } 309 | return Ok(value) 310 | } 311 | if let DeRonTok::U64(value) = self.tok { 312 | if value as i64 > max { 313 | return Err(self.err_range(&format!("{}>{}", value, max))) 314 | } 315 | return Ok(value as i64) 316 | } 317 | Err(self.err_token("signed integer")) 318 | } 319 | 320 | pub fn as_f64(&mut self) -> Result { 321 | if let DeRonTok::I64(value) = self.tok { 322 | return Ok(value as f64) 323 | } 324 | if let DeRonTok::U64(value) = self.tok { 325 | return Ok(value as f64) 326 | } 327 | if let DeRonTok::F64(value) = self.tok { 328 | return Ok(value) 329 | } 330 | Err(self.err_token("floating point")) 331 | } 332 | 333 | pub fn as_bool(&mut self) -> Result { 334 | if let DeRonTok::Bool(value) = self.tok { 335 | return Ok(value) 336 | } 337 | if let DeRonTok::U64(value) = self.tok { 338 | return Ok(value != 0) 339 | } 340 | Err(self.err_token("boolean")) 341 | } 342 | 343 | pub fn as_string(&mut self) -> Result { 344 | if let DeRonTok::Str = &mut self.tok { 345 | let mut val = String::new(); 346 | std::mem::swap(&mut val, &mut self.strbuf); 347 | return Ok(val) 348 | } 349 | Err(self.err_token("string")) 350 | } 351 | 352 | pub fn next_tok(&mut self, i: &mut Chars) -> Result<(), DeRonErr> { 353 | loop { 354 | while self.cur == '\n' || self.cur == '\r' || self.cur == '\t' || self.cur == ' ' { 355 | self.next(i); 356 | } 357 | match self.cur { 358 | '\0' => { 359 | self.tok = DeRonTok::Eof; 360 | return Ok(()) 361 | }, 362 | ':' => { 363 | self.next(i); 364 | self.tok = DeRonTok::Colon; 365 | return Ok(()) 366 | } 367 | ',' => { 368 | self.next(i); 369 | self.tok = DeRonTok::Comma; 370 | return Ok(()) 371 | } 372 | '[' => { 373 | self.next(i); 374 | self.tok = DeRonTok::BlockOpen; 375 | return Ok(()) 376 | } 377 | ']' => { 378 | self.next(i); 379 | self.tok = DeRonTok::BlockClose; 380 | return Ok(()) 381 | } 382 | '(' => { 383 | self.next(i); 384 | self.tok = DeRonTok::ParenOpen; 385 | return Ok(()) 386 | } 387 | ')' => { 388 | self.next(i); 389 | self.tok = DeRonTok::ParenClose; 390 | return Ok(()) 391 | } 392 | '{' => { 393 | self.next(i); 394 | self.tok = DeRonTok::CurlyOpen; 395 | return Ok(()) 396 | } 397 | '}' => { 398 | self.next(i); 399 | self.tok = DeRonTok::CurlyClose; 400 | return Ok(()) 401 | } 402 | '/' => { 403 | self.next(i); 404 | if self.cur == '/' { // single line comment 405 | while self.cur != '\0' { 406 | if self.cur == '\n' { 407 | self.next(i); 408 | break; 409 | } 410 | self.next(i); 411 | } 412 | } 413 | else if self.cur == '*' { // multline comment 414 | let mut last_star = false; 415 | while self.cur != '\0' { 416 | if self.cur == '/' && last_star { 417 | self.next(i); 418 | break; 419 | } 420 | if self.cur == '*' {last_star = true}else {last_star = false} 421 | self.next(i); 422 | } 423 | } 424 | else { 425 | return Err(self.err_parse("comment")); 426 | } 427 | }, 428 | '-' | '0'..='9' => { 429 | self.numbuf.truncate(0); 430 | let is_neg = if self.cur == '-' { 431 | self.numbuf.push(self.cur); 432 | self.next(i); 433 | true 434 | } 435 | else { 436 | false 437 | }; 438 | while self.cur >= '0' && self.cur <= '9' { 439 | self.numbuf.push(self.cur); 440 | self.next(i); 441 | } 442 | if self.cur == '.' { 443 | self.numbuf.push(self.cur); 444 | self.next(i); 445 | while self.cur >= '0' && self.cur <= '9' { 446 | self.numbuf.push(self.cur); 447 | self.next(i); 448 | } 449 | if let Ok(num) = self.numbuf.parse() { 450 | self.tok = DeRonTok::F64(num); 451 | return Ok(()) 452 | } 453 | else { 454 | return Err(self.err_parse("number")); 455 | } 456 | } 457 | else { 458 | if is_neg { 459 | if let Ok(num) = self.numbuf.parse() { 460 | self.tok = DeRonTok::I64(num); 461 | return Ok(()) 462 | } 463 | else { 464 | return Err(self.err_parse("number")); 465 | } 466 | } 467 | if let Ok(num) = self.numbuf.parse() { 468 | self.tok = DeRonTok::U64(num); 469 | return Ok(()) 470 | } 471 | else { 472 | return Err(self.err_parse("number")); 473 | } 474 | } 475 | }, 476 | 'a'..='z' | 'A'..='Z' | '_' => { 477 | self.identbuf.truncate(0); 478 | while self.cur >= 'a' && self.cur <= 'z' 479 | || self.cur >= 'A' && self.cur <= 'Z' 480 | || self.cur == '_' { 481 | self.identbuf.push(self.cur); 482 | self.next(i); 483 | } 484 | if self.identbuf == "true" { 485 | self.tok = DeRonTok::Bool(true); 486 | return Ok(()) 487 | } 488 | if self.identbuf == "false" { 489 | self.tok = DeRonTok::Bool(false); 490 | return Ok(()) 491 | } 492 | self.tok = DeRonTok::Ident; 493 | return Ok(()) 494 | }, 495 | '\'' => { 496 | self.next(i); 497 | if self.cur == '\\' { 498 | self.next(i); 499 | } 500 | let chr = self.cur; 501 | self.next(i); 502 | if self.cur != '\'' { 503 | return Err(self.err_token("char")); 504 | } 505 | self.next(i); 506 | self.tok = DeRonTok::Char(chr); 507 | }, 508 | '"' => { 509 | self.strbuf.truncate(0); 510 | self.next(i); 511 | while self.cur != '"' { 512 | if self.cur == '\\' { 513 | self.next(i); 514 | match self.cur { 515 | 'n' => self.strbuf.push('\n'), 516 | 'r' => self.strbuf.push('\r'), 517 | 't' => self.strbuf.push('\t'), 518 | '0' => self.strbuf.push('\0'), 519 | '\0' => { 520 | return Err(self.err_parse("string")); 521 | }, 522 | _ => self.strbuf.push(self.cur) 523 | } 524 | self.next(i); 525 | } 526 | else{ 527 | if self.cur == '\0' { 528 | return Err(self.err_parse("string")); 529 | } 530 | self.strbuf.push(self.cur); 531 | self.next(i); 532 | } 533 | } 534 | self.next(i); 535 | self.tok = DeRonTok::Str; 536 | return Ok(()) 537 | }, 538 | _ => { 539 | return Err(self.err_token("tokenizer")); 540 | } 541 | } 542 | } 543 | } 544 | } 545 | 546 | macro_rules!impl_ser_de_ron_unsigned { 547 | ( $ ty: ident, $ max: expr) => { 548 | impl SerRon for $ ty { 549 | fn ser_ron(&self, _d: usize, s: &mut SerRonState) { 550 | s.out.push_str(&self.to_string()); 551 | } 552 | } 553 | 554 | impl DeRon for $ ty { 555 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result< $ ty, 556 | DeRonErr> { 557 | //s.is_prefix(p, i) ?; 558 | let val = s.u64_range( $ max as u64) ?; 559 | s.next_tok(i) ?; 560 | return Ok(val as $ ty); 561 | } 562 | } 563 | } 564 | } 565 | 566 | macro_rules!impl_ser_de_ron_signed { 567 | ( $ ty: ident, $ min: expr, $ max: expr) => { 568 | impl SerRon for $ ty { 569 | fn ser_ron(&self, _d: usize, s: &mut SerRonState) { 570 | s.out.push_str(&self.to_string()); 571 | } 572 | } 573 | 574 | impl DeRon for $ ty { 575 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result< $ ty, 576 | DeRonErr> { 577 | //s.is_prefix(p, i) ?; 578 | let val = s.i64_range( $ min as i64, $ max as i64) ?; 579 | s.next_tok(i) ?; 580 | return Ok(val as $ ty); 581 | } 582 | } 583 | } 584 | } 585 | 586 | macro_rules!impl_ser_de_ron_float { 587 | ( $ ty: ident) => { 588 | impl SerRon for $ ty { 589 | fn ser_ron(&self, _d: usize, s: &mut SerRonState) { 590 | s.out.push_str(&self.to_string()); 591 | } 592 | } 593 | 594 | impl DeRon for $ ty { 595 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result< $ ty, 596 | DeRonErr> { 597 | //s.is_prefix(p, i) ?; 598 | let val = s.as_f64() ?; 599 | s.next_tok(i) ?; 600 | return Ok(val as $ ty); 601 | } 602 | } 603 | } 604 | } 605 | 606 | impl_ser_de_ron_unsigned!(usize, std::u64::MAX); 607 | impl_ser_de_ron_unsigned!(u64, std::u64::MAX); 608 | impl_ser_de_ron_unsigned!(u32, std::u32::MAX); 609 | impl_ser_de_ron_unsigned!(u16, std::u16::MAX); 610 | impl_ser_de_ron_unsigned!(u8, std::u8::MAX); 611 | impl_ser_de_ron_signed!(i64, std::i64::MIN, std::i64::MAX); 612 | impl_ser_de_ron_signed!(i32, std::i64::MIN, std::i64::MAX); 613 | impl_ser_de_ron_signed!(i16, std::i64::MIN, std::i64::MAX); 614 | impl_ser_de_ron_signed!(i8, std::i64::MIN, std::i8::MAX); 615 | impl_ser_de_ron_float!(f64); 616 | impl_ser_de_ron_float!(f32); 617 | 618 | impl SerRon for Option where T: SerRon { 619 | fn ser_ron(&self, d: usize, s: &mut SerRonState) { 620 | if let Some(v) = self { 621 | v.ser_ron(d, s); 622 | } 623 | else { 624 | s.out.push_str("None"); 625 | } 626 | } 627 | } 628 | 629 | impl DeRon for Option where T: DeRon { 630 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result { 632 | if let DeRonTok::Ident = &s.tok { 633 | if s.identbuf == "None" { 634 | s.next_tok(i) ?; 635 | return Ok(None) 636 | } 637 | } 638 | Ok(Some(DeRon::de_ron(s, i) ?)) 639 | } 640 | } 641 | 642 | impl SerRon for bool { 643 | fn ser_ron(&self, _d: usize, s: &mut SerRonState) { 644 | if *self { 645 | s.out.push_str("true") 646 | } 647 | else { 648 | s.out.push_str("false") 649 | } 650 | } 651 | } 652 | 653 | impl DeRon for bool { 654 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result { 655 | let val = s.as_bool() ?; 656 | s.next_tok(i) ?; 657 | return Ok(val); 658 | } 659 | } 660 | 661 | impl SerRon for String { 662 | fn ser_ron(&self, _d: usize, s: &mut SerRonState) { 663 | s.out.push('"'); 664 | for c in self.chars() { 665 | match c { 666 | '\n' => {s.out.push('\\'); s.out.push('n');}, 667 | '\r' => {s.out.push('\\'); s.out.push('r');}, 668 | '\t' => {s.out.push('\\'); s.out.push('t');}, 669 | '\0' => {s.out.push('\\'); s.out.push('0');}, 670 | '\\' => {s.out.push('\\'); s.out.push('\\');}, 671 | '"' => {s.out.push('\\'); s.out.push('"');}, 672 | _ => s.out.push(c) 673 | } 674 | } 675 | s.out.push('"'); 676 | } 677 | } 678 | 679 | impl DeRon for String { 680 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result { 681 | let val = s.as_string() ?; 682 | s.next_tok(i) ?; 683 | return Ok(val); 684 | } 685 | } 686 | 687 | impl SerRon for Vec where T: SerRon { 688 | fn ser_ron(&self, d: usize, s: &mut SerRonState) { 689 | s.out.push_str("[\n"); 690 | for item in self { 691 | s.indent(d + 1); 692 | item.ser_ron(d + 1, s); 693 | s.conl(); 694 | } 695 | s.indent(d); 696 | s.out.push(']'); 697 | } 698 | } 699 | 700 | impl DeRon for Vec where T: DeRon { 701 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result, DeRonErr> { 702 | let mut out = Vec::new(); 703 | s.block_open(i) ?; 704 | 705 | while s.tok != DeRonTok::BlockClose { 706 | out.push(DeRon::de_ron(s, i) ?); 707 | s.eat_comma_block(i) ?; 708 | } 709 | s.block_close(i) ?; 710 | Ok(out) 711 | } 712 | } 713 | 714 | impl SerRon for [T] where T: SerRon { 715 | fn ser_ron(&self, d: usize, s: &mut SerRonState) { 716 | s.out.push('('); 717 | let last = self.len() - 1; 718 | for (index, item) in self.iter().enumerate() { 719 | item.ser_ron(d + 1, s); 720 | if index != last { 721 | s.out.push_str(", "); 722 | } 723 | } 724 | s.out.push(')'); 725 | } 726 | } 727 | 728 | unsafe fn de_ron_array_impl_inner(top: *mut T, count: usize, s: &mut DeRonState, i: &mut Chars) -> Result<(), DeRonErr> where T: DeRon { 729 | s.paren_open(i) ?; 730 | for c in 0..count { 731 | top.add(c).write(DeRon::de_ron(s, i) ?); 732 | s.eat_comma_paren(i) ?; 733 | } 734 | s.paren_close(i) ?; 735 | Ok(()) 736 | } 737 | 738 | macro_rules!de_ron_array_impl { 739 | ( $ ( $ count: expr), *) => { 740 | $ ( 741 | impl DeRon for [T; $ count] where T: DeRon { 742 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result { 744 | unsafe { 745 | let mut to = std::mem::MaybeUninit::<[T; $ count]>::uninit(); 746 | let top: *mut T = std::mem::transmute(&mut to); 747 | de_ron_array_impl_inner(top, $ count, s, i) ?; 748 | Ok(to.assume_init()) 749 | } 750 | } 751 | } 752 | ) * 753 | } 754 | } 755 | 756 | de_ron_array_impl!(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32); 757 | 758 | fn de_ron_comma_paren(s: &mut DeRonState, i: &mut Chars) -> Result where T: DeRon { 759 | let t = DeRon::de_ron(s, i); 760 | s.eat_comma_paren(i) ?; 761 | t 762 | } 763 | 764 | impl SerRon for (A, B) where A: SerRon, 765 | B: SerRon { 766 | fn ser_ron(&self, d: usize, s: &mut SerRonState) { 767 | s.out.push('('); 768 | self.0.ser_ron(d, s); 769 | s.out.push_str(", "); 770 | self.1.ser_ron(d, s); 771 | s.out.push(')'); 772 | } 773 | } 774 | 775 | impl DeRon for (A, B) where A: DeRon, 776 | B: DeRon { 777 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<(A, B), DeRonErr> { 778 | s.paren_open(i) ?; 779 | let r = (de_ron_comma_paren(s, i) ?, de_ron_comma_paren(s, i) ?); 780 | s.paren_close(i) ?; 781 | Ok(r) 782 | } 783 | } 784 | 785 | impl SerRon for (A, B, C) where A: SerRon, 786 | B: SerRon, 787 | C: SerRon { 788 | fn ser_ron(&self, d: usize, s: &mut SerRonState) { 789 | s.out.push('('); 790 | self.0.ser_ron(d, s); 791 | s.out.push_str(", "); 792 | self.1.ser_ron(d, s); 793 | s.out.push_str(", "); 794 | self.2.ser_ron(d, s); 795 | s.out.push(')'); 796 | } 797 | } 798 | 799 | impl DeRon for (A, B, C) where A: DeRon, 800 | B: DeRon, 801 | C: DeRon { 802 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<(A, B, C), DeRonErr> { 803 | s.paren_open(i) ?; 804 | let r = (de_ron_comma_paren(s, i) ?, de_ron_comma_paren(s, i) ?, de_ron_comma_paren(s, i) ?); 805 | s.paren_close(i) ?; 806 | Ok(r) 807 | } 808 | } 809 | 810 | impl SerRon for (A, B, C, D) where A: SerRon, 811 | B: SerRon, 812 | C: SerRon, 813 | D: SerRon { 814 | fn ser_ron(&self, d: usize, s: &mut SerRonState) { 815 | s.out.push('('); 816 | self.0.ser_ron(d, s); 817 | s.out.push_str(", "); 818 | self.1.ser_ron(d, s); 819 | s.out.push_str(", "); 820 | self.2.ser_ron(d, s); 821 | s.out.push_str(", "); 822 | self.3.ser_ron(d, s); 823 | s.out.push(')'); 824 | } 825 | } 826 | 827 | impl DeRon for (A, B, C, D) where A: DeRon, 828 | B: DeRon, 829 | C: DeRon, 830 | D: DeRon { 831 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result<(A, B, C, D), DeRonErr> { 832 | s.paren_open(i) ?; 833 | let r = (de_ron_comma_paren(s, i) ?, de_ron_comma_paren(s, i) ?, de_ron_comma_paren(s, i) ?, de_ron_comma_paren(s, i) ?); 834 | s.paren_close(i) ?; 835 | Ok(r) 836 | } 837 | } 838 | 839 | impl SerRon for HashMap where K: SerRon, 840 | V: SerRon { 841 | fn ser_ron(&self, d: usize, s: &mut SerRonState) { 842 | s.out.push_str("{\n"); 843 | for (k, v) in self { 844 | s.indent(d + 1); 845 | k.ser_ron(d + 1, s); 846 | s.out.push_str(":"); 847 | v.ser_ron(d + 1, s); 848 | s.conl(); 849 | } 850 | s.indent(d); 851 | s.out.push('}'); 852 | } 853 | } 854 | 855 | impl DeRon for HashMap where K: DeRon + Eq + Hash, 856 | V: DeRon { 857 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result { 859 | let mut h = HashMap::new(); 860 | s.curly_open(i) ?; 861 | while s.tok != DeRonTok::CurlyClose { 862 | let k = DeRon::de_ron(s, i) ?; 863 | s.colon(i) ?; 864 | let v = DeRon::de_ron(s, i) ?; 865 | s.eat_comma_curly(i) ?; 866 | h.insert(k, v); 867 | } 868 | s.curly_close(i) ?; 869 | Ok(h) 870 | } 871 | } 872 | 873 | impl SerRon for Box where T: SerRon { 874 | fn ser_ron(&self, d: usize, s: &mut SerRonState) { 875 | (**self).ser_ron(d, s) 876 | } 877 | } 878 | 879 | impl DeRon for Box where T: DeRon { 880 | fn de_ron(s: &mut DeRonState, i: &mut Chars) -> Result, DeRonErr> { 881 | Ok(Box::new(DeRon::de_ron(s, i) ?)) 882 | } 883 | } --------------------------------------------------------------------------------