interpreter — API

Lexer

src/Lexer.ts

export class Lexer {
    private regex = /\s*(=>|{|}|<|>|<\/|\/>|::|\$|[A-Za-z_][A-Za-z_0-9]*|\d+|\S)\s*/g;

    public tokenize(code: string): Token[] {
        let result: Token[] = [];
        let match;
        while (match = this.regex.exec(code)) {
            let token: Token;
            if (match[1] === '<' || match[1] === '>' || match[1] === '</' || match[1] === '/>') {
                token = { type: TokenType.XMLTag, value: match[1] };
            } else if (match[1] === '::') {
                token = { type: TokenType.TypeScriptNamespace, value: match[1] };
            } else if (match[1] === '$') {
                token = { type: TokenType.PHPVariable, value: match[1] };
            } else if (!isNaN(Number(match[1]))) {
                token = { type: TokenType.Number, value: Number(match[1]) };
            } else {
                token = { type: TokenType.Identifier, value: match[1] };
            }
            result.push(token);
        }
        return result;
    }
}

TokenType

src/Lexer.ts

export enum TokenType {
    XMLTag = 'XMLTag',
    TypeScriptNamespace = 'TypeScriptNamespace',
    PHPVariable = 'PHPVariable',
    Number = 'Number',
    Identifier = 'Identifier',
}

Token

src/types.d.ts

export type Token = {
    type: TokenType;
    value: string | number;
};

ASTNode

src/types.d.ts

export type ASTNode = {
    type: string;
    children?: ASTNode[];
};

ProgramNode

src/types.d.ts

export type ProgramNode = ASTNode & {
    type: 'Program';
    body: StatementNode[];
};

StatementNode

src/types.d.ts

export type StatementNode = FunctionDeclarationNode | ClassDeclarationNode | VariableAssignmentNode | EchoStatementNode | ReturnStatementNode | LoopStatementNode | ConditionalStatementNode | TryStatementNode | ModuleImportNode;

ExpressionNode

src/types.d.ts

export type ExpressionNode = BinaryExpressionNode | UnaryExpressionNode | ConditionalExpressionNode | ArrayExpressionNode | ObjectExpressionNode | CallExpressionNode | MemberExpressionNode | IdentifierNode | LiteralNode;

FunctionDeclarationNode

src/types.d.ts

export type FunctionDeclarationNode = ASTNode & {
    type: 'FunctionDeclaration';
    name: IdentifierNode;
    params: IdentifierNode[];
    body: StatementNode[];
};

ClassDeclarationNode

src/types.d.ts

export type ClassDeclarationNode = ASTNode & {
    type: 'ClassDeclaration';
    name: IdentifierNode;
    properties: PropertyNode[];
    methods: FunctionDeclarationNode[];
};

PropertyNode

src/types.d.ts

export type PropertyNode = ASTNode & {
    type: 'Property';
    name: IdentifierNode;
    value: ExpressionNode;
};

VariableAssignmentNode

src/types.d.ts

export type VariableAssignmentNode = ASTNode & {
    type: 'VariableAssignment';
    name: IdentifierNode;
    value: ExpressionNode;
};

ModuleImportNode

src/types.d.ts

export type ModuleImportNode = ASTNode & {
    type: 'ModuleImport';
    moduleName: string;
};

EchoStatementNode

src/types.d.ts

export type EchoStatementNode = ASTNode & {
    type: 'EchoStatement';
    expressions: ExpressionNode[];
};

ReturnStatementNode

src/types.d.ts

export type ReturnStatementNode = ASTNode & {
    type: 'ReturnStatement';
    argument: ExpressionNode;
};

BinaryExpressionNode

src/types.d.ts

export type BinaryExpressionNode = ASTNode & {
    type: 'BinaryExpression';
    operator: string;
    left: ExpressionNode;
    right: ExpressionNode;
};

UnaryExpressionNode

src/types.d.ts

export type UnaryExpressionNode = ASTNode & {
    type: 'UnaryExpression';
    operator: string;
    argument: ExpressionNode;
};

ConditionalExpressionNode

src/types.d.ts

export type ConditionalExpressionNode = ASTNode & {
    type: 'ConditionalExpression';
    test: ExpressionNode;
    consequent: ExpressionNode;
    alternate: ExpressionNode;
};

ArrayExpressionNode

src/types.d.ts

export type ArrayExpressionNode = ASTNode & {
    type: 'ArrayExpression';
    elements: ExpressionNode[];
};

ObjectExpressionNode

src/types.d.ts

export type ObjectExpressionNode = ASTNode & {
    type: 'ObjectExpression';
    properties: PropertyNode[];
};

CallExpressionNode

src/types.d.ts

export type CallExpressionNode = ASTNode & {
    type: 'CallExpression';
    callee: ExpressionNode;
    arguments: ExpressionNode[];
};

MemberExpressionNode

src/types.d.ts

export type MemberExpressionNode = ASTNode & {
    type: 'MemberExpression';
    object: ExpressionNode;
    property: ExpressionNode;
};

IdentifierNode

src/types.d.ts

export type IdentifierNode = ASTNode & {
    type: 'Identifier';
    name: string;
};

LiteralNode

src/types.d.ts

export type LiteralNode = ASTNode & {
    type: 'Literal';
    value: string | number | boolean | null;
};

LoopStatementNode

src/types.d.ts

export type LoopStatementNode = ASTNode & {
    type: 'LoopStatement';
    init: ExpressionNode;
    test: ExpressionNode;
    update: ExpressionNode;
    body: StatementNode;
};

ConditionalStatementNode

src/types.d.ts

export type ConditionalStatementNode = ASTNode & {
    type: 'ConditionalStatement';
    test: ExpressionNode;
    consequent: StatementNode;
    alternate: StatementNode;
};

TryStatementNode

src/types.d.ts

export type TryStatementNode = ASTNode & {
    type: 'TryStatement';
    block: StatementNode;
    handler: CatchClauseNode;
};

CatchClauseNode

src/types.d.ts

export type CatchClauseNode = ASTNode & {
    type: 'CatchClause';
    param: IdentifierNode;
    body: StatementNode;
};

AST

src/types.d.ts

export type AST = ProgramNode;