constructor() {

this.reset();

}

reset() {

this.states = [];

this.output = [];

this.errors = [];

this.callStack = [];

this.globalVars = {};

this.methods = {};

this.currentLine = 0;

this.iterationCounters = {};

this.maxIterations = 10000;

this.totalSteps = 0;

this.executedLines = new Set();

this.inputQueue = [];

this.inputIndex = 0;

}

tokenize(code) {

const tokens = [];

let i = 0;

const lines = code.split('\n');

for (let lineNum = 0; lineNum < lines.length; lineNum++) {

let line = lines[lineNum];

let col = 0;

while (col < line.length) {

// Skip whitespace

if (/\s/.test(line[col])) { col++; continue; }

// Single-line comment

if (line[col] === '/' && line[col + 1] === '/') {

break; // skip rest of line

}

// Multi-line comment start (simplified - single line only for now)

if (line[col] === '/' && line[col + 1] === '*') {

const end = line.indexOf('*/', col + 2);

if (end !== -1) { col = end + 2; continue; }

break;

}

// String literal

if (line[col] === '"') {

let str = '"';

col++;

while (col < line.length && line[col] !== '"') {

if (line[col] === '\\') { str += line[col++]; }

str += line[col++];

}

str += '"';

col++;

tokens.push({ type: 'STRING', value: str, line: lineNum + 1 });

continue;

}

// Char literal

if (line[col] === "'") {

let ch = "'";

col++;

while (col < line.length && line[col] !== "'") {

if (line[col] === '\\') { ch += line[col++]; }

ch += line[col++];

}

ch += "'";

col++;

tokens.push({ type: 'CHAR', value: ch, line: lineNum + 1 });

continue;

}

// Numbers

if (/[0-9]/.test(line[col]) || (line[col] === '.' && /[0-9]/.test(line[col + 1]))) {

let num = '';

let hasDecimal = false;

while (col < line.length && (/[0-9]/.test(line[col]) || line[col] === '.')) {

if (line[col] === '.') {

if (hasDecimal) break;

hasDecimal = true;

}

num += line[col++];

}

tokens.push({ type: 'NUMBER', value: num, line: lineNum + 1 });

continue;

}

// Identifiers and keywords

if (/[a-zA-Z_$]/.test(line[col])) {

let id = '';

while (col < line.length && /[a-zA-Z0-9_$]/.test(line[col])) {

id += line[col++];

}

const keywords = ['public', 'private', 'protected', 'static', 'void', 'class', 'int', 'double', 'boolean', 'char', 'String', 'float', 'long', 'short', 'byte', 'if', 'else', 'for', 'while', 'do', 'return', 'new', 'true', 'false', 'null', 'this', 'System', 'out', 'println', 'print', 'length', 'charAt', 'Math', 'abs', 'max', 'min', 'sqrt', 'pow', 'random'];

if (keywords.includes(id)) {

tokens.push({ type: 'KEYWORD', value: id, line: lineNum + 1 });

} else {

tokens.push({ type: 'IDENTIFIER', value: id, line: lineNum + 1 });

}

continue;

}

// Multi-char operators

const multiOps = ['==', '!=', '<=', '>=', '&&', '||', '++', '--', '+=', '-=', '*=', '/=', '%='];

let matched = false;

for (const op of multiOps) {

if (line.substring(col, col + op.length) === op) {

tokens.push({ type: 'OPERATOR', value: op, line: lineNum + 1 });

col += op.length;

matched = true;

break;

}

}

if (matched) continue;

// Single char operators and punctuation

const singles = '+-*/%=<>!&|^~?:;,.(){}[]';

if (singles.includes(line[col])) {

tokens.push({ type: 'OPERATOR', value: line[col], line: lineNum + 1 });

col++;

continue;

}

col++;

}

tokens.push({ type: 'NEWLINE', value: '\n', line: lineNum + 1 });

}

return tokens.filter(t => t.type !== 'NEWLINE');

}

