Merge pull request #1 from chrisvrose/cleanup

Minor Cleanup

client/src/BranFlakesExecutorVisitor.ts

@@ -0,0 +1,146 @@
+import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor';
+import { LoopStmtContext } from './generated/bfParser';
+import { bfVisitor } from './generated/bfVisitor';
+import { DiagnosticSeverity } from 'vscode-languageclient';
+import { getTree } from './BranFlakesParseRunner';
+import { RuleNode } from 'antlr4ts/tree/RuleNode';
+import InputStrategy from './input/InputStrategy';
+
+export default class BranFlakesExecutorVisitor
+    extends AbstractParseTreeVisitor<Promise<void>>
+    implements bfVisitor<Promise<void>>
+{
+    /**
+     *
+     * @param input Input string
+     * @param inputPtr Input pointer to start from
+     */
+    constructor(
+        protected inputStrategy: InputStrategy,
+        protected logger: (val: string) => Thenable<string>,
+        protected inputPtr: number = 0
+    ) {
+        super();
+    }
+    // /**
+    //  * The memory cells (Can work with negative cells this way)
+    //  */
+    // protected cells: Map<number, number> = new Map();
+
+    protected byteArraySize: number = 30000;
+    protected byteArray: Int8Array = new Int8Array(this.byteArraySize);
+    /**
+     * Pointer
+     */
+    protected ptr: number = 0;
+    /** Output string */
+    protected outputStrArray: string[] = [];
+
+    /**
+     * Output string (Available only after visiting)
+     */
+    public get outputStr() {
+        return this.outputStrArray.join('');
+    }
+
+    defaultResult() {
+        return Promise.resolve();
+    }
+    /**
+     * Run a file
+     * @param text
+     * @param fn
+     * @param inputStrategy
+     * @returns
+     */
+    static async run(
+        text: string,
+        fn: string,
+        inputStrategy: InputStrategy,
+        logger: (str:string) => Thenable<string>
+    ) {
+        //get tree and issues
+        const { tree, issues } = getTree(text, fn);
+
+        //get only errors
+        const x = issues.filter(e => e.type === DiagnosticSeverity.Error);
+        //if any error, drop
+        if (x.length > 0) {
+            throw Error('Errors exist');
+        }
+        // make visitor
+        const vis = new BranFlakesExecutorVisitor(inputStrategy, logger);
+        //visit the tree
+        await vis.visit(tree);
+
+        //get output
+        return vis.outputStr;
+    }
+
+    getCell(pointerIndex: number) {
+        return this.byteArray[pointerIndex];
+    }
+    setCell(pointerIndex: number, value: number): void {
+        this.byteArray[pointerIndex] = value;
+    }
+
+    async visitLoopStmt(ctx: LoopStmtContext) {
+        while ((this.getCell(this.ptr) ?? 0) !== 0) {
+            await this.visitChildren(ctx);
+        }
+    }
+    async visitPtrLeft() {
+        --this.ptr;
+    }
+    async visitPtrRight() {
+        ++this.ptr;
+    }
+    async visitPtrIncr() {
+        const val = this.getCell(this.ptr);
+        this.setCell(this.ptr, (val + 1) % 256);
+    }
+    async visitPtrDecr() {
+        const val = this.getCell(this.ptr);
+        this.setCell(this.ptr, (val + 255) % 256);
+    }
+    async visitOutputStmt() {
+        const val = this.getCell(this.ptr) ?? 0;
+        const str = String.fromCharCode(val);
+
+        this.outputStrArray.push(str);
+    }
+
+    async visitInputStmt() {
+        //get char
+        const char = await this.inputStrategy.getInput() ?? 0;
+        //increment the input pointer after this
+        this.inputPtr++;
+        this.setCell(this.ptr, char);
+    }
+
+    // override for maintaining async
+    async visitChildren(node: RuleNode): Promise<void> {
+        // await this.logger("checking "+node.constructor.name)
+        let result = this.defaultResult();
+        await result;
+        let n = node.childCount;
+        for (let i = 0; i < n; i++) {
+            if (!this.shouldVisitNextChild(node, result)) {
+                break;
+            }
+            let c = node.getChild(i);
+            let childResult = c.accept(this);
+            result = this.aggregateResult(result, childResult);
+            await result;
+        }
+        return Promise.resolve();
+    }
+    // override for maintaining async
+    protected async aggregateResult(
+        aggregate: Promise<void>,
+        nextResult: Promise<void>
+    ): Promise<void> {
+        await aggregate;
+        return nextResult;
+    }
+}

client/src/BranFlakesParseRunner.ts

