qalam 0.3.1

Interpreter for the Qalam programming language. Qalam is a dead-simple, Urdu inspired, interpreted programming langauge.
Documentation 
1
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

pub mod args;
pub mod ast;
pub mod callable;
pub mod environment;
pub mod error;
pub mod hashable;
pub mod interpreter;
pub mod literal;
pub mod native;
pub mod parser;
pub mod resolver;
pub mod scanner;
pub mod stack;
pub mod token;
use anyhow::{Context, Result};
use args::Args;
use error::{ErrorReporter, ErrorType};
use interpreter::Interpreter;
use parser::Parser;
use resolver::Resolver;
use scanner::Scanner;
use std::cell::RefCell;
use std::rc::Rc;
use token::Token;
use rustyline::error::ReadlineError;
use rustyline::Editor;
// use std::cell::RefCell;

pub struct Qalam {
    error_reporter: RefCell<ErrorReporter>,
}

impl Qalam {
    pub fn init() -> Self {
        return Self {
            error_reporter: RefCell::new(ErrorReporter::init()),
        };
    }

    fn run_source(&mut self, source: &String, interpreter: Rc<RefCell<Interpreter>>) {
        let mut reporter = self.error_reporter.borrow_mut();
        let mut scanner = Scanner::init(source, &mut reporter);
        let tokens = scanner.scan_tokens();
        let mut parser = Parser::init(tokens);
        match parser.parse() {
            Ok(mut statements) => {
                let mut resolver = Resolver::init(interpreter.clone());
                if let Err(e) = resolver.resolve_stmts(&mut statements) {
                    reporter.runtime_error(&e.token, &e.message, ErrorType::Resolution);
                    return;
                }
                if let Err(e) = interpreter.clone().borrow_mut().interpret(statements) {
                    reporter.runtime_error(&e.token, &e.message, ErrorType::Runtime);
                }
            }
            Err(e) => reporter.error_token(&e.token, &e.message, ErrorType::Syntax),
        }
    }

    fn run_prompt(&mut self) {
        let interpreter = Rc::new(RefCell::new(Interpreter::init()));
        let mut rl= Editor::<(), rustyline::history::FileHistory>::new().expect("Failed to initialize input reader.");

        loop {
            let readline = rl.readline("> ");
            match readline {
                Ok(input) => {
                    let input = input.trim();
                    if input == "exit()" {
                        break;
                    }
                    let _ = rl.add_history_entry(input);
                    self.run_source(&input.to_string(), interpreter.clone());
                    self.error_reporter.borrow_mut().had_error = false;
                },
                Err(ReadlineError::Interrupted) => {
                    println!("Exiting...");
                    break;
                },
                Err(ReadlineError::Eof) => {
                    println!("Exiting...");
                    break;
                },
                Err(err) => {
                    eprintln!("Error reading input: {}", err);
                    break;
                }
            }
        }
    }

    fn run_file(&mut self, path: &String) -> Result<()> {
        let file_content =
            std::fs::read_to_string(path).with_context(|| format!("Cannot read file"))?;
        self.run_source(&file_content, Rc::new(RefCell::new(Interpreter::init())));
        if self.error_reporter.borrow().had_error {
            std::process::exit(65);
        }

        if self.error_reporter.borrow().had_runtime_error {
            std::process::exit(75);
        }
        return Ok(());
    }

    pub fn run(&mut self, args: Args) -> Result<()> {
        if let Some(raw) = args.raw {
            // raw takes priority
            // run the raw string
            self.run_source(&raw, Rc::new(RefCell::new(Interpreter::init())));
            if self.error_reporter.borrow().had_error {
                std::process::exit(1);
            }

            if self.error_reporter.borrow().had_runtime_error {
                std::process::exit(1);
            }
            return Ok(());
            // return;
        }

        if let Some(file_path) = args.file_path {
            // check the file type
            let path = std::path::Path::new(&file_path);
            let is_qlm = path.extension().map(|ext| ext == "qlm").unwrap_or(false);
            if !is_qlm {
                return Err(anyhow::anyhow!("Only .qlm files are allowed!"));
            }
            // run the file
            self.run_file(&file_path)?;
            return Ok(());
        }

        self.run_prompt();

        return Ok(());
    }
}