parse(code) {

this.reset();

const tokens = this.tokenize(code);

const statements = this.parseStatements(tokens, code);

return statements;

}

parseStatements(tokens, code) {

const stmts = [];

let i = 0;

const lines = code.split('\n');

// Extract methods and main logic

const methodBodies = this.extractMethods(lines);

for (const method of methodBodies) {

if (method.name === 'main') {

const mainStmts = this.parseMethodBody(method.bodyLines, method.startLine);

stmts.push(...mainStmts);

} else {

this.methods[method.name] = {

params: method.params,

returnType: method.returnType,

bodyLines: method.bodyLines,

startLine: method.startLine

};

}

}

return stmts;

}

extractMethods(lines) {

const methods = [];

let i = 0;

while (i < lines.length) {

const line = lines[i].trim();

// Match method declarations

const methodMatch = line.match(/(?:public\s+|private\s+|protected\s+)?(?:static\s+)?(\w+(?:\[\])?)\s+(\w+)\s*\(([^)]*)\)\s*\{?\s*$/);

if (methodMatch && !line.startsWith('//') && !line.includes('class ') && !line.includes('new ')) {

const returnType = methodMatch[1];

const name = methodMatch[2];

const paramsStr = methodMatch[3].trim();

const params = paramsStr ? paramsStr.split(',').map(p => {

const parts = p.trim().split(/\s+/);

return { type: parts.slice(0, -1).join(' '), name: parts[parts.length - 1] };

}) : [];

// Find matching closing brace

let braceCount = line.includes('{') ? 1 : 0;

let bodyStart = i + 1;

if (!line.includes('{')) {

while (bodyStart < lines.length && !lines[bodyStart].includes('{')) bodyStart++;

braceCount = 1;

bodyStart++;

}

let bodyEnd = bodyStart;

while (bodyEnd < lines.length && braceCount > 0) {

for (const ch of lines[bodyEnd]) {

if (ch === '{') braceCount++;

if (ch === '}') braceCount--;

}

if (braceCount > 0) bodyEnd++;

}

methods.push({

name,

returnType,

params,

bodyLines: lines.slice(bodyStart, bodyEnd),

startLine: bodyStart + 1

});

i = bodyEnd + 1;

continue;

}

i++;

}

return methods;

}

