💥 MAJOR UPDATE: Windows compatibility fixes + executable + installer
This commit is contained in:
723
over_interpreter.py
Normal file
723
over_interpreter.py
Normal file
@@ -0,0 +1,723 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
OverCode Interpreter - Enhanced Polyglot Execution Engine
|
||||
Supports 15+ programming languages with advanced features
|
||||
"""
|
||||
|
||||
import re
|
||||
import subprocess
|
||||
import tempfile
|
||||
import os
|
||||
import sys
|
||||
import json
|
||||
import time
|
||||
from pathlib import Path
|
||||
from colorama import Fore, Style, init
|
||||
|
||||
# Import progress bars
|
||||
try:
|
||||
from utils.progress import ProgressBar, SpinnerProgress
|
||||
except ImportError:
|
||||
# Fallback if utils not available
|
||||
class ProgressBar:
|
||||
def __init__(self, *args, **kwargs): pass
|
||||
def update(self, *args, **kwargs): pass
|
||||
|
||||
class SpinnerProgress:
|
||||
def __init__(self, *args, **kwargs): pass
|
||||
def start(self): pass
|
||||
def stop(self, *args): pass
|
||||
|
||||
init(autoreset=True)
|
||||
|
||||
class OverCodeInterpreter:
|
||||
"""Advanced polyglot code interpreter"""
|
||||
|
||||
def __init__(self):
|
||||
self.supported_languages = {
|
||||
'py': 'Python',
|
||||
'js': 'JavaScript',
|
||||
'ts': 'TypeScript',
|
||||
'php': 'PHP',
|
||||
'rb': 'Ruby',
|
||||
'go': 'Go',
|
||||
'rs': 'Rust',
|
||||
'java': 'Java',
|
||||
'cpp': 'C++',
|
||||
'c': 'C',
|
||||
'cs': 'C#',
|
||||
'lua': 'Lua',
|
||||
'perl': 'Perl',
|
||||
'r': 'R',
|
||||
'swift': 'Swift',
|
||||
'kotlin': 'Kotlin',
|
||||
'dart': 'Dart',
|
||||
'julia': 'Julia',
|
||||
'bash': 'Bash',
|
||||
'ps': 'PowerShell'
|
||||
}
|
||||
|
||||
self.outputs = []
|
||||
self.execution_times = {}
|
||||
self.errors = []
|
||||
|
||||
def interpret(self, source_code, verbose=False):
|
||||
"""Main interpretation method with progress bars"""
|
||||
print(Fore.CYAN + "🚀 OverCode Interpreter v2.0" + Style.RESET_ALL)
|
||||
print(Fore.YELLOW + "─" * 50)
|
||||
|
||||
start_time = time.time()
|
||||
|
||||
# Count total language blocks to process
|
||||
total_blocks = 0
|
||||
for lang_key in self.supported_languages.keys():
|
||||
pattern = f'<\\?{lang_key}(.*?)\\?>'
|
||||
segments = re.findall(pattern, source_code, re.DOTALL)
|
||||
total_blocks += len([s for s in segments if s.strip()])
|
||||
|
||||
if total_blocks > 0:
|
||||
# Create progress bar for execution
|
||||
progress = ProgressBar(total_blocks, style='fire', color='green')
|
||||
current_block = 0
|
||||
|
||||
# Process each language block
|
||||
for lang_key, lang_name in self.supported_languages.items():
|
||||
current_block = self._process_language_with_progress(
|
||||
source_code, lang_key, lang_name, verbose, progress, current_block
|
||||
)
|
||||
else:
|
||||
print(Fore.YELLOW + "No executable code blocks found.")
|
||||
|
||||
# Display results
|
||||
self._display_results()
|
||||
|
||||
total_time = time.time() - start_time
|
||||
print(Fore.GREEN + f"\n✓ Total execution time: {total_time:.3f}s" + Style.RESET_ALL)
|
||||
|
||||
return '\n'.join(self.outputs)
|
||||
|
||||
def _process_language_with_progress(self, source, lang_key, lang_name, verbose, progress, current_block):
|
||||
"""Process language blocks with progress tracking"""
|
||||
pattern = f'<\\?{lang_key}(.*?)\\?>'
|
||||
segments = re.findall(pattern, source, re.DOTALL)
|
||||
|
||||
if not segments:
|
||||
return current_block
|
||||
|
||||
for i, segment in enumerate(segments):
|
||||
code = segment.strip()
|
||||
if not code:
|
||||
continue
|
||||
|
||||
# Update progress
|
||||
progress.update(current_block + 1, f"Executing {lang_name} block {i+1}")
|
||||
|
||||
start = time.time()
|
||||
output = self._execute_code(lang_key, code, verbose)
|
||||
exec_time = time.time() - start
|
||||
|
||||
if output:
|
||||
self.outputs.append(f"[{lang_name} Block {i+1}]\n{output}")
|
||||
self.execution_times[f"{lang_name}_{i+1}"] = exec_time
|
||||
|
||||
current_block += 1
|
||||
time.sleep(0.1) # Small delay to show progress
|
||||
|
||||
return current_block
|
||||
|
||||
def _process_language(self, source, lang_key, lang_name, verbose):
|
||||
"""Process code blocks for a specific language"""
|
||||
pattern = f'<\\?{lang_key}(.*?)\\?>'
|
||||
segments = re.findall(pattern, source, re.DOTALL)
|
||||
|
||||
if not segments:
|
||||
return
|
||||
|
||||
if verbose:
|
||||
print(Fore.BLUE + f"📦 Processing {lang_name} blocks..." + Style.RESET_ALL)
|
||||
|
||||
for i, segment in enumerate(segments):
|
||||
code = segment.strip()
|
||||
if not code:
|
||||
continue
|
||||
|
||||
start = time.time()
|
||||
output = self._execute_code(lang_key, code, verbose)
|
||||
exec_time = time.time() - start
|
||||
|
||||
if output:
|
||||
self.outputs.append(f"[{lang_name} Block {i+1}]\n{output}")
|
||||
self.execution_times[f"{lang_name}_{i+1}"] = exec_time
|
||||
|
||||
def _execute_code(self, lang, code, verbose):
|
||||
"""Execute code for a specific language"""
|
||||
try:
|
||||
if lang == 'py':
|
||||
return self._run_python(code)
|
||||
elif lang == 'js':
|
||||
return self._run_javascript(code)
|
||||
elif lang == 'ts':
|
||||
return self._run_typescript(code)
|
||||
elif lang == 'php':
|
||||
return self._run_php(code)
|
||||
elif lang == 'rb':
|
||||
return self._run_ruby(code)
|
||||
elif lang == 'go':
|
||||
return self._run_go(code)
|
||||
elif lang == 'rs':
|
||||
return self._run_rust(code)
|
||||
elif lang == 'java':
|
||||
return self._run_java(code)
|
||||
elif lang == 'cpp':
|
||||
return self._run_cpp(code)
|
||||
elif lang == 'c':
|
||||
return self._run_c(code)
|
||||
elif lang == 'cs':
|
||||
return self._run_csharp(code)
|
||||
elif lang == 'lua':
|
||||
return self._run_lua(code)
|
||||
elif lang == 'perl':
|
||||
return self._run_perl(code)
|
||||
elif lang == 'r':
|
||||
return self._run_r(code)
|
||||
elif lang == 'swift':
|
||||
return self._run_swift(code)
|
||||
elif lang == 'kotlin':
|
||||
return self._run_kotlin(code)
|
||||
elif lang == 'dart':
|
||||
return self._run_dart(code)
|
||||
elif lang == 'julia':
|
||||
return self._run_julia(code)
|
||||
elif lang == 'bash':
|
||||
return self._run_bash(code)
|
||||
elif lang == 'ps':
|
||||
return self._run_powershell(code)
|
||||
else:
|
||||
return f"Language {lang} not yet implemented"
|
||||
except Exception as e:
|
||||
error_msg = f"Error executing {lang}: {str(e)}"
|
||||
self.errors.append(error_msg)
|
||||
return error_msg if verbose else ""
|
||||
|
||||
def _run_python(self, code):
|
||||
"""Execute Python code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.py') as f:
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['python', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout + (result.stderr if result.stderr else "")
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_javascript(self, code):
|
||||
"""Execute JavaScript code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.js') as f:
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
# Try node first, then fallback to other JS engines
|
||||
for cmd in ['node', 'nodejs', 'deno', 'bun']:
|
||||
if self._command_exists(cmd):
|
||||
result = subprocess.run(
|
||||
[cmd, path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout + (result.stderr if result.stderr else "")
|
||||
return "JavaScript runtime not found (install Node.js)"
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_typescript(self, code):
|
||||
"""Execute TypeScript code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.ts') as f:
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
if self._command_exists('ts-node'):
|
||||
result = subprocess.run(
|
||||
['ts-node', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
elif self._command_exists('deno'):
|
||||
result = subprocess.run(
|
||||
['deno', 'run', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
return "TypeScript runtime not found (install ts-node or deno)"
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_php(self, code):
|
||||
"""Execute PHP code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.php') as f:
|
||||
f.write("<?php\n" + code + "\n?>")
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['php', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_ruby(self, code):
|
||||
"""Execute Ruby code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.rb') as f:
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['ruby', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_go(self, code):
|
||||
"""Execute Go code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.go') as f:
|
||||
# Wrap in main function if not present
|
||||
if 'func main()' not in code:
|
||||
code = f'package main\nimport "fmt"\nfunc main() {{\n{code}\n}}'
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['go', 'run', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_rust(self, code):
|
||||
"""Execute Rust code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.rs') as f:
|
||||
# Wrap in main function if not present
|
||||
if 'fn main()' not in code:
|
||||
code = f'fn main() {{\n{code}\n}}'
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
exe_path = path.replace('.rs', '')
|
||||
compile_result = subprocess.run(
|
||||
['rustc', path, '-o', exe_path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
|
||||
if os.path.exists(exe_path):
|
||||
run_result = subprocess.run(
|
||||
[exe_path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
os.unlink(exe_path)
|
||||
return run_result.stdout
|
||||
return compile_result.stderr
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_java(self, code):
|
||||
"""Execute Java code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.java') as f:
|
||||
# Wrap in class if not present
|
||||
if 'class' not in code:
|
||||
code = f'''
|
||||
public class TempClass {{
|
||||
public static void main(String[] args) {{
|
||||
{code}
|
||||
}}
|
||||
}}'''
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
# Extract class name
|
||||
class_name = re.search(r'class\s+(\w+)', code)
|
||||
if class_name:
|
||||
class_name = class_name.group(1)
|
||||
else:
|
||||
class_name = 'TempClass'
|
||||
|
||||
# Compile
|
||||
subprocess.run(['javac', path], capture_output=True, timeout=10)
|
||||
|
||||
# Run
|
||||
class_file = os.path.join(os.path.dirname(path), f'{class_name}.class')
|
||||
if os.path.exists(class_file):
|
||||
result = subprocess.run(
|
||||
['java', '-cp', os.path.dirname(path), class_name],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
os.unlink(class_file)
|
||||
return result.stdout
|
||||
return "Compilation failed"
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_cpp(self, code):
|
||||
"""Execute C++ code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.cpp') as f:
|
||||
# Add necessary includes if not present
|
||||
if '#include' not in code:
|
||||
code = '#include <iostream>\nusing namespace std;\n' + code
|
||||
if 'int main()' not in code:
|
||||
code = f'{code}\nint main() {{ return 0; }}'
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
exe_path = path.replace('.cpp', '.exe' if os.name == 'nt' else '')
|
||||
compile_result = subprocess.run(
|
||||
['g++', path, '-o', exe_path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
|
||||
if os.path.exists(exe_path):
|
||||
run_result = subprocess.run(
|
||||
[exe_path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
os.unlink(exe_path)
|
||||
return run_result.stdout
|
||||
return compile_result.stderr
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_c(self, code):
|
||||
"""Execute C code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.c') as f:
|
||||
if '#include' not in code:
|
||||
code = '#include <stdio.h>\n' + code
|
||||
if 'int main()' not in code:
|
||||
code = f'{code}\nint main() {{ return 0; }}'
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
exe_path = path.replace('.c', '.exe' if os.name == 'nt' else '')
|
||||
compile_result = subprocess.run(
|
||||
['gcc', path, '-o', exe_path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
|
||||
if os.path.exists(exe_path):
|
||||
run_result = subprocess.run(
|
||||
[exe_path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
os.unlink(exe_path)
|
||||
return run_result.stdout
|
||||
return compile_result.stderr
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_csharp(self, code):
|
||||
"""Execute C# code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.cs') as f:
|
||||
if 'class' not in code:
|
||||
code = f'''
|
||||
using System;
|
||||
class Program {{
|
||||
static void Main() {{
|
||||
{code}
|
||||
}}
|
||||
}}'''
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
exe_path = path.replace('.cs', '.exe')
|
||||
compile_result = subprocess.run(
|
||||
['csc', '/nologo', f'/out:{exe_path}', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
|
||||
if os.path.exists(exe_path):
|
||||
run_result = subprocess.run(
|
||||
[exe_path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
os.unlink(exe_path)
|
||||
return run_result.stdout
|
||||
return "C# compiler not found or compilation failed"
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_lua(self, code):
|
||||
"""Execute Lua code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.lua') as f:
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['lua', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_perl(self, code):
|
||||
"""Execute Perl code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.pl') as f:
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['perl', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_r(self, code):
|
||||
"""Execute R code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.r') as f:
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['Rscript', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_swift(self, code):
|
||||
"""Execute Swift code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.swift') as f:
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['swift', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_kotlin(self, code):
|
||||
"""Execute Kotlin code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.kt') as f:
|
||||
if 'fun main()' not in code:
|
||||
code = f'fun main() {{\n{code}\n}}'
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
jar_path = path.replace('.kt', '.jar')
|
||||
subprocess.run(
|
||||
['kotlinc', path, '-d', jar_path],
|
||||
capture_output=True,
|
||||
timeout=10
|
||||
)
|
||||
|
||||
if os.path.exists(jar_path):
|
||||
result = subprocess.run(
|
||||
['java', '-jar', jar_path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
os.unlink(jar_path)
|
||||
return result.stdout
|
||||
return "Kotlin compiler not found"
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_dart(self, code):
|
||||
"""Execute Dart code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.dart') as f:
|
||||
if 'void main()' not in code:
|
||||
code = f'void main() {{\n{code}\n}}'
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['dart', 'run', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_julia(self, code):
|
||||
"""Execute Julia code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.jl') as f:
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['julia', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_bash(self, code):
|
||||
"""Execute Bash code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.sh') as f:
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
if os.name == 'nt':
|
||||
# On Windows, try WSL or Git Bash
|
||||
for shell in ['bash', 'sh']:
|
||||
if self._command_exists(shell):
|
||||
result = subprocess.run(
|
||||
[shell, path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
return "Bash not available on Windows (install WSL or Git Bash)"
|
||||
else:
|
||||
result = subprocess.run(
|
||||
['bash', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _run_powershell(self, code):
|
||||
"""Execute PowerShell code"""
|
||||
with tempfile.NamedTemporaryFile('w', delete=False, suffix='.ps1') as f:
|
||||
f.write(code)
|
||||
path = f.name
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
['powershell', '-ExecutionPolicy', 'Bypass', '-File', path],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout
|
||||
finally:
|
||||
os.unlink(path)
|
||||
|
||||
def _command_exists(self, command):
|
||||
"""Check if a command exists"""
|
||||
try:
|
||||
subprocess.run(
|
||||
['which' if os.name != 'nt' else 'where', command],
|
||||
capture_output=True,
|
||||
check=False
|
||||
)
|
||||
return True
|
||||
except:
|
||||
return False
|
||||
|
||||
def _display_results(self):
|
||||
"""Display execution results"""
|
||||
if self.outputs:
|
||||
print(Fore.GREEN + "\n📋 Output:" + Style.RESET_ALL)
|
||||
print("─" * 50)
|
||||
for output in self.outputs:
|
||||
print(output)
|
||||
|
||||
if self.errors:
|
||||
print(Fore.RED + "\n❌ Errors:" + Style.RESET_ALL)
|
||||
for error in self.errors:
|
||||
print(f" • {error}")
|
||||
|
||||
if self.execution_times:
|
||||
print(Fore.CYAN + "\n⏱️ Execution Times:" + Style.RESET_ALL)
|
||||
for lang, exec_time in self.execution_times.items():
|
||||
print(f" • {lang}: {exec_time:.3f}s")
|
||||
|
||||
def interpret_file(filepath, verbose=False):
|
||||
"""Interpret an OverCode file"""
|
||||
interpreter = OverCodeInterpreter()
|
||||
|
||||
try:
|
||||
with open(filepath, 'r', encoding='utf-8') as f:
|
||||
source_code = f.read()
|
||||
|
||||
return interpreter.interpret(source_code, verbose)
|
||||
except FileNotFoundError:
|
||||
print(Fore.RED + f"Error: File '{filepath}' not found" + Style.RESET_ALL)
|
||||
return None
|
||||
except Exception as e:
|
||||
print(Fore.RED + f"Error: {str(e)}" + Style.RESET_ALL)
|
||||
return None
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) > 1:
|
||||
interpret_file(sys.argv[1], verbose=True)
|
||||
else:
|
||||
print("Usage: python over_interpreter.py <file.ovc>")
|
||||
Reference in New Issue
Block a user