678 lines
30 KiB
Rust
678 lines
30 KiB
Rust
use crate::lexer::{lex, LexerState, TokenType};
|
|
use crate::parser::{new_vars, Ast, AstType, Parser, Variable, VariableType};
|
|
use std::collections::HashMap;
|
|
use std::fs;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Transpiler {
|
|
pub state: LexerState,
|
|
pub auto_mut: bool,
|
|
pub auto_macro: bool,
|
|
pub auto_pub: bool,
|
|
pub macros: Vec<String>,
|
|
pub modnum: u32,
|
|
pub peek: String,
|
|
pub matched_vars: HashMap<String, Variable>,
|
|
}
|
|
|
|
impl Default for Transpiler {
|
|
fn default() -> Transpiler {
|
|
Transpiler {
|
|
state: LexerState { line: 1, column: 0 },
|
|
auto_mut: true,
|
|
auto_macro: true,
|
|
auto_pub: false,
|
|
macros: vec![String::from("println")],
|
|
modnum: 0,
|
|
peek: String::new(),
|
|
matched_vars: HashMap::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Transpiler {
|
|
pub fn transpile(
|
|
&mut self,
|
|
input: String,
|
|
indent: u32,
|
|
variables: HashMap<String, Variable>,
|
|
) -> String {
|
|
let mut variables = variables;
|
|
let mut result = String::new();
|
|
if indent == 0 {
|
|
// result += "type int = i32;\n";
|
|
} else {
|
|
result += " ".repeat((indent as usize) * 2).as_str();
|
|
}
|
|
let lexer_out = lex(input.as_str(), false, self.state);
|
|
|
|
match lexer_out {
|
|
Ok(tokens) => {
|
|
let mut full_ast = Parser::new(tokens.clone(), variables.clone());
|
|
let mut last_ast = Ast {
|
|
ast_type: AstType::Other,
|
|
tokens: vec![],
|
|
};
|
|
for ast in full_ast.parse() {
|
|
variables = full_ast.variables.clone();
|
|
if ast.ast_type == AstType::Other
|
|
&& ast.tokens[0].token_type == TokenType::Identifier
|
|
&& ast.tokens[0].value.contains(&self.peek)
|
|
&& self.peek != ""
|
|
{
|
|
let ctoken = &ast.tokens[0];
|
|
// let pname = ctoken.value.split(&self.peek).next().unwrap();
|
|
for (name, var) in variables.clone() {
|
|
if ctoken.line > var.state.line || var.vtype != VariableType::Var {
|
|
self.matched_vars.insert(name, var);
|
|
}
|
|
}
|
|
self.peek = String::new();
|
|
continue;
|
|
}
|
|
if last_ast.tokens.len() > 0 {
|
|
let mut fl = 0;
|
|
for t in &last_ast.tokens {
|
|
fl += t.value.len()
|
|
}
|
|
if ast.tokens[ast.tokens.len() - 1].column
|
|
> last_ast.tokens[last_ast.tokens.len() - 1].column + fl
|
|
{
|
|
result += " "
|
|
.repeat(
|
|
ast.tokens[ast.tokens.len() - 1].column
|
|
- (last_ast.tokens[last_ast.tokens.len() - 1].column + fl),
|
|
)
|
|
.as_str();
|
|
}
|
|
}
|
|
last_ast = Ast {
|
|
ast_type: ast.ast_type.clone(),
|
|
tokens: ast.tokens.clone(),
|
|
};
|
|
|
|
if ast.ast_type == AstType::FunctionDeceleration {
|
|
if self.auto_pub {
|
|
result += "pub ";
|
|
}
|
|
result += format!(
|
|
"fn {}({}) -> {} {}",
|
|
ast.tokens[1].value,
|
|
self.transpile_round(ast.tokens[2].value.clone(), variables.clone()),
|
|
ast.tokens[0].value,
|
|
self.transpile(
|
|
ast.tokens[3].value.clone(),
|
|
indent + 1,
|
|
variables.clone()
|
|
)
|
|
)
|
|
.as_str();
|
|
} else if ast.ast_type == AstType::VoidFunctionDeceleration {
|
|
if self.auto_pub {
|
|
result += "pub ";
|
|
}
|
|
result += format!(
|
|
"fn {}({}) {}",
|
|
ast.tokens[1].value,
|
|
self.transpile_round(ast.tokens[2].value.clone(), variables.clone()),
|
|
self.transpile(
|
|
ast.tokens[3].value.clone(),
|
|
indent + 1,
|
|
variables.clone()
|
|
)
|
|
)
|
|
.as_str();
|
|
} else if ast.ast_type == AstType::StructDeceleration {
|
|
if self.auto_pub {
|
|
result += "pub ";
|
|
}
|
|
result += format!(
|
|
"struct {} {} {}",
|
|
ast.tokens[0].value,
|
|
"{\n",
|
|
self.transpile_round(ast.tokens[1].value.clone(), variables.clone())
|
|
.trim_end()
|
|
)
|
|
.replace(
|
|
"\n",
|
|
("\n".to_string() + " ".repeat(((indent + 1) as usize) * 2).as_str())
|
|
.as_str(),
|
|
)
|
|
.as_str();
|
|
result += "\n}\n";
|
|
} else if ast.ast_type == AstType::VariableDeceleration {
|
|
if self.clone().auto_mut {
|
|
result +=
|
|
format!("let mut {}: {}", ast.tokens[1].value, ast.tokens[0].value)
|
|
.as_str();
|
|
} else {
|
|
result +=
|
|
format!("let {}: {}", ast.tokens[1].value, ast.tokens[0].value)
|
|
.as_str();
|
|
}
|
|
} else if ast.ast_type == AstType::MutVariableDeceleration {
|
|
result +=
|
|
format!("let mut {}: {}", ast.tokens[1].value, ast.tokens[0].value)
|
|
.as_str();
|
|
} else if ast.ast_type == AstType::Other
|
|
&& ast.tokens[0].token_type == TokenType::Round
|
|
{
|
|
result += format!(
|
|
"({})",
|
|
self.transpile_round(ast.tokens[0].value.clone(), variables.clone())
|
|
)
|
|
.as_str();
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Square
|
|
{
|
|
result += format!(
|
|
"[{}]",
|
|
self.transpile_square(
|
|
ast.tokens[0].value.clone(),
|
|
LexerState {
|
|
line: ast.tokens[0].line,
|
|
column: ast.tokens[0].column
|
|
},
|
|
variables.clone()
|
|
)
|
|
)
|
|
.as_str();
|
|
} else if ast.ast_type == AstType::CodeBlock {
|
|
result += "{";
|
|
result += ast.tokens[0].value.as_str();
|
|
result += "}";
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Curly
|
|
{
|
|
// if ast.tokens[0].token_type == TokenType::Newline {
|
|
// result += (ast.tokens[0].value.as_str().to_owned()
|
|
// + (" ".repeat((indent as usize) * 2).as_str()))
|
|
// .as_str();
|
|
// } else {
|
|
// result += ast.tokens[0].value.as_str();
|
|
result += self
|
|
.transpile_json(
|
|
ast.tokens[0].value.as_str().to_string(),
|
|
LexerState {
|
|
line: ast.tokens[0].line,
|
|
column: ast.tokens[0].column,
|
|
},
|
|
variables.clone(),
|
|
)
|
|
.as_str();
|
|
// }
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Ptr {
|
|
result += ".";
|
|
} else if ast.ast_type == AstType::StructCall {
|
|
result += ast.tokens[0].value.as_str();
|
|
result += " {";
|
|
result += ast.tokens[1].value.as_str();
|
|
result += "}";
|
|
} else if ast.ast_type == AstType::StructVar {
|
|
result += format!(
|
|
"let mut {}: {} = {} {}{}{}",
|
|
ast.tokens[1].value.as_str(),
|
|
ast.tokens[0].value.as_str(),
|
|
ast.tokens[0].value.as_str(),
|
|
"{",
|
|
ast.tokens[2].value.as_str(),
|
|
"}"
|
|
)
|
|
.as_str();
|
|
} else if ast.ast_type == AstType::Include {
|
|
let modname = self.transpile_mod(ast, "lib/");
|
|
result += "mod ";
|
|
result += modname.as_str();
|
|
result += ";\n";
|
|
result += "use ";
|
|
result += modname.as_str();
|
|
result += "::*;\n";
|
|
self.modnum += 1;
|
|
} else if ast.ast_type == AstType::IncludeLocal {
|
|
let modname = self.transpile_mod(ast, "");
|
|
result += "mod ";
|
|
result += modname.as_str();
|
|
result += ";\n";
|
|
result += "use ";
|
|
result += modname.as_str();
|
|
result += "::*;\n";
|
|
self.modnum += 1;
|
|
} else if ast.ast_type == AstType::State3 {
|
|
result += format!(
|
|
"{} {} {}",
|
|
ast.tokens[0].value.clone(),
|
|
self.transpile_round(ast.tokens[1].value.clone(), variables.clone()),
|
|
self.transpile(
|
|
ast.tokens[2].value.clone(),
|
|
indent + 1,
|
|
variables.clone()
|
|
),
|
|
)
|
|
.as_str();
|
|
} else if ast.ast_type == AstType::State2 {
|
|
result += format!(
|
|
"{} {}",
|
|
ast.tokens[0].value.clone(),
|
|
self.transpile(
|
|
ast.tokens[1].value.clone(),
|
|
indent + 1,
|
|
variables.clone()
|
|
),
|
|
)
|
|
.as_str();
|
|
} else if ast.ast_type == AstType::Namespace {
|
|
result += format!(
|
|
"mod {} {}{}{}",
|
|
&ast.tokens[0].value.clone(),
|
|
"{",
|
|
self.transpile(ast.tokens[1].value.clone(), 0, variables.clone()),
|
|
"}"
|
|
)
|
|
.as_str();
|
|
} else if ast.ast_type == AstType::Impl {
|
|
result += format!(
|
|
"impl {} {}{}{}",
|
|
&ast.tokens[0].value.clone(),
|
|
"{",
|
|
self.transpile(ast.tokens[1].value.clone(), 0, variables.clone()),
|
|
"}"
|
|
)
|
|
.as_str();
|
|
} else if ast.ast_type == AstType::PointerDeceleration {
|
|
if self.auto_mut {
|
|
result += format!(
|
|
"let mut {}: &mut {}",
|
|
ast.tokens[1].value, ast.tokens[0].value
|
|
)
|
|
.as_str();
|
|
} else {
|
|
result += format!(
|
|
"let {}: &mut {}",
|
|
ast.tokens[1].value, ast.tokens[0].value
|
|
)
|
|
.as_str();
|
|
}
|
|
}
|
|
// flp
|
|
else {
|
|
if ast.tokens[0].token_type == TokenType::Newline {
|
|
result += (ast.tokens[0].value.as_str().to_owned()
|
|
+ (" ".repeat((indent as usize) * 2).as_str()))
|
|
.as_str();
|
|
} else if ast.tokens[0].token_type == TokenType::Semicolon {
|
|
result += ";\n";
|
|
result += " ".repeat((indent as usize) * 2).as_str();
|
|
} else {
|
|
// if last_ast.tokens.len() > 0 && (
|
|
// last_ast.tokens[last_ast.tokens.len()-1].token_type == TokenType::Identifier ||
|
|
// last_ast.tokens[last_ast.tokens.len()-1].token_type == TokenType::Keyword ||
|
|
// last_ast.tokens[last_ast.tokens.len()-1].token_type == TokenType::Number
|
|
// ) {
|
|
// let ltkn = last_ast.tokens[last_ast.tokens.len()-1].token_type;
|
|
// if ltkn == TokenType::Identifier ||
|
|
// ltkn == TokenType::Keyword ||
|
|
// ltkn == TokenType::Number {
|
|
// }
|
|
// }
|
|
result += ast.tokens[0].value.as_str();
|
|
if self.auto_macro
|
|
&& self
|
|
.macros
|
|
.contains(&ast.tokens[0].value.as_str().to_string())
|
|
{
|
|
result += "!";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
result = result.trim_end().to_string();
|
|
|
|
// if self.var_match != "" && (self.state.line + input.len()) > self.var_state.line {
|
|
// for (name, var) in variables {
|
|
// if (self.var_state.line > var.line
|
|
// || (self.var_state.line == var.line
|
|
// && self.var_state.column > var.column))
|
|
// && name.to_lowercase().starts_with(&self.var_match)
|
|
// {
|
|
// self.matched_vars.insert(name, var);
|
|
// }
|
|
// }
|
|
// self.var_match = String::new();
|
|
// }
|
|
|
|
if indent > 0 {
|
|
result += "\n";
|
|
result += " ".repeat((indent as usize - 1) * 2).as_str();
|
|
return "{\n".to_owned() + result.as_str() + "}";
|
|
} else {
|
|
return result;
|
|
}
|
|
}
|
|
Err((state, _tokens)) => {
|
|
panic!("Invalid syntax at code.ws:{}:{}", state.line, state.column);
|
|
}
|
|
}
|
|
}
|
|
pub fn transpile_mod(&mut self, ast: Ast, s: &str) -> String {
|
|
let modfile = ast.tokens[0].value.as_str();
|
|
let modname = format!(
|
|
"mod_{}",
|
|
// clean_incl(modfile.split(".").collect::<Vec<_>>()[0]),
|
|
self.clone().modnum
|
|
);
|
|
let file_content = fs::read_to_string(s.to_string() + modfile).expect("Error reading file");
|
|
let transpiled_code = self.transpile(file_content, 0, new_vars());
|
|
fs::write(
|
|
("build/".to_string() + modname.as_str()) + ".rs",
|
|
transpiled_code,
|
|
)
|
|
.expect("Error writing file");
|
|
modname
|
|
}
|
|
pub fn transpile_round(
|
|
&mut self,
|
|
input: String,
|
|
variables: HashMap<String, Variable>,
|
|
) -> String {
|
|
let mut result = String::new();
|
|
let lexer_out = lex(input.as_str(), false, self.state);
|
|
match lexer_out {
|
|
Ok(tokens) => {
|
|
let mut full_ast = Parser::new(tokens.clone(), variables.clone());
|
|
let mut last_ast = Ast {
|
|
ast_type: AstType::Other,
|
|
tokens: vec![],
|
|
};
|
|
for ast in full_ast.parse() {
|
|
if last_ast.tokens.len() > 0 {
|
|
let mut fl = 0;
|
|
for t in &last_ast.tokens {
|
|
fl += t.value.len()
|
|
}
|
|
if ast.tokens[ast.tokens.len() - 1].column
|
|
> last_ast.tokens[last_ast.tokens.len() - 1].column + fl
|
|
{
|
|
result += " "
|
|
.repeat(
|
|
ast.tokens[ast.tokens.len() - 1].column
|
|
- (last_ast.tokens[last_ast.tokens.len() - 1].column + fl),
|
|
)
|
|
.as_str();
|
|
}
|
|
}
|
|
last_ast = Ast {
|
|
ast_type: ast.ast_type.clone(),
|
|
tokens: ast.tokens.clone(),
|
|
};
|
|
if ast.ast_type == AstType::VariableDeceleration {
|
|
result +=
|
|
format!("{}: {}", ast.tokens[1].value, ast.tokens[0].value).as_str();
|
|
} else if ast.ast_type == AstType::MutVariableDeceleration {
|
|
result += format!("mut {}: {}", ast.tokens[1].value, ast.tokens[0].value)
|
|
.as_str();
|
|
} else if ast.ast_type == AstType::PointerDeceleration {
|
|
result += format!("{}: &mut {}", ast.tokens[1].value, ast.tokens[0].value)
|
|
.as_str();
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Round
|
|
{
|
|
result += format!(
|
|
"({})",
|
|
self.transpile_round(ast.tokens[0].value.clone(), variables.clone())
|
|
)
|
|
.as_str();
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Square
|
|
{
|
|
result += format!(
|
|
"[{}]",
|
|
self.transpile_square(
|
|
ast.tokens[0].value.clone(),
|
|
LexerState {
|
|
line: ast.tokens[0].line,
|
|
column: ast.tokens[0].column
|
|
},
|
|
variables.clone()
|
|
)
|
|
)
|
|
.as_str();
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Ptr {
|
|
result += ".";
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Curly
|
|
{
|
|
result += self
|
|
.transpile_json(
|
|
ast.tokens[0].value.as_str().to_string(),
|
|
LexerState {
|
|
line: ast.tokens[0].line,
|
|
column: ast.tokens[0].column,
|
|
},
|
|
variables.clone(),
|
|
)
|
|
.as_str();
|
|
} else if ast.ast_type == AstType::StructCall {
|
|
result += ast.tokens[0].value.as_str();
|
|
result += " {";
|
|
result += ast.tokens[1].value.as_str();
|
|
result += "}";
|
|
} else if ast.ast_type == AstType::Ref {
|
|
result += "&mut ";
|
|
result += ast.tokens[0].value.as_str();
|
|
}
|
|
// flp
|
|
else {
|
|
result += ast.tokens[0].value.as_str();
|
|
}
|
|
}
|
|
|
|
result = result.trim_end().to_string();
|
|
result
|
|
}
|
|
Err((state, _tokens)) => {
|
|
panic!("Invalid syntax at code.ws:{}:{}", state.line, state.column);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn transpile_square(
|
|
&mut self,
|
|
input: String,
|
|
state: LexerState,
|
|
variables: HashMap<String, Variable>,
|
|
) -> String {
|
|
let mut result = String::new();
|
|
let lexer_out = lex(input.as_str(), false, state);
|
|
match lexer_out {
|
|
Ok(tokens) => {
|
|
let mut full_ast = Parser::new(tokens.clone(), variables.clone());
|
|
let mut last_ast = Ast {
|
|
ast_type: AstType::Other,
|
|
tokens: vec![],
|
|
};
|
|
for ast in full_ast.parse() {
|
|
if last_ast.tokens.len() > 0 {
|
|
let mut fl = 0;
|
|
for t in &last_ast.tokens {
|
|
fl += t.value.len()
|
|
}
|
|
if ast.tokens[ast.tokens.len() - 1].column
|
|
> last_ast.tokens[last_ast.tokens.len() - 1].column + fl
|
|
{
|
|
result += " "
|
|
.repeat(
|
|
ast.tokens[ast.tokens.len() - 1].column
|
|
- (last_ast.tokens[last_ast.tokens.len() - 1].column + fl),
|
|
)
|
|
.as_str();
|
|
}
|
|
}
|
|
last_ast = Ast {
|
|
ast_type: ast.ast_type.clone(),
|
|
tokens: ast.tokens.clone(),
|
|
};
|
|
|
|
if ast.ast_type == AstType::VariableDeceleration {
|
|
result +=
|
|
format!("{}: {}", ast.tokens[1].value, ast.tokens[0].value).as_str();
|
|
} else if ast.ast_type == AstType::MutVariableDeceleration {
|
|
result += format!("mut {}: {}", ast.tokens[1].value, ast.tokens[0].value)
|
|
.as_str();
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Round
|
|
{
|
|
result += format!(
|
|
"({})",
|
|
self.transpile_round(ast.tokens[0].value.clone(), variables.clone())
|
|
)
|
|
.as_str();
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Square
|
|
{
|
|
result += format!(
|
|
"[{}]",
|
|
self.transpile_square(
|
|
ast.tokens[0].value.clone(),
|
|
LexerState {
|
|
line: ast.tokens[0].line,
|
|
column: ast.tokens[0].column
|
|
},
|
|
variables.clone()
|
|
)
|
|
)
|
|
.as_str();
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Ptr {
|
|
result += ".";
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Curly
|
|
{
|
|
result += self
|
|
.transpile_json(
|
|
ast.tokens[0].value.as_str().to_string(),
|
|
LexerState {
|
|
line: ast.tokens[0].line,
|
|
column: ast.tokens[0].column,
|
|
},
|
|
variables.clone(),
|
|
)
|
|
.as_str();
|
|
} else if ast.ast_type == AstType::StructCall {
|
|
result += ast.tokens[0].value.as_str();
|
|
result += " {";
|
|
result += ast.tokens[1].value.as_str();
|
|
result += "}";
|
|
}
|
|
// flp
|
|
else {
|
|
result += ast.tokens[0].value.as_str();
|
|
}
|
|
}
|
|
|
|
result = result.trim_end().to_string();
|
|
result
|
|
}
|
|
Err((state, _tokens)) => {
|
|
panic!("Invalid syntax at code.ws:{}:{}", state.line, state.column);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn transpile_json(
|
|
&mut self,
|
|
input: String,
|
|
state: LexerState,
|
|
variables: HashMap<String, Variable>,
|
|
) -> String {
|
|
let mut result = String::new();
|
|
let lexer_out = lex(input.as_str(), false, state);
|
|
match lexer_out {
|
|
Ok(tokens) => {
|
|
let mut full_ast = Parser::new(tokens.clone(), variables.clone());
|
|
full_ast.json = true;
|
|
result += "HashMap::from([";
|
|
let mut last_ast = Ast {
|
|
ast_type: AstType::Other,
|
|
tokens: vec![],
|
|
};
|
|
for ast in full_ast.parse() {
|
|
if last_ast.tokens.len() > 0 {
|
|
let mut fl = 0;
|
|
for t in &last_ast.tokens {
|
|
fl += t.value.len()
|
|
}
|
|
if ast.tokens[ast.tokens.len() - 1].column
|
|
> last_ast.tokens[last_ast.tokens.len() - 1].column + fl
|
|
{
|
|
result += " "
|
|
.repeat(
|
|
ast.tokens[ast.tokens.len() - 1].column
|
|
- (last_ast.tokens[last_ast.tokens.len() - 1].column + fl),
|
|
)
|
|
.as_str();
|
|
}
|
|
}
|
|
last_ast = Ast {
|
|
ast_type: ast.ast_type.clone(),
|
|
tokens: ast.tokens.clone(),
|
|
};
|
|
|
|
if ast.ast_type == AstType::Json {
|
|
result += "(";
|
|
result += ast.tokens[0].value.as_str();
|
|
result += ",";
|
|
result += ast.tokens[1].value.as_str();
|
|
result += ")";
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Round
|
|
{
|
|
result += format!(
|
|
"({})",
|
|
self.transpile_round(ast.tokens[0].value.clone(), variables.clone())
|
|
)
|
|
.as_str();
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Square
|
|
{
|
|
result += format!(
|
|
"[{}]",
|
|
self.transpile_square(
|
|
ast.tokens[0].value.clone(),
|
|
LexerState {
|
|
line: ast.tokens[0].line,
|
|
column: ast.tokens[0].column
|
|
},
|
|
variables.clone()
|
|
)
|
|
)
|
|
.as_str();
|
|
} else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Curly
|
|
{
|
|
result += self
|
|
.transpile_json(
|
|
ast.tokens[0].value.as_str().to_string(),
|
|
LexerState {
|
|
line: ast.tokens[0].line,
|
|
column: ast.tokens[0].column,
|
|
},
|
|
variables.clone(),
|
|
)
|
|
.as_str();
|
|
} else {
|
|
result += ast.tokens[0].value.as_str();
|
|
}
|
|
}
|
|
result += "])";
|
|
result = result.trim_end().to_string();
|
|
result
|
|
}
|
|
Err((state, _tokens)) => {
|
|
panic!("Invalid syntax at code.ws:{}:{}", state.line, state.column);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// fn clean_incl(input: &str) -> String {
|
|
// input
|
|
// .chars()
|
|
// .map(|c| {
|
|
// if c.is_alphanumeric() || c == '_' {
|
|
// c
|
|
// } else {
|
|
// '_'
|
|
// }
|
|
// })
|
|
// .collect()
|
|
// }
|