669 lines
22 KiB
Java
669 lines
22 KiB
Java
/*
|
|
* AppleCommander - An Apple ][ image utility.
|
|
* Copyright (C) 2003-2022 by Robert Greene
|
|
* robgreene at users.sourceforge.net
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
package com.webcodepro.applecommander.compiler;
|
|
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Properties;
|
|
import java.util.Stack;
|
|
|
|
import com.webcodepro.applecommander.storage.FileEntry;
|
|
import com.webcodepro.applecommander.util.ApplesoftToken;
|
|
import com.webcodepro.applecommander.util.ApplesoftTokenizer;
|
|
import com.webcodepro.applecommander.util.ApplesoftTokens;
|
|
import com.webcodepro.applecommander.util.TextBundle;
|
|
|
|
/**
|
|
* Compile the given Applesoft file. The result will be an assembly
|
|
* program (ultimately assembled). This is not intended to be anything
|
|
* sophisticated.
|
|
* <p>
|
|
* Date created: Nov 2, 2002 10:04:10 PM
|
|
* @author Rob Greene
|
|
*/
|
|
public class ApplesoftCompiler implements ApplesoftTokens {
|
|
private TextBundle textBundle = CompilerBundle.getInstance();
|
|
/**
|
|
* Tokenized the Applesoft program.
|
|
*/
|
|
private ApplesoftTokenizer tokenizer;
|
|
/**
|
|
* Holds a token that was "peeked" at, if any. A null indicates
|
|
* that there is no value peeked at.
|
|
*/
|
|
private ApplesoftToken tokenAlreadySeen;
|
|
/**
|
|
* Used internally to construct the assembly representation of
|
|
* the Applesoft code. This variable should really be passed
|
|
* between methods.
|
|
*/
|
|
private StringBuffer sourceAssembly = new StringBuffer();
|
|
/**
|
|
* Used internally to construct the original Applesoft source
|
|
* line. This variable should really be passed between methods.
|
|
*/
|
|
private StringBuffer sourceLine = new StringBuffer();
|
|
/**
|
|
* Contains a list of all known Apple ROM addresses that may be used
|
|
* by the compiled program. This map is keyed by the name of the
|
|
* address and the value is the address.
|
|
*/
|
|
private Map<String,String> knownAddresses = new HashMap<>();
|
|
/**
|
|
* Lists the names of all addresses used by the compiled program.
|
|
* To identify the value, use the knownAddresses map.
|
|
*/
|
|
private List<String> usedAddresses = new ArrayList<>();
|
|
/**
|
|
* Contains a list of all variables declared or used by the
|
|
* program.
|
|
*/
|
|
private List<Variable> variables = new ArrayList<>();
|
|
/**
|
|
* Dynamically created map of commands to Methods.
|
|
*/
|
|
private Map<String,Method> commandMethods = new HashMap<>();
|
|
/**
|
|
* Track FOR loop variables.
|
|
*/
|
|
private Stack<String> loopVariables = new Stack<>();
|
|
/**
|
|
* Indicates integer math operations only.
|
|
*/
|
|
private boolean integerOnlyMath;
|
|
|
|
/**
|
|
* Constructor for ApplesoftCompiler.
|
|
*/
|
|
public ApplesoftCompiler(FileEntry fileEntry) {
|
|
super();
|
|
tokenizer = new ApplesoftTokenizer(fileEntry);
|
|
initializeKnownAddresses();
|
|
}
|
|
|
|
/**
|
|
* Load known memory addresses from AppleMemoryAddresses.properties.
|
|
*/
|
|
protected void initializeKnownAddresses() {
|
|
InputStream inputStream =
|
|
getClass().getResourceAsStream("AppleMemoryAddresses.properties"); //$NON-NLS-1$
|
|
Properties properties = new Properties();
|
|
try {
|
|
properties.load(inputStream);
|
|
for (String key : properties.stringPropertyNames()) {
|
|
knownAddresses.put(key, properties.getProperty(key));
|
|
}
|
|
} catch (IOException ex) {
|
|
ex.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Answers true if there are more tokens to process.
|
|
*/
|
|
protected boolean hasMoreTokens() {
|
|
return peekToken() != null;
|
|
}
|
|
|
|
/**
|
|
* Get the next token.
|
|
*/
|
|
protected ApplesoftToken nextToken() {
|
|
ApplesoftToken token = tokenAlreadySeen;
|
|
if (tokenAlreadySeen != null) {
|
|
tokenAlreadySeen = null;
|
|
} else {
|
|
token = tokenizer.getNextToken();
|
|
}
|
|
if (token == null) {
|
|
// No more tokens
|
|
} else if (token.isLineNumber()) {
|
|
sourceLine.append("* "); //$NON-NLS-1$
|
|
sourceLine.append(token.getLineNumber());
|
|
sourceLine.append(" "); //$NON-NLS-1$
|
|
} else if (token.isToken()) {
|
|
sourceLine.append(token.getTokenString());
|
|
} else if (token.isString()) {
|
|
sourceLine.append(token.getStringValue());
|
|
}
|
|
return token;
|
|
}
|
|
|
|
/**
|
|
* Take a peek at the next token.
|
|
*/
|
|
protected ApplesoftToken peekToken() {
|
|
if (tokenAlreadySeen == null) {
|
|
tokenAlreadySeen = tokenizer.getNextToken();
|
|
}
|
|
return tokenAlreadySeen;
|
|
}
|
|
|
|
/**
|
|
* Compile the given FileEntry and return the assembly code.
|
|
*/
|
|
public byte[] compile() throws CompileException {
|
|
StringBuffer programCode = new StringBuffer();
|
|
while (hasMoreTokens()) {
|
|
ApplesoftToken token = nextToken();
|
|
if (!token.isLineNumber()) {
|
|
throw new CompileException(textBundle.
|
|
get("ApplesoftCompiler.ExpectLineNumberError")); //$NON-NLS-1$
|
|
}
|
|
sourceAssembly.append("LINE"); //$NON-NLS-1$
|
|
sourceAssembly.append(token.getLineNumber());
|
|
sourceAssembly.append("\n"); //$NON-NLS-1$
|
|
do {
|
|
evaluateCommand();
|
|
token = peekToken();
|
|
if (token != null && token.isCommandSeparator()) {
|
|
token = nextToken();
|
|
}
|
|
} while (token != null && token.isCommandSeparator());
|
|
programCode.append(sourceLine);
|
|
programCode.append("\n"); //$NON-NLS-1$
|
|
programCode.append(sourceAssembly);
|
|
programCode.append("\n"); //$NON-NLS-1$
|
|
sourceLine.setLength(0);
|
|
sourceAssembly.setLength(0);
|
|
}
|
|
programCode.insert(0, buildUsedAddresses());
|
|
programCode.append(buildVariableSection());
|
|
sourceLine.setLength(0);
|
|
sourceAssembly.setLength(0);
|
|
return programCode.toString().getBytes();
|
|
}
|
|
|
|
/**
|
|
* Build a list of ROM and Zero-page addresses that are used
|
|
* within this specific program.
|
|
*/
|
|
protected StringBuffer buildUsedAddresses() {
|
|
StringBuffer buf = new StringBuffer();
|
|
if (usedAddresses.size() > 0) {
|
|
buf.append("* Addresses:\n"); //$NON-NLS-1$
|
|
for (int i=0; i<usedAddresses.size(); i++) {
|
|
String label = (String) usedAddresses.get(i);
|
|
buf.append(label);
|
|
buf.append(" = "); //$NON-NLS-1$
|
|
buf.append((String) knownAddresses.get(label));
|
|
buf.append("\n"); //$NON-NLS-1$
|
|
}
|
|
buf.append("\n"); //$NON-NLS-1$
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
/**
|
|
* Build the variable section that is placed at the end of the
|
|
* assembly listing.
|
|
* <p>
|
|
* <b>Warning:</b> This method re-uses the global sourceAssembly
|
|
* variables since the addAssembly method is used to format the
|
|
* code.
|
|
*/
|
|
protected StringBuffer buildVariableSection() {
|
|
sourceAssembly.setLength(0);
|
|
for (int i=0; i<variables.size(); i++) {
|
|
if (i == 0) {
|
|
sourceAssembly.append("\n"); //$NON-NLS-1$
|
|
sourceAssembly.append("* Variables:\n"); //$NON-NLS-1$
|
|
}
|
|
Variable variable = (Variable) variables.get(i);
|
|
if (variable.isConstantInteger()) {
|
|
addAssembly(variable.getName(), "DW", variable.getValue()); //$NON-NLS-1$
|
|
} else if (variable.isConstantFloat()) {
|
|
// FIXME
|
|
} else if (variable.isConstantString()) {
|
|
addAssembly(variable.getName(), "ASC", variable.getValue()); //$NON-NLS-1$
|
|
addAssembly(null, "HEX", "00"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else if (variable.isTypeFloat()) {
|
|
addAssembly(variable.getName(), "HEX", "8400000000"); // = 0.0 //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else if (variable.isTypeInteger()) {
|
|
addAssembly(variable.getName(), "DS", "2"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else if (variable.isTypeString()) {
|
|
// FIXME
|
|
}
|
|
}
|
|
return sourceAssembly;
|
|
}
|
|
|
|
protected void evaluateCommand() {
|
|
ApplesoftToken token = nextToken();
|
|
while (token != null && token.isCommandSeparator()) {
|
|
token = nextToken();
|
|
}
|
|
if (token == null || !token.isToken()) {
|
|
return; // end of line (no command on line...)
|
|
}
|
|
Method method = getMethod(token);
|
|
if (method != null) {
|
|
try {
|
|
method.invoke(this, new Object[0]);
|
|
} catch (IllegalArgumentException e) {
|
|
System.err.println(textBundle.
|
|
format("ApplesoftCompiler.UnableToLocateError", //$NON-NLS-1$
|
|
method.getName()));
|
|
e.printStackTrace();
|
|
} catch (IllegalAccessException e) {
|
|
System.err.println(textBundle.
|
|
format("ApplesoftCompiler.UnableToLocateError", //$NON-NLS-1$
|
|
method.getName()));
|
|
e.printStackTrace();
|
|
} catch (InvocationTargetException e) {
|
|
System.err.println(textBundle.
|
|
format("ApplesoftCompiler.UnableToLocateError", //$NON-NLS-1$
|
|
method.getName()));
|
|
e.printStackTrace();
|
|
}
|
|
} else {
|
|
// FIXME: Just during development - this should throw an exception!
|
|
while (peekToken() != null && !peekToken().isCommandSeparator() && !peekToken().isLineNumber()) {
|
|
nextToken();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected Method getMethod(ApplesoftToken token) {
|
|
StringBuffer buf = new StringBuffer();
|
|
buf.append("evaluate"); //$NON-NLS-1$
|
|
buf.append(token.getTokenString().trim());
|
|
for (int i=buf.length()-1; i>=0; i--) {
|
|
if (buf.charAt(i) == '=') {
|
|
buf.deleteCharAt(i);
|
|
}
|
|
}
|
|
String tokenName = buf.toString();
|
|
Method method = (Method) commandMethods.get(tokenName);
|
|
if (method == null) {
|
|
try {
|
|
method = getClass().getMethod(tokenName, new Class[0]);
|
|
commandMethods.put(tokenName, method);
|
|
} catch (SecurityException e) {
|
|
e.printStackTrace();
|
|
return null;
|
|
} catch (NoSuchMethodException e) {
|
|
// FIXME: This is actually valid (during development anyway)
|
|
//e.printStackTrace();
|
|
return null;
|
|
}
|
|
}
|
|
return method;
|
|
}
|
|
|
|
protected void addAssembly(String label, String mnemonic, String parameter) {
|
|
if (label != null) {
|
|
sourceAssembly.append(label);
|
|
// sourceAssembly.append(":\n");
|
|
}
|
|
if (mnemonic != null) {
|
|
sourceAssembly.append(" "); //$NON-NLS-1$
|
|
sourceAssembly.append(mnemonic);
|
|
if (parameter != null) {
|
|
sourceAssembly.append(" "); //$NON-NLS-1$
|
|
sourceAssembly.append(parameter);
|
|
if (!usedAddresses.contains(parameter)
|
|
&& knownAddresses.containsKey(parameter)) {
|
|
usedAddresses.add(parameter);
|
|
}
|
|
}
|
|
sourceAssembly.append("\n"); //$NON-NLS-1$
|
|
}
|
|
}
|
|
|
|
public void evaluateHOME() {
|
|
addAssembly(null, "JSR", "HOME"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
public void evaluateTEXT() {
|
|
addAssembly(null, "JSR", "TEXT"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
public void evaluateRETURN() {
|
|
addAssembly(null, "RTS", null); //$NON-NLS-1$
|
|
}
|
|
|
|
public void evaluateEND() {
|
|
evaluateRETURN();
|
|
}
|
|
|
|
public void evaluateHGR() {
|
|
addAssembly(null, "JSR", "HGR"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
public void evaluateHGR2() {
|
|
addAssembly(null, "JSR", "HGR2"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
public void evaluateGR() {
|
|
addAssembly(null, "JSR", "GR"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
public void evaluateINVERSE() {
|
|
addAssembly(null, "LDA", "#$3F"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "STA", "INVFLAG"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
public void evaluateNORMAL() {
|
|
addAssembly(null, "LDA", "#$FF"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "STA", "INVFLAG"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
public void evaluateFLASH() {
|
|
addAssembly(null, "LDA", "#$7F"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "STA", "INVFLAG"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
protected Variable evaluateExpression() throws CompileException {
|
|
// FIXME: no type checking available
|
|
// FIXME: needs to evaluate all valid expressions
|
|
ApplesoftToken token = peekToken();
|
|
if (token.isEndOfCommand()) {
|
|
return null;
|
|
}
|
|
token = nextToken();
|
|
if (token.isString()) {
|
|
String value = token.getStringValue();
|
|
Variable variable = null;
|
|
for (int i=0; i<variables.size(); i++) {
|
|
variable = (Variable) variables.get(i);
|
|
if (value.equals(variable.getValue())) {
|
|
break;
|
|
}
|
|
variable = null;
|
|
}
|
|
if (variable == null) {
|
|
if (isIntegerNumber(value)) {
|
|
variable = new Variable("INT" + value, Variable.CONST_INTEGER, value); //$NON-NLS-1$
|
|
} else if (value.startsWith("\"")) { //$NON-NLS-1$
|
|
variable = new Variable("STR" + variables.size(), Variable.CONST_STRING, value); //$NON-NLS-1$
|
|
} else { // assume variable name
|
|
if (value.endsWith("$")) { //$NON-NLS-1$
|
|
variable = new Variable("VAR" + value, Variable.TYPE_STRING, value); //$NON-NLS-1$
|
|
} else if (value.endsWith("%") || isIntegerOnlyMath()) { //$NON-NLS-1$
|
|
variable = new Variable("VAR" + value, Variable.TYPE_INTEGER, value); //$NON-NLS-1$
|
|
} else {
|
|
variable = new Variable("VAR" + value, Variable.TYPE_FLOAT, value); //$NON-NLS-1$
|
|
}
|
|
}
|
|
variables.add(variable);
|
|
}
|
|
return variable;
|
|
}
|
|
throw new CompileException(textBundle.get("ApplesoftCompiler.UnableToEvaluateError")); //$NON-NLS-1$
|
|
}
|
|
|
|
protected Variable evaluateNumber() throws CompileException {
|
|
Variable variable = evaluateExpression();
|
|
if (variable.isNumber()) {
|
|
return variable;
|
|
}
|
|
throw new CompileException(textBundle.get("ApplesoftCompiler.NumberRequiredError")); //$NON-NLS-1$
|
|
}
|
|
|
|
/**
|
|
* Answer with the line number label. Used by GOTO and ON expr GOTO
|
|
* statements.
|
|
*/
|
|
protected String getLineNumberLabel() throws CompileException {
|
|
ApplesoftToken token = nextToken();
|
|
if (token.isString() && isIntegerNumber(token.getStringValue())) {
|
|
return "LINE" + token.getStringValue(); //$NON-NLS-1$
|
|
}
|
|
throw new CompileException(textBundle.
|
|
format("ApplesoftCompiler.ExpectingLineNumberError", //$NON-NLS-1$
|
|
token.toString()));
|
|
}
|
|
|
|
protected void addLoadByteValue(Variable variable, char register) throws CompileException {
|
|
if (variable.isConstantInteger()) {
|
|
addAssembly(null, "LD" + register, "#" + variable.getValue()); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else if(variable.isTypeInteger()) {
|
|
addAssembly(null, "LD" + register, variable.getName()); //$NON-NLS-1$
|
|
} else if (variable.isConstantFloat() || variable.isTypeFloat()) {
|
|
addAssembly(null, "LDY", "#>" + variable.getName()); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "LDA", "#<" + variable.getName()); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "JSR","MOVFM"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "JSR", "QINT"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "LD" + register, "FACLO"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else {
|
|
throw new CompileException(textBundle.
|
|
format("ApplesoftCompiler.InvalidByteFormatError", //$NON-NLS-1$
|
|
variable.getName()));
|
|
}
|
|
}
|
|
|
|
protected void addLoadWordValue(Variable variable, char registerHi, char registerLo) throws CompileException {
|
|
if (variable.isConstantInteger()) {
|
|
addAssembly(null, "LD" + registerHi, "#>" + variable.getValue()); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "LD" + registerLo, "#<" + variable.getValue()); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else if (variable.isTypeInteger()) {
|
|
addAssembly(null, "LD" + registerHi, variable.getName() + "+1"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "LD" + registerLo, variable.getName()); //$NON-NLS-1$
|
|
} else if (variable.isConstantFloat() || variable.isTypeFloat()) {
|
|
addLoadFac(variable);
|
|
addAssembly(null, "JSR", "QINT"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "LD" + registerHi, "FACMO"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "LD" + registerLo, "FACLO"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else {
|
|
throw new CompileException(textBundle.
|
|
format("ApplesoftCompiler.InvalidWordFormatError", //$NON-NLS-1$
|
|
variable.getName()));
|
|
}
|
|
}
|
|
|
|
protected void addLoadAddress(Variable variable, char registerHi, char registerLo) {
|
|
addAssembly(null, "LD" + registerHi, "#>" + variable.getName()); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "LD" + registerLo, "#<" + variable.getName()); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
protected void addLoadFac(Variable variable) throws CompileException {
|
|
if (variable.isConstantFloat() || variable.isTypeFloat()) {
|
|
addLoadAddress(variable, 'Y', 'A');
|
|
addAssembly(null, "JSR","MOVFM"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else if (variable.isConstantInteger() || variable.isTypeInteger()) {
|
|
addLoadWordValue(variable, 'A', 'Y');
|
|
addAssembly(null, "JSR", "GIVAYF"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else {
|
|
throw new CompileException(textBundle.
|
|
format("ApplesoftCompiler.InvalidFloatTypeError", //$NON-NLS-1$
|
|
variable.getName()));
|
|
}
|
|
}
|
|
|
|
protected void addCopyFac(Variable variable) throws CompileException {
|
|
if (variable.isTypeFloat()) {
|
|
addLoadAddress(variable, 'Y', 'X');
|
|
addAssembly(null, "JSR", "MOVMF"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else {
|
|
throw new CompileException(
|
|
textBundle.get("ApplesoftCompiler.CannotCopyToFloatError")); //$NON-NLS-1$
|
|
}
|
|
}
|
|
|
|
public void evaluateHTAB() throws CompileException {
|
|
addLoadByteValue(evaluateExpression(), 'A');
|
|
addAssembly(null, "STA", "CH"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
public void evaluateVTAB() throws CompileException {
|
|
addLoadByteValue(evaluateExpression(), 'X');
|
|
addAssembly(null, "DEX", null); //$NON-NLS-1$
|
|
addAssembly(null, "STX", "CV"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "JSR", "LF"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
public void evaluateHCOLOR() throws CompileException {
|
|
addLoadByteValue(evaluateExpression(), 'X');
|
|
addAssembly(null, "JSR", "SETHCOL"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
public void evaluatePRINT() throws CompileException {
|
|
ApplesoftToken token = null;
|
|
do {
|
|
Variable variable = evaluateExpression();
|
|
if (variable == null) {
|
|
addAssembly(null, "JSR", "PRCR"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else if (variable.isConstantFloat() || variable.isTypeFloat()) {
|
|
addLoadFac(variable);
|
|
addAssembly(null, "JSR", "PRNTFAC"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else if (variable.isConstantInteger() || variable.isTypeInteger()) {
|
|
addLoadWordValue(variable, 'X', 'A');
|
|
addAssembly(null, "JSR", "LINPRT"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else if (variable.isConstantString()) {
|
|
addLoadAddress(variable, 'Y', 'A');
|
|
addAssembly(null, "JSR", "STROUT"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} else if (variable.isTypeString()) {
|
|
throw new CompileException(textBundle.get("ApplesoftCompiler.StringPrintUnsupported")); //$NON-NLS-1$
|
|
}
|
|
// check if we have separators to skip over...
|
|
token = peekToken();
|
|
if (token != null && token.isExpressionSeparator()) {
|
|
nextToken();
|
|
}
|
|
// see if we should continue processing the print statement
|
|
token = peekToken();
|
|
} while (token != null && !token.isEndOfCommand());
|
|
}
|
|
|
|
public void evaluateGOTO() throws CompileException {
|
|
addAssembly(null, "JMP", getLineNumberLabel()); //$NON-NLS-1$
|
|
}
|
|
|
|
protected void checkSyntax(byte tokenValue, String expectedToken) throws CompileException {
|
|
ApplesoftToken token = nextToken();
|
|
if (token.getTokenValue() != tokenValue) {
|
|
// FIXME: Should this read token from master token list?
|
|
throw new CompileException(textBundle.
|
|
format("ApplesoftCompiler.SyntaxError", expectedToken)); //$NON-NLS-1$
|
|
}
|
|
}
|
|
|
|
protected void checkSyntax(String stringValue, String expectedToken) throws CompileException {
|
|
ApplesoftToken token = nextToken();
|
|
if (!stringValue.equals(token.getStringValue())) {
|
|
// FIXME: Should this read token from master token list?
|
|
throw new CompileException(textBundle.
|
|
format("ApplesoftCompiler.SyntaxError", expectedToken)); //$NON-NLS-1$
|
|
}
|
|
}
|
|
|
|
public void evaluateFOR() throws CompileException {
|
|
Variable loopVariable = evaluateExpression();
|
|
if (!loopVariable.isTypeFloat() && !loopVariable.isTypeInteger()) {
|
|
throw new CompileException(
|
|
textBundle.get("ApplesoftCompiler.ForStatementUnsupportedTypeError")); //$NON-NLS-1$
|
|
}
|
|
checkSyntax(EQUALS, "="); //$NON-NLS-1$
|
|
Variable startValue = evaluateNumber();
|
|
checkSyntax(TO, "TO"); //$NON-NLS-1$
|
|
Variable endValue = evaluateNumber();
|
|
// FIXME: Need to handle STEP
|
|
String loopName = "FOR" + loopVariables.size(); //$NON-NLS-1$
|
|
loopVariables.add(loopName);
|
|
addLoadFac(startValue);
|
|
addCopyFac(loopVariable);
|
|
addAssembly(loopName, null, null);
|
|
addLoadFac(endValue);
|
|
addLoadAddress(loopVariable, 'Y', 'A');
|
|
addAssembly(null, "JSR", "FCOMP"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "CMP", "#$FF"); // loopVariable > endValue //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "BEQ", "END" + loopName); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
|
|
public void evaluateHPLOT() throws CompileException {
|
|
boolean firstCoordinate = true;
|
|
while (peekToken() != null && !peekToken().isEndOfCommand()) {
|
|
if (!firstCoordinate) {
|
|
checkSyntax(TO, "TO"); //$NON-NLS-1$
|
|
}
|
|
Variable coordX = evaluateNumber();
|
|
checkSyntax(",", ", (comma)"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
Variable coordY = evaluateNumber();
|
|
if (firstCoordinate) {
|
|
addLoadWordValue(coordX, 'Y', 'X');
|
|
addLoadByteValue(coordY, 'A');
|
|
addAssembly(null, "JSR", "HPOSN"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
firstCoordinate = false;
|
|
} else {
|
|
addLoadWordValue(coordX, 'X', 'A');
|
|
addLoadByteValue(coordY, 'Y');
|
|
addAssembly(null, "JSR", "HLIN"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
}
|
|
}
|
|
}
|
|
|
|
public void evaluateNEXT() throws CompileException {
|
|
// FIXME: Next requires variable name given...
|
|
Variable variable = null;
|
|
if (!peekToken().isCommandSeparator()) {
|
|
// FIXME: This does not ensure that we only have a variable!
|
|
variable = evaluateExpression();
|
|
}
|
|
if (variable.isTypeFloat()) {
|
|
addAssembly(null, "LDY", "#1"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "JSR", "SNGFLT"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addLoadAddress(variable, 'Y', 'A');
|
|
addAssembly(null, "JSR", "FADD"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addCopyFac(variable);
|
|
} else if (variable.isTypeInteger()) {
|
|
addAssembly(null, "INC", variable.getName()); //$NON-NLS-1$
|
|
addAssembly(null, "BNE", ":1"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(null, "INC", variable.getName() + "+1"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
addAssembly(":1", null, null); //$NON-NLS-1$
|
|
}
|
|
String loopName = (String) loopVariables.pop();
|
|
addAssembly(null, "JMP", loopName); //$NON-NLS-1$
|
|
addAssembly("END" + loopName, null, null); //$NON-NLS-1$
|
|
}
|
|
|
|
/**
|
|
* Indicates if this string is a number.
|
|
*/
|
|
protected boolean isIntegerNumber(String value) {
|
|
for (int i=0; i<value.length(); i++) {
|
|
if (!Character.isDigit(value.charAt(i))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Indicates integer math only.
|
|
*/
|
|
public boolean isIntegerOnlyMath() {
|
|
return integerOnlyMath;
|
|
}
|
|
|
|
/**
|
|
* Sets integer only math.
|
|
*/
|
|
public void setIntegerOnlyMath(boolean integerOnlyMath) {
|
|
this.integerOnlyMath = integerOnlyMath;
|
|
}
|
|
}
|