[Patch] Noviq-Rust-Nebula-0.1.1

coredex-source · coredex-source · commit ac8e8c77dc36 · 2025-11-08T23:30:38.000+05:30
- Variables and comments.
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "noviq"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 authors = ["Noviq Contributors"]
 description = "A simple, interpreted programming language written in Rust"
diff --git a/README.md b/README.md
@@ -21,6 +21,24 @@ Noviq aims to be a compiled language instead of an interpreted language in the f
 Builder tool for interpreter version is called: Photon or Photon-NVQ
 The compiler will be called: Singularity or Singularity-NVQ
 
+First release of Noviq is expected to be Pre-alpha 1.0.0.
+
+## Implementation:
+### Pre-aplha (Nebula):
+- Basic syntax including but not limited to variables, print, conditionals, etc.
+
+### Aplha (Protostar):
+- Including but not limited to everything that includes a basic workstack for a language like loops, functions, libs, a lot more.
+- Start building a simple compiler.
+
+### Beta (Nova):
+- More advanced features including OOP, etc.
+- Compiler should be able to build most of the code.
+
+### Release (Supernova):
+- A polished interpreted release of everything implemented before it.
+- A fully working compiler which will be polished in future builds.
+
 ## Building
 
 ### Using Photon (Recommended)
diff --git a/examples/README.md b/examples/README.md
@@ -14,17 +14,16 @@ cargo run -- examples/hello.nvq
 
 ## Available Examples
 
-### `hello.nvq`
-Basic hello world program demonstrating:
-- Print statements with `log()`
-- Comments with `#`
-- String literals
-
-### `test.nvq`
-Basic test file for development
+- `hello.nvq` - Basic hello world program
+- `test.nvq` - Simple test file
+- `variables.nvq` - Variable declaration and usage
+- `quotes.nvq` - Single and double quote strings
 
 ## Features Demonstrated
 
 - Comments (lines starting with `#`)
 - Print statements with `print()`
-- String literals
+- String literals (double and single quotes)
+- Variable declarations with `let`
+- Numbers (integers and floats)
+- Booleans (true/false)
diff --git a/examples/quotes.nvq b/examples/quotes.nvq
@@ -0,0 +1,7 @@
+# Testing both quote types
+
+let double_quote = "String with double quotes"
+let single_quote = 'String with single quotes'
+
+print(double_quote)
+print(single_quote)
diff --git a/examples/showcase.nvq b/examples/showcase.nvq
@@ -0,0 +1,22 @@
+# Comprehensive example showcasing Noviq features
+
+# Variable declarations with different types
+let greeting = "Hello, Noviq!"
+let name = 'World'
+let answer = 42
+let pi = 3.14159
+let is_cool = true
+let is_boring = false
+
+# Print variables
+print(greeting)
+print(name)
+print(answer)
+print(pi)
+print(is_cool)
+print(is_boring)
+
+# Direct values in print
+print("Direct string")
+print(123)
+print(true)
diff --git a/examples/variables.nvq b/examples/variables.nvq
@@ -0,0 +1,11 @@
+# Variable declaration test
+
+let message = "Hello from a variable!"
+let number = 42
+let pi = 3.14
+let flag = true
+
+print(message)
+print(number)
+print(pi)
+print(flag)
diff --git a/src/frontend/ast.rs b/src/frontend/ast.rs
@@ -4,15 +4,19 @@
 
 /// AST node definitions for Noviq
 ///
-/// Kept minimal for the current language subset (string literals and function calls)
+/// Expressions and statements for the Noviq language
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Expr {
     String(String),
+    Number(f64),
+    Boolean(bool),
+    Identifier(String),
     Call { name: String, args: Vec<Expr> },
 }
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Stmt {
+    Let { name: String, value: Expr },
     Expr(Expr),
 }
diff --git a/src/frontend/lexer/mod.rs b/src/frontend/lexer/mod.rs
@@ -43,9 +43,23 @@ impl Lexer {
                 self.reader.advance();
                 Token::Newline
             }
