added ast validation

Author: DigitalCodeCrafter

Cargo.toml

@@ -2,6 +2,7 @@
 name = "ksmc"
 version = "0.1.0"
 edition = "2024"
+license = "MIT"
 
 [dependencies]
 flate2 = "1.1.4"

README.md

@@ -0,0 +1,49 @@
+# ksmc
+
+A rust-based, assembler, disassembler, and compiler for **kOS** - a scripting mod for Kerbal Space Program.
+
+## Features
+
+ - **Assembler & Disassembler** for `.ksm` (kOS machine code) binaries
+ - **Compiler** from high-level code to kerboscipt bytecode
+
+## Building
+
+Requires **Rust 1.86+**
+
+```bash
+git clone https://github.com/<your-username>/ksmc.git
+cd ksmc
+cargo build --release
+```
+
+## Usage
+
+Assemble a `.ksm` binary:
+
+```bash
+./target/release/ksmc input.kasm -o output.ksm
+```
+
+Disassemble a `.ksm` binary:
+
+```bash
+./target/release/ksmc input.ksm -o output.kasm --dump
+```
+
+look at `src/main.rs` for further info
+
+## License
+
+Licensed under [MIT License](LICENSE)
+
+## Roadmap
+
+ - minimal working compiler
+ - optimization passes
+ - compiler safety options
+
+## NOTE
+
+This project is not affiliated with the official [kOS](https://ksp-kos.github.io/KOS/) team.
+It’s an independent project for learning and personal interest.

src/compiler.rs

@@ -3,7 +3,7 @@
 // [/] parser
 // [/] expander
 // [/] resolver
-// [ ] validator
+// [x] validator
 // [ ] type checker
 // [ ] lowerer
 // [ ] optimizer
@@ -18,15 +18,18 @@ mod parser;
 mod ast;
 mod expander;
 mod resolver;
+mod validator;
+mod type_checker;
 
-type CResult<T> = Result<T, CompilerError>;
 #[derive(Debug)]
 pub enum CompilerError {
     Error { text: String },
 
     LexError(Vec<lexer::LexError>),
     ParseError(Vec<parser::ParseError>),
     ExpandError(expander::ExpandError),
+    ResolveError(Vec<resolver::ResolveError>),
+    ValidationError(Vec<validator::ValidationError>),
 
     IoError(std::io::Error),
 }
@@ -39,34 +42,28 @@ impl std::fmt::Display for CompilerError {
             LexError(err) => write!(f, "Error: {:?}", err),
             ParseError(err) => write!(f, "Error: {:?}", err),
             ExpandError(err) => write!(f, "Error: {:?}", err),
+            ResolveError(err) => write!(f, "Error: {:?}", err),
+            ValidationError(err) => write!(f, "Error: {:?}", err),
 
             IoError(e) => write!(f, "{}", e),
         }
     }
 }
 impl std::error::Error for CompilerError {}
 
-trait ToCompileResult<T> {
-    fn into_cresult(self) -> CResult<T>;
-}
-
 pub fn compile(file_path: impl AsRef<Path>) -> Result<(), CompilerError> {
     let src = std::fs::read_to_string(&file_path)
         .map_err(|e| CompilerError::IoError(e))?;
 
-    let tokens = lexer::lex_all(&src).into_cresult()?;
+    let tokens = lexer::lex_all(&src)?;
 
-    let mut ast = parser::parse_tokens(tokens).into_cresult()?;
+    let mut ast = parser::parse_all(tokens)?;
 
-    let mut expander = expander::Expander::new(&mut ast, file_path.as_ref().parent().unwrap(), |src| {
-        lexer::lex_all(src).into_cresult()
-    }, |tokens| {
-        parser::parse_tokens(tokens).into_cresult()
-    });
-    expander.expand_modules()?;
+    expander::expand_all(&mut ast, file_path.as_ref().parent().unwrap())?;
 
-    let mut resolver = resolver::Resolver::new(&ast);
-    let result = resolver.resolve();
+    let symbols = resolver::resolve_all(&ast)?;
+   
+    validator::validate_all(&ast)?;
 
     todo!()
 }

src/compiler/ast.rs

