java2ib/dist/parser.d.ts

TypeScript library that converts Java code into IB Computer Science pseudocode format

/**
 * Parser for Java source code that builds an Abstract Syntax Tree (AST)
 */
import { Token, ASTNode, NodeType, ConversionError } from './types';
export interface ProgramNode extends ASTNode {
    type: NodeType.PROGRAM;
    declarations: ASTNode[];
}
export interface ClassDeclarationNode extends ASTNode {
    type: NodeType.CLASS_DECLARATION;
    name: string;
    superClass?: string;
    methods: MethodDeclarationNode[];
    fields: VariableDeclarationNode[];
}
export interface MethodDeclarationNode extends ASTNode {
    type: NodeType.METHOD_DECLARATION;
    name: string;
    returnType: string;
    parameters: ParameterNode[];
    body: ASTNode[];
    isVoid: boolean;
    isStatic: boolean;
    isPublic: boolean;
}
export interface ParameterNode extends ASTNode {
    name: string;
    paramType: string;
}
export interface VariableDeclarationNode extends ASTNode {
    type: NodeType.VARIABLE_DECLARATION;
    name: string;
    dataType: string;
    initializer?: ASTNode;
}
export interface AssignmentNode extends ASTNode {
    type: NodeType.ASSIGNMENT;
    left: ASTNode;
    right: ASTNode;
    operator: string;
}
export interface BinaryExpressionNode extends ASTNode {
    type: NodeType.BINARY_EXPRESSION;
    left: ASTNode;
    right: ASTNode;
    operator: string;
}
export interface MethodCallNode extends ASTNode {
    type: NodeType.METHOD_CALL;
    object?: ASTNode;
    methodName: string;
    arguments: ASTNode[];
}
export interface IfStatementNode extends ASTNode {
    type: NodeType.IF_STATEMENT;
    condition: ASTNode;
    thenStatement: ASTNode;
    elseStatement?: ASTNode;
}
export interface WhileLoopNode extends ASTNode {
    type: NodeType.WHILE_LOOP;
    condition: ASTNode;
    body: ASTNode;
}
export interface ForLoopNode extends ASTNode {
    type: NodeType.FOR_LOOP;
    initialization?: ASTNode;
    condition?: ASTNode;
    update?: ASTNode;
    body: ASTNode;
}
export interface LiteralNode extends ASTNode {
    type: NodeType.LITERAL;
    value: string;
    dataType: 'string' | 'number' | 'boolean' | 'char';
}
export interface IdentifierNode extends ASTNode {
    type: NodeType.IDENTIFIER;
    name: string;
}
export interface ArrayAccessNode extends ASTNode {
    type: NodeType.ARRAY_ACCESS;
    array: ASTNode;
    index: ASTNode;
}
export interface ReturnStatementNode extends ASTNode {
    type: NodeType.RETURN_STATEMENT;
    expression?: ASTNode;
}
export interface SwitchStatementNode extends ASTNode {
    type: NodeType.SWITCH_STATEMENT;
    discriminant: ASTNode;
    cases: (CaseClauseNode | DefaultClauseNode)[];
}
export interface CaseClauseNode extends ASTNode {
    type: NodeType.CASE_CLAUSE;
    test: ASTNode;
    consequent: ASTNode[];
}
export interface DefaultClauseNode extends ASTNode {
    type: NodeType.DEFAULT_CLAUSE;
    consequent: ASTNode[];
}
export interface BreakStatementNode extends ASTNode {
    type: NodeType.BREAK_STATEMENT;
}
export interface ContinueStatementNode extends ASTNode {
    type: NodeType.CONTINUE_STATEMENT;
}
export interface EnhancedForLoopNode extends ASTNode {
    type: NodeType.ENHANCED_FOR_LOOP;
    variable: IdentifierNode;
    iterable: ASTNode;
    body: ASTNode;
}
export interface ArrayInitializationNode extends ASTNode {
    type: NodeType.ARRAY_INITIALIZATION;
    elements: ASTNode[];
}
export declare class Parser {
    private tokens;
    private current;
    private errors;
    constructor(tokens: Token[]);
    /**
     * Parse tokens into an Abstract Syntax Tree
     * @returns Parse result with AST and any syntax errors
     */
    parse(): {
        ast: ProgramNode | null;
        errors: ConversionError[];
    };
    private parseProgram;
    private parseDeclaration;
    private parseClassDeclaration;
    private parseClassDeclarationWithModifiers;
    private parseMethodDeclaration;
    private parseVariableDeclaration;
    private parseFieldDeclaration;
    private parseVariableDeclarationWithoutSemicolon;
    private parseStatement;
    private parseIfStatement;
    private parseWhileLoop;
    private parseForLoop;
    private parseReturnStatement;
    private parseSwitchStatement;
    private parseBreakStatement;
    private parseContinueStatement;
    private parseBlockStatement;
    private parseBlock;
    private parseExpressionStatement;
    private parseExpression;
    private parseAssignment;
    private parseLogicalOr;
    private parseLogicalAnd;
    private parseEquality;
    private parseComparison;
    private parseTerm;
    private parseFactor;
    private parseUnary;
    private parsePostfix;
    private parsePrimary;
    private match;
    private matchOperator;
    private check;
    private checkModifiers;
    private checkReturnType;
    private checkDataType;
    private checkDataTypeOrIdentifier;
    private advance;
    private isAtEnd;
    private peek;
    private previous;
    private consume;
    private synchronize;
    private getCurrentLocation;
    private addError;
    private getExpressionName;
}
//# sourceMappingURL=parser.d.ts.map