@@ -16,9 +16,9 @@ export interface TranslationError {
 export function getTree(str: string, fn: string) {
 	const charStreams = CharStreams.fromString(str, fn);
 	const lexer = new bfLexer(charStreams);
-	// const errorListener = this.errorManager.newErrorListener();
 	const issues: TranslationError[] = [];
 	// remove the error listener. We want to put our own
+	
 	lexer.removeErrorListeners();
 	lexer.addErrorListener({
 		syntaxError(source, o, line, charPositionInLine, msg, error) {

client/src/bfExecutor.ts

@@ -1,117 +0,0 @@
-import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor';
-import { LoopStmtContext, ProgramContext } from '../../client/src/generated/bfParser';
-import { bfVisitor } from '../../client/src/generated/bfVisitor';
-import {getTree} from './bfGrammar';
-import { DiagnosticSeverity } from 'vscode-languageserver-types';
-
-/**
- * Run BF code
- * @param text 
- * @param fn 
- * @param input 
- * @returns 
- */
-export async function runBF(text:string,fn:string,input:string){
-	//get tree and issues
-	const {tree,issues} = getTree(text,fn);
-
-	//get only errors
-	const x = issues.filter(e=>e.type===DiagnosticSeverity.Error);
-	//if any error, drop
-	if(x.length>0) {
-		throw Error('Errors exist');
-	}
-	// make visitor
-	const vis = new BFExecutor(input);
-	
-	//visit the tree
-	vis.visit(tree);
-
-	//get output
-	return vis.outputStr;
-}
-
-
-class BFExecutor
-	extends AbstractParseTreeVisitor<void>
-	implements bfVisitor<void> {
-
-	/**
-	 * 
-	 * @param input Input string
-	 * @param inputPtr Input pointer to start from
-	 */
-	constructor(protected input: string='', protected inputPtr: number = 0) {
-		super();
-	}
-	/**
-	 * The memory cells (Can work with negative cells this way)
-	 */
-    protected cells: Map<number, number> = new Map();
-    /**
-	 * Pointer
-	 */
-	protected ptr: number = 0;
-	/** Output string */
-	protected outputStrArray:string[]=[];
-
-	/**
-	 * Output string (Available only after visiting)
-	 */
-	public get outputStr(){
-		return this.outputStrArray.join('');
-	}
-
-
-	defaultResult() {}
-
-	visitLoopStmt(ctx:LoopStmtContext){
-		while((this.cells.get(this.ptr)??0)!==0){
-			this.visitChildren(ctx);
-		}
-	}
-	visitPtrLeft() {
-		
-		--this.ptr;
-	}
-	visitPtrRight() {
-		++this.ptr;
-	}
-	visitPtrIncr() {
-
-    	const val = this.cells.get(this.ptr);
-    	if (val === undefined) {
-    		this.cells.set(this.ptr, 1);
-		} else if(val===255){
-			this.cells.delete(this.ptr);
-		}else{
-    		this.cells.set(this.ptr, val + 1);
-    	}
-	}
-	visitPtrDecr() {
-		// console.log('down',this.ptr,this.cells);
-
-    	const val = this.cells.get(this.ptr);
-    	if (val === undefined || val === 0) {
-    		this.cells.set(this.ptr, 255);
-    	} else if(val===1){
-			this.cells.delete(this.ptr);
-		}else{
-    		this.cells.set(this.ptr, val - 1);
-    	}
-	}
-	visitOutputStmt() {
-		const val = this.cells.get(this.ptr)??0;
-		const str = String.fromCharCode(val);
-		// console.log('op',str);
-		this.outputStrArray.push(str);
-	}
-
-	visitInputStmt(){
-		//get char
-		const char = this.input.charCodeAt(this.inputPtr)??0;
-		//increment the input pointer after this
-		this.inputPtr++;
-		this.cells.set(this.ptr,char);
-	}
-}

client/src/extension.ts

@@ -4,14 +4,15 @@
  * ------------------------------------------------------------------------------------------ */
 
 import * as path from 'path';
-import { workspace, ExtensionContext,commands, window } from 'vscode';
+import { ExtensionContext,commands, window } from 'vscode';
-import {runBF} from './bfExecutor';
 import {
 	LanguageClient,
 	LanguageClientOptions,
 	ServerOptions,
 	TransportKind
 } from 'vscode-languageclient';
+import BranFlakesExecutorVisitor from './BranFlakesExecutorVisitor';
+import { VSCodePromptInputStrategy } from './input/VSCodePromptInputStrategy';
 
 
 let client: LanguageClient;
@@ -46,8 +47,8 @@ export function activate(context: ExtensionContext) {
 	const commandHandler = async()=>{
 		const text= window.activeTextEditor.document.getText();
 		const fn = window.activeTextEditor.document.fileName;
-		const input = await window.showInputBox({prompt:'Enter input (If not enough, program will assume 0)'});
+		const inputStrategy = new VSCodePromptInputStrategy(window.showInputBox);
-		const output = await runBF(text,fn,input);
+		const output = await BranFlakesExecutorVisitor.run(text,fn,inputStrategy,window.showInformationMessage);
 		await window.showInformationMessage(`Output: ${output}`);
 	};
 

client/src/input/InputStrategy.ts

@@ -0,0 +1,4 @@
+
+export default interface InputStrategy {
+	getInput(): Promise<number>;
+}

client/src/input/VSCodePromptInputStrategy.ts

@@ -0,0 +1,21 @@
+import { CancellationToken, InputBoxOptions } from 'vscode';
+import InputStrategy from './InputStrategy';
+
+export class VSCodePromptInputStrategy implements InputStrategy {
+    private inputQueue:string;
+	constructor(private requestor:(promptOptions?:InputBoxOptions,cancelToken?:CancellationToken)=>Thenable<string>) {}
+
+    async getInput(): Promise<number> {
+        while (this.inputQueue.length == 0) {
+            await this.requestInputFromPrompt();
+        }
+        const character = this.inputQueue.charCodeAt(0);
+        this.inputQueue = this.inputQueue.substring(1);
+        
+        return character;
+    }
+    private async requestInputFromPrompt() {
+        const inputPrompt = await this.requestor({prompt:"More input is required. Please provide input:"});
+        this.inputQueue += inputPrompt;
+    }
+}

server/src/server.ts

@@ -18,10 +18,10 @@ import {
 	Position,
 } from 'vscode-languageserver';
 
-// import * as path from 'path';
+
 
 import { TextDocument } from 'vscode-languageserver-textdocument';
-// import { getTree } from './bfGrammar';
+
 
 // Create a connection for the server. The connection uses Node's IPC as a transport.
 // Also include all preview / proposed LSP features.