@@ -26,7 +26,7 @@ pub enum NodeKind {
     ArrayRepeat { value: NodeId, count: NodeId },
     UnderscoreExpr,
     IndexExpression { array: NodeId , index: NodeId },
-    TupleIndexExpression { tuple: NodeId , index: i32 },
+    TupleIndexExpression { tuple: NodeId , index: u32 },
     PathExpression { segments: Vec<NodeId> },
     ErrorExpr,
 
@@ -282,7 +282,7 @@ impl Node {
 
 #[derive(Debug, Clone)]
 pub enum Literal {
-    Int(i32),
+    Int(u32),
     Float(f64),
     Bool(bool),
     Str(String),

src/compiler/expander.rs

@@ -1,18 +1,27 @@
 use std::{collections::HashSet, path::{Path, PathBuf}};
-use crate::compiler::{ast::{Node, NodeId, NodeKind, AST}, lexer::Token, CompilerError, ToCompileResult};
+use crate::compiler::{ast::{Node, NodeId, NodeKind, AST}, lexer::Token, CompilerError};
 
 #[derive(Debug)]
 pub enum ExpandError {
     NoProgramRoot,
     NotFound(PathBuf),
     FileRead(PathBuf, std::io::Error),
 }
-impl<T> ToCompileResult<T> for Result<T, ExpandError> {
-    fn into_cresult(self) -> Result<T, super::CompilerError> {
-        self.map_err(|err| CompilerError::ExpandError(err))
+impl From<ExpandError> for CompilerError {
+    fn from(value: ExpandError) -> Self {
+        CompilerError::ExpandError(value)
     }
 }
 
+pub fn expand_all(ast: &mut AST, base_path: &Path) -> Result<(), CompilerError> {
+    let mut expander = Expander::new(ast, base_path, |src| {
+        super::lexer::lex_all(src).map_err(|e| e.into())
+    }, |tokens| {
+        super::parser::parse_all(tokens).map_err(|e| e.into())
+    });
+    expander.expand_modules()
+}
+
 pub struct Expander<'a> {
     pub ast: &'a mut AST,
     pub base_path: &'a Path,
@@ -70,7 +79,7 @@ impl<'a> Expander<'a> {
 
     fn expand_module_file(&mut self, node_id: NodeId, path: &Path) -> Result<(), CompilerError> {
         if !path.exists() {
-            return Err(ExpandError::NotFound(path.to_path_buf())).into_cresult();
+            return Err(ExpandError::NotFound(path.to_path_buf()).into());
         }
 
         // already expanded
@@ -81,7 +90,7 @@ impl<'a> Expander<'a> {
 
         // read and parse
         let src = std::fs::read_to_string(path)
-            .map_err(|e| ExpandError::FileRead(path.to_path_buf(), e)).into_cresult()?;
+            .map_err(|e| ExpandError::FileRead(path.to_path_buf(), e))?;
 
         let tokens = (self.lexer)(&src)?;
         let mut parsed_ast = (self.parser)(tokens)?;

src/compiler/lexer.rs

@@ -1,5 +1,5 @@
 // Source text -> Tokens
-use crate::compiler::{ast::{Pos, Span}, CompilerError, ToCompileResult};
+use crate::compiler::{ast::{Pos, Span}, CompilerError};
 
 const CASE_SENSITIVITY: bool = true;
 
@@ -8,18 +8,17 @@ pub struct LexError {
     pub span: Span,
     pub message: String,
 }
-
-impl<T> ToCompileResult<T> for Result<T, Vec<LexError>> {
-    fn into_cresult(self) -> Result<T, super::CompilerError> {
-        self.map_err(|err| CompilerError::LexError(err))
+impl From<Vec<LexError>> for CompilerError {
+    fn from(value: Vec<LexError>) -> Self {
+        CompilerError::LexError(value)
     }
 }
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum TokenKind {
     // Identifiers and Literals
     Identifier(String),
-    Int(i32),
+    Int(u32),
     Float(f64),
     String(String),
 
@@ -90,7 +89,11 @@ pub struct Token {
 
 pub fn lex_all(src: &str) -> Result<Vec<Token>, Vec<LexError>> {
     let mut lexer = Lexer::new(&src);
-    lexer.lex_all()
+    if lexer.lex_all().is_ok() {
+        Ok(lexer.tokens)
+    } else {
+        Err(lexer.errors)
+    }
 }
 
 pub struct Lexer {
@@ -99,6 +102,7 @@ pub struct Lexer {
     errors: Vec<LexError>,
     line: usize,
     col: usize,
+    pub tokens: Vec<Token>
 }
 impl Lexer {
     pub fn new(input: &str) -> Self {
@@ -108,27 +112,25 @@ impl Lexer {
             errors: Vec::new(),
             line: 1,
             col: 1,
+            tokens: Vec::new(),
         }
     }
 
-    pub fn lex_all(&mut self) -> Result<Vec<Token>, Vec<LexError>> {
-        let mut tokens = Vec::new();
+    pub fn lex_all(&mut self) -> Result<(), &[LexError]> {
         loop {
-            let tok = self.next_token();
-            if matches!(tok.kind, TokenKind::EOF) {
-                tokens.push(tok); break;
-            } else {
-                tokens.push(tok);
+            self.next_token();
+            if matches!(self.tokens.last(), Some(Token { kind: TokenKind::EOF, .. })) {
+                break;
             }
         }
         if self.errors.is_empty() {
-            Ok(tokens)
+            Ok(())
         } else {
-            Err(self.errors.clone())
+            Err(&self.errors)
         }
     }
 
-    pub fn next_token(&mut self) -> Token {
+    fn next_token(&mut self) {
         self.skip_whitespace_and_comment();
 
         let start_line = self.line;
@@ -139,22 +141,20 @@ impl Lexer {
         };
 
         if c.is_alphabetic() {
-            self.lex_identifier_or_keyword(start_line, start_col)
+            self.lex_identifier_or_keyword(start_line, start_col);
         } else if c.is_ascii_digit() {
-            self.lex_number(start_line, start_col)
+            self.lex_number(start_line, start_col);
         } else if c == '.' && self.peek_ahead(1).map_or(false, |n| n.is_ascii_digit()) {
-            self.lex_number(start_line, start_col)
-        } else if c == '-' && self.peek_ahead(1).map_or(false, |n| n.is_ascii_digit()) {
-            self.lex_number(start_line, start_col)
+            self.lex_number(start_line, start_col);
         } else if c == '"' {
-            self.lex_string(start_line, start_col)
+            self.lex_string(start_line, start_col);
         } else {
-            self.lex_symbol(start_line, start_col)
+            self.lex_symbol(start_line, start_col);
         }
     }
 
-    fn make_token(&self, kind: TokenKind, line: usize, col: usize) -> Token {
-        Token { kind, span: self.make_span(line, col) }
+    fn make_token(&mut self, kind: TokenKind, line: usize, col: usize) {
+        self.tokens.push(Token { kind, span: self.make_span(line, col) });
     }
 
     fn make_span(&self, line: usize, col: usize) -> Span {
@@ -232,7 +232,7 @@ impl Lexer {
 
     // --------- Identifiers & Keywords ---------
 
-    fn lex_identifier_or_keyword(&mut self, line: usize, col: usize) -> Token {
+    fn lex_identifier_or_keyword(&mut self, line: usize, col: usize) {
         let mut s = String::new();
         while let Some(c) = self.peek() {
             if c.is_alphanumeric() || c == '_' {
@@ -271,7 +271,7 @@ impl Lexer {
 
     // --------- Numbers ---------
 
-    fn lex_number(&mut self, line: usize, col: usize) -> Token {
+    fn lex_number(&mut self, line: usize, col: usize) {
         let mut num_str = String::new();
         let mut has_dot = false;
         let mut has_exp = false;
@@ -338,7 +338,7 @@ impl Lexer {
         self.make_token(kind, line, col)
     }
 
-    fn lex_based_number(&mut self, base: u32,line: usize, col: usize) -> Token {
+    fn lex_based_number(&mut self, base: u32,line: usize, col: usize) {
         let mut s = String::new();
         while let Some(c) = self.peek() {
             match c {
@@ -363,13 +363,13 @@ impl Lexer {
         }
 
         let cleaned = s.replace("_", "");
-        let value = i32::from_str_radix(&cleaned, base).unwrap_or(0);
+        let value = u32::from_str_radix(&cleaned, base).unwrap_or(0);
         self.make_token(TokenKind::Int(value), line, col)
     }
 
     // --------- Strings ---------
 
-    fn lex_string(&mut self, line: usize, col: usize) -> Token {
+    fn lex_string(&mut self, line: usize, col: usize) {
         self.advance(); // consume '"'
         let mut s = String::new();
 
@@ -403,7 +403,7 @@ impl Lexer {
 
     // --------- Symbols & Operators ---------
 
-    fn lex_symbol(&mut self, line: usize, col: usize) -> Token {
+    fn lex_symbol(&mut self, line: usize, col: usize) {
         use TokenKind::*;
         let c = self.advance().unwrap();
 
@@ -478,7 +478,8 @@ mod tests {
         let mut lexer = Lexer::new(src);
         let mut i = 0;
         loop {
-            let tok = lexer.next_token();
+            lexer.next_token();
+            let tok = lexer.tokens.last().unwrap();
             println!("{:?}", tok);
             assert_eq!(tok.kind, expected[i]);
             if matches!(tok.kind, TokenKind::EOF) { break; }
@@ -500,7 +501,8 @@ mod tests {
         let mut lexer = Lexer::new(src);
         let mut i = 0;
         loop {
-            let tok = lexer.next_token();
+            lexer.next_token();
+            let tok = lexer.tokens.last().unwrap();
             println!("{:?}", tok);
             assert_eq!(tok.kind, expected[i]);
             if matches!(tok.kind, TokenKind::EOF) { break; }
@@ -521,7 +523,8 @@ mod tests {
         let mut lexer = Lexer::new(src);
         let mut i = 0;
         loop {
-            let tok = lexer.next_token();
+            lexer.next_token();
+            let tok = lexer.tokens.last().unwrap();
             println!("{:?}", tok);
             assert_eq!(tok.kind, expected[i]);
             if matches!(tok.kind, TokenKind::EOF) { break; }