Use this project as API

[sblendorio]

Is it possible to use this project as an API, like...

basic.exec("10 PRINT 3*4", System.in, System.out)

?

[lwiest]

Hello Francesco, thank you for your interest in BASICCompiler! Yes, I think this should be possible. Not out of the box, as, of course, one needs to implement the exact method signature you mentioned. If you want to have a try at doing this by yourself, maybe a look into file CompilerTest.java, method compileAndRun(), could provide some inspiration. Best regards -- Lorenz

[sblendorio]

Hi Lorenz, BASICCompiler seems to be the best solution for my project, https://github.com/sblendorio/petscii-bbs

In a few words, it's a "BBS Server", and I'm incorporating classic text games and other contents.

There are a lot of classic BASIC games and I would like to integrate them into it. What I'd need is a sort of "bridge" from your generated code to mine.

I looked into the source, it prints/reads from static object System.in and System.out. What I could do has been to add a class:

package de.lorenzwiest.basiccompiler;

import java.lang.reflect.Method;

public class JavaClassLoader extends ClassLoader {
	public static void main(byte[] data) throws Exception {
		JavaClassLoader _classLoader = new JavaClassLoader();
		byte[] rawBytes = new byte[data.length];
		for (int index = 0; index < rawBytes.length; index++)
			rawBytes[index] = (byte) data[index];
		Class regeneratedClass = _classLoader.defineClass("Result", rawBytes, 0, rawBytes.length);
		Method meth = regeneratedClass.getMethod("main", String[].class);
		String[] params = null;
		meth.invoke(null, (Object) params);
	  }
}

then using it into the pre-existing main:

...
    try {
	    inReader = new BufferedReader(new FileReader(inFilename));
	    if (outFilename.endsWith(".class") == false) {
		    outFilename += ".class";
	    }
	    outStream = new BufferedOutputStream(new FileOutputStream(outFilename));
	    String className = getClassName(outFilename);
	    ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
	    BASICCompiler.exec(inReader, outStream, className, properties);
	    byte[] code = bytesOut.toByteArray();
	    JavaClassLoader.main(code);
    } catch (FileNotFoundException e) {
...

but here, I can't use classes which are outside the custom classpath.

In my project, I have a class, "BbsThread" which incapsulates I/O operation through a bunch of methods (e.g. println(), readKey(), readLine(), ...), I'd like to be able to call them when in BASIC program there are PRINT and INPUT instruction: this would solve all the issues.

But... it's a compiler and I don't know the internals of the JVM (though the whole project is very very clean, I love it, especially because it doesn't need any external dependency).

Please could you suggest me where I can start to investigate to build this sort of "bridge"?

Thanks in advance

[lwiest]

Hello Francesco,

if I understand you correctly, then you actually want to achieve two things:

1. Compile BASIC programs to Java byte code with BASICCompiler.exec(inReader, outStream, className, ...), where inReader is the object which reads the BASIC source code and outStream is the object to which the compiled Java bytecode is written. This should be quite possible.
2. Delegate calls in the compiled program to System.out and System.in (resulting from BASIC commands PRINT, INPUT, etc.) to your own I/O class methods. As you have already discovered, at runtime, BASIC "output" commands (= PRINT) eventually call the bytecode produced by Method_PrintCharFromStack.addMethodBytecode(), which funnels all calls to System.out. Similarly, BASIC "input" commands (= INPUT) eventually call the bytecode produced by Method_ReadCharsToStack.addMethodBytecode(), which funnels all calls to System.in. These calls are "baked" into the compiled program. Unfortunately, I don't know how to easily delegate those calls to methods of other classes without changing the code of Method_PrintCharFromStack and Method_ReadCharsToStack.

Best regards -- Lorenz

[sblendorio]

Hello, thanks for your detailed explanation.

Point 1. OK, it's simple, I just did it.

Point 2. I'm looking at Method_PrintCharFromStack and Method_ReadCharsToStack and since I don't know internals of JVM, I'm not able to change it. I ask you: is it possibile to write a bytecode which calls some external class / method (not static) which follows some agreed conventions? (not changing this repo, but just on a fork of mine)

[lwiest]

Hello Francesco,

I think, I've found a way to modify BASICCompiler such that it reroutes input and output calls from BASIC's INPUT and PRINT statements to another class. Find a fully worked out example below.

Background

• For the execution of INPUT statments, the bytecode produced by BASICCompiler retrieves an InputStream from field System.in and calls its method int read(byte[] b).
• For the execution of PRINT statements, the bytecode produced by BASICCompiler retrieves a PrintStream from field System.out and calls its method void print(char c).
• We change BASICCompiler such that the produced bytecode doesn't retrieve the InputStream from System.in and the PrintStream from System.out, but from a class of your own, which we call MyIOClass.

Steps

1.) Implement class MyIOClass in package com.sample. (Find the full version of class MyIOClass at the end of this post.)

package com.sample;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;

public class MyIOClass {
  static class MyInputStream extends InputStream {
    // ...
  }

  static class MyPrintStream extends PrintStream {
    // ...
  }

  public static InputStream IN = new MyInputStream();
  public static PrintStream OUT = new MyPrintStream(System.out);
}

This class has two static fields IN and OUT. BASICCompiler will produce bytecode that uses those fields to call IN.read(byte[] b) and OUT.printprint(char c), respectively.

2.) Compile this class. (So there is a MyIOClass.class file.)