parseMethodBody(bodyLines, startLine) {

const stmts = [];

let i = 0;

while (i < bodyLines.length) {

const rawLine = bodyLines[i].trim();

// Strip inline // comments (but not inside string literals)

const line = this.stripInlineComment(rawLine);

const lineNum = startLine + i;

if (!line || line.startsWith('//') || line.startsWith('/*') || line === '{' || line === '}') {

i++;

continue;

}

// For loop

const forMatch = line.match(/^for\s*\((.+)\)\s*\{?\s*$/);

if (forMatch) {

const parts = forMatch[1].split(';').map(s => s.trim());

let bodyStmts = [];

let braceCount = line.includes('{') ? 1 : 0;

let j = i + 1;

if (!line.includes('{')) {

// Single statement for body

if (j < bodyLines.length) {

bodyStmts = this.parseMethodBody([bodyLines[j]], startLine + j);

}

j++;

} else {

const bodyStart = j;

while (j < bodyLines.length && braceCount > 0) {

for (const ch of bodyLines[j]) {

if (ch === '{') braceCount++;

if (ch === '}') braceCount--;

}

if (braceCount > 0) j++;

}

bodyStmts = this.parseMethodBody(bodyLines.slice(bodyStart, j), startLine + bodyStart);

j++;

}

stmts.push({

type: 'for',

init: parts[0],

condition: parts[1],

update: parts[2],

body: bodyStmts,

line: lineNum

});

i = j;

continue;

}

// While loop

const whileMatch = line.match(/^while\s*\((.+)\)\s*\{?\s*$/);

if (whileMatch) {

let bodyStmts = [];

let braceCount = line.includes('{') ? 1 : 0;

let j = i + 1;

if (!line.includes('{')) {

if (j < bodyLines.length) {

bodyStmts = this.parseMethodBody([bodyLines[j]], startLine + j);

}

j++;

} else {

const bodyStart = j;

while (j < bodyLines.length && braceCount > 0) {

for (const ch of bodyLines[j]) {

if (ch === '{') braceCount++;

if (ch === '}') braceCount--;

}

if (braceCount > 0) j++;

}

bodyStmts = this.parseMethodBody(bodyLines.slice(bodyStart, j), startLine + bodyStart);

j++;

}

stmts.push({

type: 'while',

condition: whileMatch[1],

body: bodyStmts,

line: lineNum

});

i = j;

continue;

}

// Do-while loop

const doMatch = line.match(/^do\s*\{?\s*$/);

if (doMatch) {

let bodyStmts = [];

let braceCount = line.includes('{') ? 1 : 0;

let j = i + 1;

const bodyStart = j;

while (j < bodyLines.length && braceCount > 0) {

for (const ch of bodyLines[j]) {

if (ch === '{') braceCount++;

if (ch === '}') braceCount--;

}

if (braceCount > 0) j++;

}

// j is now on the "} while(...)" line

const whileCondMatch = bodyLines[j]?.trim().match(/\}\s*while\s*\((.+)\)\s*;/);

const cond = whileCondMatch ? whileCondMatch[1] : 'true';

bodyStmts = this.parseMethodBody(bodyLines.slice(bodyStart, j), startLine + bodyStart);

stmts.push({

type: 'dowhile',

condition: cond,

body: bodyStmts,

line: lineNum,

condLine: startLine + j

});

i = j + 1;

continue;

}

// If / else if / else

const ifMatch = line.match(/^if\s*\((.+)\)\s*\{?\s*$/);

if (ifMatch) {

const branches = [];

let condition = ifMatch[1];

let braceCount = line.includes('{') ? 1 : 0;

let j = i + 1;

// Parse if body - stop at the line where closing } is found

const bodyStart = j;

while (j < bodyLines.length && braceCount > 0) {

const bLine = bodyLines[j];

// Check each char but stop if we hit } that closes the if-body

for (let ci = 0; ci < bLine.length; ci++) {

if (bLine[ci] === '{') braceCount++;

if (bLine[ci] === '}') {

braceCount--;

if (braceCount === 0) break;

}

}

if (braceCount > 0) j++;

}

branches.push({

condition,

body: this.parseMethodBody(bodyLines.slice(bodyStart, j), startLine + bodyStart),

line: lineNum

});

// Check for else if / else - could be on the same line as closing }

const closingLine = bodyLines[j]?.trim() || '';

const elseOnSameLine = closingLine.match(/^}\s*else\s+if\s*\((.+)\)\s*\{?\s*$/) ||

closingLine.match(/^}\s*else\s*\{?\s*$/);

if (elseOnSameLine) {

// Process else/else-if from the same line

const processElseChain = (startJ) => {

let ej = startJ;

while (ej < bodyLines.length) {

const eLine = bodyLines[ej]?.trim() || '';

const eifMatch = eLine.match(/^}\s*else\s+if\s*\((.+)\)\s*\{?\s*$/) ||

eLine.match(/^else\s+if\s*\((.+)\)\s*\{?\s*$/);

const eMatch = eLine.match(/^}\s*else\s*\{?\s*$/) ||

eLine.match(/^else\s*\{?\s*$/);

if (eifMatch) {

const cond = eifMatch[1];

braceCount = eLine.includes('{') ? 1 : 0;

ej++;

const eBodyStart = ej;

while (ej < bodyLines.length && braceCount > 0) {

const bl = bodyLines[ej];

for (let ci = 0; ci < bl.length; ci++) {

if (bl[ci] === '{') braceCount++;

if (bl[ci] === '}') { braceCount--; if (braceCount === 0) break; }

}

if (braceCount > 0) ej++;

}

branches.push({

condition: cond,

body: this.parseMethodBody(bodyLines.slice(eBodyStart, ej), startLine + eBodyStart),

line: startLine + eBodyStart - 1

});

// Check if this closing line also has else

const nextClosing = bodyLines[ej]?.trim() || '';

if (!nextClosing.match(/else/)) { ej++; break; }

} else if (eMatch) {

braceCount = eLine.includes('{') ? 1 : 0;

ej++;

const eBodyStart = ej;

while (ej < bodyLines.length && braceCount > 0) {

const bl = bodyLines[ej];

for (let ci = 0; ci < bl.length; ci++) {

if (bl[ci] === '{') braceCount++;

if (bl[ci] === '}') { braceCount--; if (braceCount === 0) break; }

}

if (braceCount > 0) ej++;

}

branches.push({

condition: null,

body: this.parseMethodBody(bodyLines.slice(eBodyStart, ej), startLine + eBodyStart),

line: startLine + eBodyStart - 1

});

ej++;

break;

} else {

break;

}

}

return ej;

};

j = processElseChain(j);

} else {

j++;

// Check next line for standalone else

while (j < bodyLines.length) {

const nextLine = bodyLines[j]?.trim() || '';

const elseIfMatch2 = nextLine.match(/^else\s+if\s*\((.+)\)\s*\{?\s*$/);

const elseMatch2 = nextLine.match(/^else\s*\{?\s*$/);

if (elseIfMatch2) {

const cond = elseIfMatch2[1];

braceCount = nextLine.includes('{') ? 1 : 0;

j++;

const eBodyStart = j;

while (j < bodyLines.length && braceCount > 0) {

const bl = bodyLines[j];

for (let ci = 0; ci < bl.length; ci++) {

if (bl[ci] === '{') braceCount++;

if (bl[ci] === '}') { braceCount--; if (braceCount === 0) break; }

}

if (braceCount > 0) j++;

}

branches.push({

condition: cond,

body: this.parseMethodBody(bodyLines.slice(eBodyStart, j), startLine + eBodyStart),

line: startLine + eBodyStart - 1

});

j++;

} else if (elseMatch2) {

braceCount = nextLine.includes('{') ? 1 : 0;

j++;

const eBodyStart = j;

while (j < bodyLines.length && braceCount > 0) {

const bl = bodyLines[j];

for (let ci = 0; ci < bl.length; ci++) {

if (bl[ci] === '{') braceCount++;

if (bl[ci] === '}') { braceCount--; if (braceCount === 0) break; }

}

if (braceCount > 0) j++;

}

branches.push({

condition: null,

body: this.parseMethodBody(bodyLines.slice(eBodyStart, j), startLine + eBodyStart),

line: startLine + eBodyStart - 1

});

j++;

break;

} else {

break;

}

}

}

stmts.push({ type: 'if', branches, line: lineNum });

i = j;

continue;

}

// Handle "} else if" or "} else" at start (already consumed by if parser above)

if (line.startsWith('} else') || line === '}') {

i++;

continue;

}

// Return statement

const returnMatch = line.match(/^return\s*(.*?)\s*;$/);

if (returnMatch) {

stmts.push({ type: 'return', expr: returnMatch[1], line: lineNum });

i++;

continue;

}

// Regular statement (declaration, assignment, method call, etc.)

const cleanLine = line.endsWith(';') ? line.slice(0, -1).trim() : line.replace(/[{}]/g, '').trim();

if (cleanLine) {

stmts.push({ type: 'statement', code: cleanLine, line: lineNum });

}

i++;

}

return stmts;

}

evaluateExpression(expr, vars) {

if (expr === undefined || expr === null) return undefined;

expr = expr.trim();

if (expr === '') return undefined;

if (expr === 'true') return true;

if (expr === 'false') return false;

if (expr === 'null') return null;

// String literal — must be a single quoted string, not "str" + expr + "str"

if (expr.startsWith('"') && expr.endsWith('"')) {

// Find the actual end of the first string literal

let endIdx = -1;

for (let si = 1; si < expr.length; si++) {

if (expr[si] === '\\') { si++; continue; }

if (expr[si] === '"') { endIdx = si; break; }

}

if (endIdx === expr.length - 1) {

// The entire expression is one string literal

return expr.slice(1, -1).replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\"/g, '"');

}

// Otherwise it's something like "str" + expr + "str" — fall through to concat handler

}

// Char literal

if (expr.startsWith("'") && expr.endsWith("'")) {

return expr.slice(1, -1);

}

// Number (including L/l for long, f/F for float, d/D for double suffixes, underscore separators)

if (/^-?\d[\d_]*(\.\d[\d_]*)?[lLfFdD]?$/.test(expr)) {

const cleanNum = expr.replace(/[lLfFdD]$/, '').replace(/_/g, '');

return cleanNum.includes('.') ? parseFloat(cleanNum) : parseInt(cleanNum);

}

// Parenthesized expression

if (expr.startsWith('(') && this.findMatchingParen(expr, 0) === expr.length - 1) {

// Check for cast

const inner = expr.slice(1, -1).trim();

const castMatch = inner.match(/^(int|double|float|long|short|byte|char)\)\s*(.+)$/);

if (castMatch) {

// Actually it's (type) value

}

return this.evaluateExpression(inner, vars);

}

// Type cast: (double) expr, (int) expr

// Only capture the next token (variable or number), not the whole remaining expression

const castMatch = expr.match(/^\((\w+)\)\s*(.+)$/);

if (castMatch) {

const castType = castMatch[1];

const restExpr = castMatch[2];

// Check if there's an operator after the cast target — e.g. "(double) sum / 5"

// In that case, cast only applies to the first operand

const opMatch = restExpr.match(/^(\w+(?:\[.+?\])?)\s*([+\-*/%])\s*(.+)$/);

if (opMatch) {

let castVal = this.evaluateExpression(opMatch[1], vars);

if (castType === 'int') castVal = Math.floor(Number(castVal));

else if (castType === 'double' || castType === 'float') castVal = Number(castVal);

else if (castType === 'char') castVal = String.fromCharCode(Number(castVal));

const right = this.evaluateExpression(opMatch[3], vars);

const op = opMatch[2];

if (op === '+') return castVal + Number(right);

if (op === '-') return castVal - Number(right);

if (op === '*') return castVal * Number(right);

if (op === '/') {

if (Number(right) === 0 && Number.isInteger(castVal) && (castType === 'int' || castType === 'long' || castType === 'short' || castType === 'byte')) throw new Error('ArithmeticException: / by zero');

return castVal / Number(right);

}

if (op === '%') return castVal % Number(right);

}

const castVal = this.evaluateExpression(restExpr, vars);

if (castType === 'int') return Math.floor(Number(castVal));

if (castType === 'double' || castType === 'float') return Number(castVal);

if (castType === 'char') return String.fromCharCode(Number(castVal));

return castVal;

}

// String concatenation with + (handle carefully)

// We need to split on + but not inside strings or parens

const concatParts = this.splitOnOperator(expr, '+');

if (concatParts.length > 1) {

const values = concatParts.map(p => this.evaluateExpression(p.trim(), vars));

if (values.some(v => typeof v === 'string' || (v && typeof v === 'object' && v.__type__))) {

return values.map(v => {

if (v === null) return 'null';

if (v === undefined) return 'undefined';

if (v && typeof v === 'object' && v.__type__ === 'ArrayList') return '[' + v.items.join(', ') + ']';

if (v && typeof v === 'object' && v.__type__ === 'HashMap') { const entries = [...v.map.entries()].map(([k, val]) => k + '=' + val); return '{' + entries.join(', ') + '}'; }

if (v && typeof v === 'object' && v.__type__ === 'StringBuilder') return v.value;

if (Array.isArray(v)) return '[' + v.join(', ') + ']';

return String(v);

}).join('');

}

// Otherwise it's numeric addition - but only if exactly 2 parts or all numeric