RL-Optimized Source to Source Compiler

RL-Optimized Source to Source Compiler Overview

RL-Optimized Source to Source Compiler is an end-to-end imperative source-to-source compilation framework paired with a tabular Reinforcement Learning Q-learning agent. The compiler translates a custom C-like procedural source language into rigorously optimized Python 3 source code.

Unlike conventional optimizing compilers that depend on fragile, hardcoded heuristics or fixed phase orderings, this system uses an autonomous RL agent that inspects intermediate Three-Address Code (TAC) and applies optimal sequences of program transformations to minimize instruction count and execution latency while preserving semantic equivalence.

• Syntax Convention: C-like procedural syntax; statements terminate with semicolons (;); blocks are delimited by curly braces ({ }).
• Dynamic Typing: Numerical literals are treated as double-precision floating point; strings are first-class immutable sequences.
• Guaranteed Termination: Sandboxed execution engine with daemon thread isolation and a 5.0 s watchdog timer preventing CPU hangs or infinite loops.

Language Specifications & Inventory

A rigorous inventory of all primitive data types, keywords, operators, delimiters, and lexical token categories supported by the compiler:

1. Data Types (2 Supported Types)

Boolean Representation: Logical and relational operations evaluate to numerical 1 (True) and 0 (False). Branching constructs evaluate truthiness using non-zero value semantics.

2. Reserved Keywords (5 Keywords)

3. Lexical Token Categories (8 Categories / 32 Token Types)

Formal Grammar Specification (EBNF)

The language syntax is formally specified below in Extended Backus-Naur Form (EBNF). The recursive descent parser processes tokens deterministically with LL(1) lookahead:

The 7-Stage Compilation Pipeline

Every source program flows sequentially through 7 decoupled compilation stages, each exposing verifiable intermediate states:

Variables & Scoping

Variables are implicitly declared upon their first assignment. The semantic analysis stage builds a scoped symbol table that verifies variables are defined before they are referenced.

Basic assignment

x = 10;
name = "Alice";
print(x);
print(name);

10
Alice

Compound in-place assignment

The language supports shorthand arithmetic accumulation operators (+=, -=, *=, /=):

x = 5;
x += 3;
x -= 1;
print(x);

7

Expressions & Mathematics

Arithmetic expressions follow standard mathematical operator precedence (*, /, and % bind tighter than + and -):

a = 10;
b = 3;
print(a + b);
print(a - b);
print(a * b);
print(a / b);
print(a % b);

13
7
30
3.3333333333333335
1

Division & Modulo Zero-Check Protection: To eliminate fatal runtime exceptions in critical execution loops, target code wraps divisions and modulos in zero-guard ternaries: (a / b if b != 0 else 0) and (a % b if b != 0 else 0).

Control Flow

Conditional Branching: if / else

Conditional branches evaluate boolean expressions and generate conditional jumps (IF_FALSE) in the TAC intermediate layer:

age = 20;
if (age >= 18) {
    print("Adult");
} else {
    print("Minor");
}

Adult

Iteration: while loops

Loops compile into back-edge jumps with guard conditions evaluated at each cycle iteration:

i = 1;
while (i <= 5) {
    print(i);
    i += 1;
}

1
2
3
4
5

Input & Output

Interactive programs can prompt and consume inputs from the user via the scan() builtin:

print("Enter a number:");
scan(n);
print(n * 2);

Enter a number:
14.0

scan(var) consumes the next line from standard input and parses it as a float. Input values can be prepared in the Stdin text area on the workspace, separated by newlines.

Operator Reference

Reinforcement Learning Optimization Engine

The optimizer models program optimization as a Markov Decision Process (MDP) over the Three-Address Code intermediate representation. At each instruction index, the tabular Q-learning agent evaluates local opcode contexts and selects transformation actions:

• State Representation: Fingerprint of surrounding instruction opcodes within a window of position ±1, combined with variable live-range status.
• Action Space:
  • constant_folding: Replaces expressions of known constants with precomputed scalar values.
  • dead_code_elimination: Prunes assignments to variables that are overwritten before being read.
  • common_subexpression: Deduplicates identical computations and reuses previously computed temporaries.
  • algebraic_simplification: Simplifies identity operations such as x + 0, x * 1, and x * 0.
  • loop_invariant_motion: Hoists computations independent of loop variables outside the loop header.
• Reward Formulation: Reward = (+10 × removed_instructions) + (+5 × folded_constants) − (20 × code_growth)
• Exploration vs Exploitation: The agent follows an ε-greedy policy with an exponential decay schedule (×0.99 per optimization pass) to balance discovering new rewrite patterns and exploiting proven reduction paths.

Security & Sandboxing Guarantees

• Thread & Process Isolation: Target Python execution runs inside an isolated daemon thread with a strict 5000 ms watchdog. Infinite loops and recursive lockups are terminated automatically.
• Namespace Scrubbing: Dangerous builtins including os, subprocess, open, eval, exec, sys, and all module import mechanisms (__import__) are stripped from the sandbox execution environment.
• Safe Division: Every division operation compiles with a non-zero guard to guarantee immunity against unhandled ZeroDivisionError crash conditions.
• Recursion Guard: The compiler raises the system recursion limit to 10 000 during AST analysis and restores baseline defaults immediately after completion.

Keyboard Shortcuts & Pro Tips