3.) Donload the content of BASICCompiler GitHub repo into a directory (which I'll call the "project folder"), for example,

  C:\eclipseWorkspace.others\BASICCompiler

4.) In the BASICCompiler source code file ClassModel.java, find and change the following snippet:

  OLD
    SYSTEM_OUT("java/lang/System", "out", "Ljava/io/PrintStream;"),
    SYSTEM_IN("java/lang/System", "in", "Ljava/io/InputStream;");
  NEW
    SYSTEM_OUT("com/sample/MyIOClass", "OUT", "Ljava/io/PrintStream;"),
    SYSTEM_IN("com/sample/MyIOClass", "IN", "Ljava/io/InputStream;");

5.) Create the BASICCompiler JAR file by entering the following in the project folder:

  C:\eclipseWorkspace.others\BASICCompiler> makejar

This creates the BASICCompiler.jar file.

6.) Create a simple BASIC file SAMPLE.BAS in the project folder:

    10 INPUT "WHAT'S YOUR NAME"; A$
    20 PRINT A$

7.) Compile this BASIC program with the BASICCompiler JAR that you created in step 5:

  C:\eclipseWorkspace.others\BASICCompiler> java -jar BASICCompiler SAMPLE.BAS Sample

8.) Run the compiled BASIC program:

  C:\eclipseWorkspace.others\BASICCompiler> java -classpath .;./bin Sample

NOTE: The classpath argument lists two folders: . lets Java detect the Sample class file at C:\eclipseWorkspace.others\BASICCompiler\Sample.class, ./bin lets Java detect the MyIOClass class file (provided it is located at C:\eclipseWorkspace.others\BASICCompiler\bin\com\sample\MyIOClass.class).
NOTE: You may need to replace ./bin with the actual class path of your MyIOClass.class file.

Enter SAMPLE, then press RETURN. The output should look like so:

  *W*H*A*T*'*S* *Y*O*U*R* *N*A*M*E*?SAMPLE
  *S*A*M*P*L*E*

// Full version of MyIOClass.java

package com.sample;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;

public class MyIOClass {
  static class MyInputStream extends InputStream {
    static InputStream in = System.in;

    @Override
    public int read() throws IOException {
      return in.read();
    }

    public static InputStream nullInputStream() {
      return in.nullInputStream();
    }

    @Override
    public int read(byte b[]) throws IOException {
      return in.read(b);
    }

    @Override
    public int read(byte b[], int off, int len) throws IOException {
      return in.read(b, off, len);
    }

    @Override
    public byte[] readAllBytes() throws IOException {
      return in.readAllBytes();
    }

    @Override
    public byte[] readNBytes(int len) throws IOException {
      return in.readNBytes(len);
    }

    @Override
    public int readNBytes(byte[] b, int off, int len) throws IOException {
      return in.readNBytes(b, off, len);
    }

    @Override
    public long skip(long n) throws IOException {
      return in.skip(n);
    }

    @Override
    public int available() throws IOException {
      return in.available();
    }

    @Override
    public void close() throws IOException {
      in.close();
    }

    @Override
    public synchronized void mark(int readlimit) {
      in.mark(readlimit);
    }

    @Override
    public synchronized void reset() throws IOException {
      in.reset();
    }

    @Override
    public boolean markSupported() {
      return in.markSupported();
    }

    @Override
    public long transferTo(OutputStream out) throws IOException {
      return in.transferTo(out);
    }
  }

  static class MyPrintStream extends PrintStream {
    public MyPrintStream(OutputStream out) {
      super(out);

    }

    @Override
    public void print(char c) {
      System.out.print("*");
      super.print(c);
    }
  }

  public static InputStream IN = new MyInputStream();
  public static PrintStream OUT = new MyPrintStream(System.out);
}

I hope this may be of help.

Best regards -- Lorenz

[sblendorio]

Thanks for your detailed explanation!

Just one doubt: is it possibile to use a NOT static class, but instead a specific instance, an object? In my project I have several threads which communicate with their specific socket client.

To have an idea, this is the service https://bbs.retrocampus.com (it's just a web proxy for a TCP RAW service reachable through TELNET)

[sblendorio]

How could it be hard to turn it from compiler to an interpreter?

[lwiest]

Hello Francesco,

Just one doubt: is it possibile to use a NOT static class...

I had a good look at the issue but couldn't find a quick way to do it. One issue is how to pass the instance reference of the IOClass to BASICCompiler, another issue is how to pass this reference to the bytecode produced by methods Method_PrintCharFromStack.addMethodBytecode() and Method_ReadCharsToStack.addMethodBytecode(). For this, I think, the produced bytecode would need to be rewritten at the least. Unfortunatley I couldn't cook up anything to this end.

How could it be hard to turn it from compiler to an interpreter?

How hard would it be to turn the compiler into an interpreter? I think this depends on the definition of "interpreter". I would see a BASIC interpreter as an "environment" in which I could enter and run lines of BASIC commands. While doing so, variables may be created dynamically at runtime, depending on your BASIC commands. So the environment would need to provide a kind of dynamic "scope" for variables at runtime. This is something the compiler does not provide, because it knows all variables already at compile time (all variables are in a sense static), it doesn't need to handle creating and maintaining variables dynamically at runtime.

Best regards -- Lorenz