Multiline code working with arithematic and data variable assignments

Author: aditya-raj-arora

mas/lexer.c

@@ -23,7 +23,7 @@ static int next_char() {
 
 // Helper function to peek at next character
 static int peek_char() {
-    if (current && *current) {
+    if (current && *current != '\0') {
         return *current;
     }
     return EOF;
@@ -35,9 +35,16 @@ static void skip_whitespace() {
     while ((c = peek_char()) != EOF) {
         if (c == ' ' || c == '\t') {
             next_char();
+        } else if (c == '\r') {
+            // Skip \r (in case of \r\n or lone \r)
+            next_char();
+            // If followed by \n, we'll let lexer_next() handle the \n
         } else if (c == '#') {
-            // Comment
-            while ((c = next_char()) != EOF && c != '\n');
+            next_char(); // consume '#'
+            while ((c = peek_char()) != EOF && c != '\n' && c != '\r') {
+                next_char();
+            }
+            // Do NOT consume \n or \r — leave for lexer_next()
         } else {
             break;
         }
@@ -172,11 +179,6 @@ Token* lexer_next() {
     skip_whitespace();
 
     int c = peek_char();
-    if (c == EOF) {
-        eof_reached = true;
-        return make_token(TOK_EOF, NULL, line);
-    }
-    
     // Single character tokens
     if (c == '+') { next_char(); return make_token(TOK_PLUS, NULL, line); }
     if (c == '-') { next_char(); return make_token(TOK_MINUS, NULL, line); }
@@ -225,7 +227,8 @@ Token* lexer_next() {
     }
     if (c == '\n') {
         next_char();
-        return make_token(TOK_NEWLINE, NULL, line);
+        // The newline token belongs to the line we just finished.
+        return make_token(TOK_NEWLINE, NULL, line - 1);
     }
 
     // Multi-character tokens
@@ -239,9 +242,18 @@ Token* lexer_next() {
         return read_string();
     }
 
+    if (c == EOF) {
+        eof_reached = true;
+        return make_token(TOK_EOF, NULL, line);
+    }
+
     // Unknown character
     char msg[100];
-    sprintf(msg, "Unknown character: %c", c);
+    if (isprint(c)) {
+        sprintf(msg, "Unknown character: '%c'", c);
+    } else {
+        sprintf(msg, "Unknown character: '\\x%02X'", (unsigned char)c);
+    }
     next_char(); // consume it
     return make_token(TOK_ERROR, strdup(msg), line);
 }

mas/main.c

@@ -1,25 +1,68 @@
 // main.c
 #include "mas.h"
+#include <stdio.h>
 
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         fprintf(stderr, "Usage: %s <input.mas>\n", argv[0]);
         return 1;
     }
 
-    FILE* f = fopen(argv[1], "r");
+    FILE* f = fopen(argv[1], "rb");
     if (!f) {
         perror("Failed to open file");
         return 1;
     }
 
     lexer_init(f);
 
+
+    
+    // Token* tok;
+    // do {
+    //     tok = lexer_next();
+    //     switch (tok->type) {
+    //         case TOK_EOF:
+    //             printf("EOF\n");
+    //             break;
+    //         case TOK_ERROR:
+    //             printf("ERROR (line %d): %s\n", tok->line, tok->value);
+    //             break;
+    //         case TOK_NUMBER:
+    //             printf("NUMBER (line %d): %s\n", tok->line, tok->value);
+    //             break;
+    //         case TOK_STRING:
+    //             printf("STRING (line %d): \"%s\"\n", tok->line, tok->value);
+    //             break;
+    //         case TOK_ID:
+    //             printf("IDENTIFIER (line %d): %s\n", tok->line, tok->value);
+    //             break;
+    //         case TOK_NEWLINE:
+    //             printf("NEWLINE (line %d)\n", tok->line);
+    //             break;
+    //         case TOK_PLUS:     printf("PLUS (line %d)\n", tok->line); break;
+    //         case TOK_ASSIGN:   printf("ASSIGN '=' (line %d)\n", tok->line); break;
+    //         case TOK_EQ:       printf("EQ '==' (line %d)\n", tok->line); break;
+    //         // ... add more as needed, or use a helper function ...
+    //         default:
+    //             // For brevity, just print type and value
+    //             printf("TOKEN %d (line %d): %s\n", tok->type, tok->line, tok->value ? tok->value : "");
+    //             break;
+    //     }
+
+    //     TokenType type = tok->type;
+
+    //     // Clean up
+    //     if (tok->value) free(tok->value);
+    //     free(tok);
+
+    //     if (type == TOK_EOF) break;
+    // }while(1);
+      
     ASTNode* ast = parse_program();
     fclose(f);
 
-    // print_ast(ast, 0); // Print the AST
-    MASObject* result = interpret(ast);    
+    MASObject* result = interpret(ast);
     mas_object_decref(result);
 
     return 0;

mas/mas.exe

@@ -54,6 +54,11 @@ ASTNode* parse_program() {
             continue;
         }
         statements[stmt_count++] = parse_statement();
+
+        // After a statement, we must have a newline or EOF.
+        if (current_token->type != TOK_NEWLINE && current_token->type != TOK_EOF) {
+            consume(TOK_NEWLINE, "Expected newline after statement");
+        }
     }
 
     program->data.list.items = statements;
@@ -238,52 +243,15 @@ ASTNode* parse_statement() {
         stmt->line = call->line;
         stmt->data.expr = call;
         return stmt;
+    } else {
+        // If it's not a keyword-led statement, it must be an expression statement.
+        ASTNode* expr = parse_expression();
+        ASTNode* stmt = malloc(sizeof(ASTNode));
+        stmt->type = AST_EXPRSTMT;
+        stmt->line = expr->line;
+        stmt->data.expr = expr;
+        return stmt;
     }
-    else if (match(TOK_ID)) {
-        char* id = strdup(current_token->value);
-        advance();
-        if (match(TOK_ASSIGN)) { // Assignment
-            // Assignment
-            ASTNode* value = parse_expression();
-            ASTNode* assign = malloc(sizeof(ASTNode));
-            assign->type = AST_ASSIGN;
-            assign->line = current_token->line;
-            assign->data.assign.name = id;
-            assign->data.assign.value = value;
-            return assign;
-        }
-        else if (match(TOK_LPAREN)) { // Function call
-            // Function call
-            ASTNode** args = malloc(sizeof(ASTNode*) * 10);
-            int arg_count = 0;
-            
-            if (!match(TOK_RPAREN)) {
-                do {
-                    args[arg_count++] = parse_expression();
-                    if (match(TOK_COMMA)) {
-                        advance(); // consume comma
-                    } else break;
-                } while (true);
-                consume(TOK_RPAREN, "Expected ')'");
-            }
-            
-            ASTNode* call = malloc(sizeof(ASTNode));
-            call->type = AST_CALL;
-            call->line = current_token->line;
-            call->data.call.name = id;
-            call->data.call.args = args;
-            call->data.call.arg_count = arg_count;
-            return call;
-        }
-    }
-    
-    // Default: parse as expression statement
-    ASTNode* expr = parse_expression();
-    ASTNode* stmt = malloc(sizeof(ASTNode));
-    stmt->type = AST_EXPRSTMT;
-    stmt->line = current_token->line;
-    stmt->data.expr = expr;
-    return stmt;
 }
 
 // Parse expression (simplified - left associative)
@@ -292,7 +260,23 @@ ASTNode* parse_expression() {
 }
 
 ASTNode* parse_comparison() {
-    ASTNode* expr = parse_term();
+    ASTNode* expr = parse_term(); // Parse the left-hand side
+
+    // Check for assignment, which has the lowest precedence
+    if (match(TOK_ASSIGN)) {
+        advance(); // consume '='
+        if (expr->type != AST_VAR) {
+            fprintf(stderr, "Parse error at line %d: Invalid assignment target.\n", expr->line);
+            exit(1);
+        }
+        ASTNode* value = parse_expression();
+        ASTNode* assign = malloc(sizeof(ASTNode));
+        assign->type = AST_ASSIGN;
+        assign->line = expr->line;
+        assign->data.assign.name = expr->data.var_name;
+        assign->data.assign.value = value;
+        return assign;
+    }
 
     while (current_token) {
         if (match(TOK_EQ)) {
@@ -498,13 +482,36 @@ ASTNode* parse_primary() {
         return null_node;
     }
     else if (match(TOK_ID)) {
-        char* value = strdup(current_token->value);
+        char* id_name = strdup(current_token->value);
         int line = current_token->line;
         advance();
+
+        // Check if it's a function call
+        if (match(TOK_LPAREN)) {
+            advance(); // consume '('
+            ASTNode** args = malloc(sizeof(ASTNode*) * 10);
+            int arg_count = 0;
+            if (!match(TOK_RPAREN)) {
+                do {
+                    args[arg_count++] = parse_expression();
+                } while (match(TOK_COMMA) && (advance(), true));
+            }
+            consume(TOK_RPAREN, "Expected ')'");
+
+            ASTNode* call = malloc(sizeof(ASTNode));
+            call->type = AST_CALL;
+            call->line = line;
+            call->data.call.name = id_name;
+            call->data.call.args = args;
+            call->data.call.arg_count = arg_count;
+            return call;
+        }
+
+        // Otherwise, it's a variable
         ASTNode* var = malloc(sizeof(ASTNode));
         var->type = AST_VAR;
         var->line = line;
-        var->data.var_name = value;
+        var->data.var_name = id_name;
         return var;
     }
     else if (match(TOK_LBRACKET)) {

mas/parser.c

@@ -1 +1,3 @@
-print "Idiots in the house"
+x = 4 - 5
+print "Sum is equal to ", x
+print "Sagnik is idiot"