-            Some('"') => Token::String(self.reader.read_string()),
+            Some('"') | Some('\'') => Token::String(self.reader.read_string()),
+            Some('=') => {
+                self.reader.advance();
+                Token::Assign
+            }
             Some(ch) if ch.is_alphabetic() || ch == '_' => {
-                Token::Identifier(self.reader.read_identifier())
+                let ident = self.reader.read_identifier();
+                // Check for keywords
+                match ident.as_str() {
+                    "let" => Token::Let,
+                    "true" => Token::True,
+                    "false" => Token::False,
+                    _ => Token::Identifier(ident),
+                }
+            }
+            Some(ch) if ch.is_numeric() => {
+                Token::Number(self.reader.read_number())
             }
             Some('(') => {
                 self.reader.advance();
diff --git a/src/frontend/lexer/reader.rs b/src/frontend/lexer/reader.rs
@@ -45,11 +45,12 @@ impl Reader {
     }
     
     pub fn read_string(&mut self) -> String {
+        let quote_char = self.current.unwrap(); // Remember which quote (' or ")
         let mut result = String::new();
         self.advance(); // Skip opening quote
         
         while let Some(ch) = self.current {
-            if ch == '"' {
+            if ch == quote_char {
                 self.advance(); // Skip closing quote
                 break;
             } else if ch == '\\' {
@@ -60,6 +61,7 @@ impl Reader {
                         't' => result.push('\t'),
                         'r' => result.push('\r'),
                         '"' => result.push('"'),
+                        '\'' => result.push('\''),
                         '\\' => result.push('\\'),
                         _ => {
                             result.push('\\');
@@ -77,6 +79,21 @@ impl Reader {
         result
     }
     
+    pub fn read_number(&mut self) -> f64 {
+        let mut num_str = String::new();
+        
+        while let Some(ch) = self.current {
+            if ch.is_numeric() || ch == '.' {
+                num_str.push(ch);
+                self.advance();
+            } else {
+                break;
+            }
+        }
+        
+        num_str.parse().unwrap_or(0.0)
+    }
+    
     pub fn read_identifier(&mut self) -> String {
         let mut ident = String::new();
         
diff --git a/src/frontend/parser/expr.rs b/src/frontend/parser/expr.rs
@@ -42,17 +42,30 @@ impl<'a> ExprParser<'a> {
                 self.advance();
                 Ok(Expr::String(s))
             }
+            Token::Number(n) => {
+                self.advance();
+                Ok(Expr::Number(n))
+            }
+            Token::True => {
+                self.advance();
+                Ok(Expr::Boolean(true))
+            }
+            Token::False => {
+                self.advance();
+                Ok(Expr::Boolean(false))
+            }
             Token::Identifier(name) => {
                 self.advance();
                 
-                // Must be a function call
+                // Check if it's a function call
                 if self.current() == &Token::LeftParen {
                     self.advance(); // consume '('
                     let args = self.parse_arguments()?;
                     self.expect(Token::RightParen)?;
                     Ok(Expr::Call { name, args })
                 } else {
-                    Err(format!("Expected '(' after identifier '{}'", name))
+                    // Just an identifier (variable reference)
+                    Ok(Expr::Identifier(name))
                 }
             }
             token => Err(format!("Unexpected token in expression: {:?}", token)),
diff --git a/src/frontend/parser/stmt.rs b/src/frontend/parser/stmt.rs
@@ -27,6 +27,12 @@ impl<'a> StmtParser<'a> {
     }
     
     pub fn parse(&mut self) -> Result<Stmt, String> {
+        // Check for let statement
+        if self.current() == &Token::Let {
+            return self.parse_let();
+        }
+        
+        // Otherwise, parse as expression statement
         let mut expr_parser = ExprParser::new(self.tokens, self.position);
         let expr = expr_parser.parse()?;
         
@@ -37,4 +43,32 @@ impl<'a> StmtParser<'a> {
         
         Ok(Stmt::Expr(expr))
     }
+    
+    fn parse_let(&mut self) -> Result<Stmt, String> {
+        self.advance(); // Skip 'let'
+        
+        // Get variable name
+        let name = match self.current() {
+            Token::Identifier(n) => n.clone(),
+            _ => return Err("Expected identifier after 'let'".to_string()),
+        };
+        self.advance();
+        
+        // Expect '='
+        if self.current() != &Token::Assign {
+            return Err("Expected '=' after variable name".to_string());
+        }
+        self.advance();
+        
+        // Parse value expression
+        let mut expr_parser = ExprParser::new(self.tokens, self.position);
+        let value = expr_parser.parse()?;
+        
+        // Skip optional newline
+        if self.current() == &Token::Newline {
+            self.advance();
+        }
+        
+        Ok(Stmt::Let { name, value })
+    }
 }
diff --git a/src/frontend/token.rs b/src/frontend/token.rs
@@ -7,8 +7,20 @@ use std::fmt;
 /// Tokens produced by the lexer
 #[derive(Debug, Clone, PartialEq)]
 pub enum Token {
+    // Keywords
+    Let,
+    
+    // Identifiers and Literals
     Identifier(String),
     String(String),
+    Number(f64),
+    True,
+    False,
+    
+    // Operators
+    Assign,
+    
+    // Delimiters
     LeftParen,
     RightParen,
     Newline,
@@ -18,8 +30,13 @@ pub enum Token {
 impl fmt::Display for Token {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
+            Token::Let => write!(f, "let"),
             Token::Identifier(s) => write!(f, "Identifier({})", s),
             Token::String(s) => write!(f, "String(\"{}\")", s),
+            Token::Number(n) => write!(f, "Number({})", n),
+            Token::True => write!(f, "true"),
+            Token::False => write!(f, "false"),
+            Token::Assign => write!(f, "="),
             Token::LeftParen => write!(f, "("),
             Token::RightParen => write!(f, ")"),
             Token::Newline => write!(f, "Newline"),
diff --git a/src/runtime/interpreter/expr.rs b/src/runtime/interpreter/expr.rs
@@ -7,17 +7,34 @@
 use crate::frontend::ast::Expr;
 use crate::runtime::value::Value;
 use crate::runtime::builtins;
+use std::collections::HashMap;
 
-pub struct ExprEvaluator;
+pub struct ExprEvaluator {
+    variables: HashMap<String, Value>,
+}
 
 impl ExprEvaluator {
     pub fn new() -> Self {
-        ExprEvaluator
+        ExprEvaluator {
+            variables: HashMap::new(),
+        }
+    }
+    
+    pub fn set_variable(&mut self, name: String, value: Value) {
+        self.variables.insert(name, value);
     }
     
     pub fn evaluate(&mut self, expr: Expr) -> Result<Value, String> {
         match expr {
             Expr::String(s) => Ok(Value::String(s)),
+            Expr::Number(n) => Ok(Value::Number(n)),
+            Expr::Boolean(b) => Ok(Value::Boolean(b)),
+            Expr::Identifier(name) => {
+                self.variables
+                    .get(&name)
+                    .cloned()
+                    .ok_or_else(|| format!("Undefined variable: {}", name))
+            }
             Expr::Call { name, args } => {
                 builtins::call_builtin(&name, args, &mut |e| self.evaluate(e))
             }
diff --git a/src/runtime/interpreter/mod.rs b/src/runtime/interpreter/mod.rs
@@ -50,4 +50,23 @@ mod tests {
         let mut interpreter = Interpreter::new();
         assert!(interpreter.execute(stmts).is_ok());
     }
+    
+    #[test]
+    fn test_variable_declaration() {
+        let mut parser = Parser::new(r#"let x = 42"#);
+        let stmts = parser.parse().unwrap();
+        let mut interpreter = Interpreter::new();
+        assert!(interpreter.execute(stmts).is_ok());
+    }
+    
+    #[test]
+    fn test_variable_usage() {
+        let mut parser = Parser::new(r#"
+            let msg = "Hello"
+            print(msg)
+        "#);
+        let stmts = parser.parse().unwrap();
+        let mut interpreter = Interpreter::new();
+        assert!(interpreter.execute(stmts).is_ok());
+    }
 }
diff --git a/src/runtime/interpreter/stmt.rs b/src/runtime/interpreter/stmt.rs
@@ -12,6 +12,11 @@ pub struct StmtExecutor;
 impl StmtExecutor {
     pub fn execute(stmt: Stmt, evaluator: &mut ExprEvaluator) -> Result<(), String> {
         match stmt {
+            Stmt::Let { name, value } => {
+                let val = evaluator.evaluate(value)?;
+                evaluator.set_variable(name, val);
+                Ok(())
+            }
             Stmt::Expr(expr) => {
                 evaluator.evaluate(expr)?;
                 Ok(())
diff --git a/src/runtime/value.rs b/src/runtime/value.rs
@@ -9,13 +9,17 @@
 #[derive(Debug, Clone, PartialEq)]
 pub enum Value {
     String(String),
+    Number(f64),
+    Boolean(bool),
     Null,
 }
 
 impl std::fmt::Display for Value {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             Value::String(s) => write!(f, "{}", s),
+            Value::Number(n) => write!(f, "{}", n),
+            Value::Boolean(b) => write!(f, "{}", b),
             Value::Null => write!(f, "null"),
         }
     }
diff --git a/wiki.md b/wiki.md
