6502/kickc
1
0
Fork 0
mirror of https://gitlab.com/camelot/kickc.git synced 2025-04-09 21:37:31 +00:00
Code Issues Projects Releases Wiki Activity

Eliminating SymbolTypeMulti - 274/351

Browse Source
This commit is contained in:
jespergravgaard 2019-05-12 14:42:41 +02:00
parent 7767c1216b
commit 07b67efb7c
18 changed files with 79 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/main/java/dk/camelot64/kickc/fragment/AsmFormat.java
View File

@ -10,8 +10,6 @@ import dk.camelot64.kickc.model.symbols.Variable;
import dk.camelot64.kickc.model.types.*;
import dk.camelot64.kickc.model.values.*;
import java.util.List;
/** Formatting of numbers, constants, names and more for KickAssembler */
public class AsmFormat {
@ -165,22 +163,22 @@ public class AsmFormat {
return getAsmConstant(program, new ConstantBinary(new ConstantInteger((long) 0xffffffffL), Operators.BOOL_AND, operand), outerPrecedence, codeScope);
} else if(Operators.LOWBYTE.equals(operator)) {
SymbolType operandType = SymbolTypeInference.inferType(program.getScope(), operand);
if(SymbolType.isByte(operandType) || SymbolType.isSByte(operandType)) {
if(SymbolType.BYTE.equals(operandType) || SymbolType.SBYTE.equals(operandType)) {
return getAsmConstant(program, operand, outerPrecedence, codeScope);
} else if(SymbolType.isWord(operandType) || SymbolType.isSWord(operandType) || operandType instanceof SymbolTypePointer || SymbolType.STRING.equals(operandType)) {
} else if(SymbolType.WORD.equals(operandType) || SymbolType.SWORD.equals(operandType) || operandType instanceof SymbolTypePointer || SymbolType.STRING.equals(operandType)) {
return "<" + getAsmConstant(program, operand, outerPrecedence, codeScope);
} else if(SymbolType.isDWord(operandType) || SymbolType.isSDWord(operandType)) {
} else if(SymbolType.DWORD.equals(operandType) || SymbolType.SDWORD.equals(operandType)) {
return getAsmConstant(program, new ConstantBinary(operand, Operators.BOOL_AND, new ConstantInteger((long) 0xffff)), outerPrecedence, codeScope);
} else {
throw new CompileError("Unhandled type " + operand);
}
} else if(Operators.HIBYTE.equals(operator)) {
SymbolType operandType = SymbolTypeInference.inferType(program.getScope(), operand);
if(SymbolType.isByte(operandType) || SymbolType.isSByte(operandType)) {
if(SymbolType.BYTE.equals(operandType) || SymbolType.SBYTE.equals(operandType)) {
return getAsmConstant(program, new ConstantInteger(0l), outerPrecedence, codeScope);
} else if(SymbolType.isWord(operandType) || SymbolType.isSWord(operandType) || operandType instanceof SymbolTypePointer || SymbolType.STRING.equals(operandType)) {
} else if(SymbolType.WORD.equals(operandType) || SymbolType.SWORD.equals(operandType) || operandType instanceof SymbolTypePointer || SymbolType.STRING.equals(operandType)) {
return ">" + getAsmConstant(program, operand, outerPrecedence, codeScope);
} else if(SymbolType.isDWord(operandType) || SymbolType.isSDWord(operandType)) {
} else if(SymbolType.DWORD.equals(operandType) || SymbolType.SDWORD.equals(operandType)) {
return getAsmConstant(program, new ConstantBinary(operand, Operators.SHIFT_RIGHT, new ConstantInteger((long) 16)), outerPrecedence, codeScope);
} else {
throw new CompileError("Unhandled type " + operand);
@ -191,11 +189,11 @@ public class AsmFormat {
return getAsmConstant(program, new ConstantBinary(operand, Operators.MINUS, new ConstantInteger((long) 1)), outerPrecedence, codeScope);
} else if(Operators.BOOL_NOT.equals(operator)) {
SymbolType operandType = SymbolTypeInference.inferType(program.getScope(), operand);
if(SymbolType.isByte(operandType) || SymbolType.isSByte(operandType)) {
if(SymbolType.BYTE.equals(operandType) || SymbolType.SBYTE.equals(operandType)) {
return getAsmConstant(program, new ConstantBinary(operand, Operators.BOOL_XOR, new ConstantInteger((long) 0xff)), outerPrecedence, codeScope);
} else if(SymbolType.isWord(operandType) || SymbolType.isSWord(operandType) || operandType instanceof SymbolTypePointer || SymbolType.STRING.equals(operandType)) {
} else if(SymbolType.WORD.equals(operandType) || SymbolType.SWORD.equals(operandType) || operandType instanceof SymbolTypePointer || SymbolType.STRING.equals(operandType)) {
return getAsmConstant(program, new ConstantBinary(operand, Operators.BOOL_XOR, new ConstantInteger((long) 0xffff)), outerPrecedence, codeScope);
} else if(SymbolType.isDWord(operandType) || SymbolType.isSDWord(operandType)) {
} else if(SymbolType.DWORD.equals(operandType) || SymbolType.SDWORD.equals(operandType)) {
return getAsmConstant(program, new ConstantBinary(operand, Operators.BOOL_XOR, new ConstantInteger((long) 0xffffffff)), outerPrecedence, codeScope);
} else {
throw new CompileError("Unhandled type " + operand);

2
src/main/java/dk/camelot64/kickc/fragment/AsmFragmentInstance.java
View File

@ -301,7 +301,7 @@ public class AsmFragmentInstance {
public AsmParameter visitAsmExprInt(KickCParser.AsmExprIntContext ctx) {
Number number = NumberParser.parseLiteral(ctx.NUMBER().getText());
ConstantInteger intVal = new ConstantInteger(number.longValue());
boolean isZp = SymbolType.isByte(intVal.getType()) || SymbolType.isSByte(intVal.getType());
boolean isZp = SymbolType.BYTE.equals(intVal.getType()) || SymbolType.SBYTE.equals(intVal.getType());
String param = AsmFormat.getAsmNumber(number);
return new AsmParameter(param, isZp);
}

24
src/main/java/dk/camelot64/kickc/fragment/AsmFragmentInstanceSpecFactory.java
View File

@ -288,17 +288,17 @@ public class AsmFragmentInstanceSpecFactory {
* @return The type name
*/
static String getTypePrefix(SymbolType type) {
if(SymbolType.isByte(type)) {
if(SymbolType.BYTE.equals(type)) {
return "vbu";
} else if(SymbolType.isSByte(type)) {
} else if(SymbolType.SBYTE.equals(type)) {
return "vbs";
} else if(SymbolType.isWord(type)) {
} else if(SymbolType.WORD.equals(type)) {
return "vwu";
} else if(SymbolType.isSWord(type)) {
} else if(SymbolType.SWORD.equals(type)) {
return "vws";
} else if(SymbolType.isDWord(type)) {
} else if(SymbolType.DWORD.equals(type)) {
return "vdu";
} else if(SymbolType.isSDWord(type)) {
} else if(SymbolType.SDWORD.equals(type)) {
return "vds";
} else if(SymbolType.STRING.equals(type)) {
return "pbu";
@ -306,17 +306,17 @@ public class AsmFragmentInstanceSpecFactory {
return "vbo";
} else if(type instanceof SymbolTypePointer) {
SymbolType elementType = ((SymbolTypePointer) type).getElementType();
if(SymbolType.isByte(elementType)) {
if(SymbolType.BYTE.equals(elementType)) {
return "pbu";
} else if(SymbolType.isSByte(elementType)) {
} else if(SymbolType.SBYTE.equals(elementType)) {
return "pbs";
} else if(SymbolType.isWord(elementType)) {
} else if(SymbolType.WORD.equals(elementType)) {
return "pwu";
} else if(SymbolType.isSWord(elementType)) {
} else if(SymbolType.SWORD.equals(elementType)) {
return "pws";
} else if(SymbolType.isDWord(elementType)) {
} else if(SymbolType.DWORD.equals(elementType)) {
return "pdu";
} else if(SymbolType.isSDWord(elementType)) {
} else if(SymbolType.SDWORD.equals(elementType)) {
return "pds";
} else if(SymbolType.BOOLEAN.equals(elementType)) {
return "pbo";

6
src/main/java/dk/camelot64/kickc/model/operators/OperatorDWord.java
View File

@ -32,13 +32,13 @@ public class OperatorDWord extends OperatorBinary {
if(right instanceof SymbolTypePointer) {
right = SymbolType.WORD;
}
if(SymbolType.isByte(left)) {
if(SymbolType.BYTE.equals(left)) {
left = SymbolType.WORD;
}
if(SymbolType.isByte(right)) {
if(SymbolType.BYTE.equals(right)) {
right = SymbolType.WORD;
}
if(SymbolType.isWord(left) && SymbolType.isWord(right)) {
if(SymbolType.WORD.equals(left) && SymbolType.WORD.equals(right)) {
return SymbolType.DWORD;
}
throw new NoMatchingType("DWord constructor cannot use " + left + " " + getOperator() + " " + right);

8
src/main/java/dk/camelot64/kickc/model/operators/OperatorGetHigh.java
View File

@ -22,9 +22,9 @@ public class OperatorGetHigh extends OperatorUnary {
public ConstantLiteral calculateLiteral(ConstantLiteral operand, ProgramScope scope) {
if(operand instanceof ConstantInteger) {
ConstantInteger operandInt = (ConstantInteger) operand;
if(SymbolType.isWord(operandInt.getType()) || SymbolType.isSWord(operandInt.getType())) {
if(SymbolType.WORD.equals(operandInt.getType()) || SymbolType.SWORD.equals(operandInt.getType())) {
return new ConstantInteger(operandInt.getInteger()>>8);
} else if(SymbolType.isDWord(operandInt.getType()) || SymbolType.isSDWord(operandInt.getType())) {
} else if(SymbolType.DWORD.equals(operandInt.getType()) || SymbolType.SDWORD.equals(operandInt.getType())) {
return new ConstantInteger(operandInt.getInteger()>>16);
}
} else if(operand instanceof ConstantPointer) {
@ -37,9 +37,9 @@ public class OperatorGetHigh extends OperatorUnary {
@Override
public SymbolType inferType(SymbolTypeSimple operandType) {
if(operandType instanceof SymbolTypePointer || SymbolType.isWord(operandType) || SymbolType.isSWord(operandType)) {
if(operandType instanceof SymbolTypePointer || SymbolType.WORD.equals(operandType) || SymbolType.SWORD.equals(operandType)) {
return SymbolType.BYTE;
} else if(SymbolType.isDWord(operandType) || SymbolType.isSDWord(operandType)) {
} else if(SymbolType.DWORD.equals(operandType) || SymbolType.SDWORD.equals(operandType)) {
return SymbolType.WORD;
} else if(SymbolType.STRING.equals(operandType)) {
return SymbolType.BYTE;

8
src/main/java/dk/camelot64/kickc/model/operators/OperatorGetLow.java
View File

@ -22,9 +22,9 @@ public class OperatorGetLow extends OperatorUnary {
public ConstantLiteral calculateLiteral(ConstantLiteral operand, ProgramScope scope) {
if(operand instanceof ConstantInteger) {
ConstantInteger operandInt = (ConstantInteger) operand;
if(SymbolType.isWord(operandInt.getType()) || SymbolType.isSWord(operandInt.getType())) {
if(SymbolType.WORD.equals(operandInt.getType()) || SymbolType.SWORD.equals(operandInt.getType())) {
return new ConstantInteger(operandInt.getInteger()&0xff);
} else if(SymbolType.isDWord(operandInt.getType()) || SymbolType.isSDWord(operandInt.getType())) {
} else if(SymbolType.DWORD.equals(operandInt.getType()) || SymbolType.SDWORD.equals(operandInt.getType())) {
return new ConstantInteger(operandInt.getInteger()&0xffff);
}
} else if(operand instanceof ConstantPointer) {
@ -37,9 +37,9 @@ public class OperatorGetLow extends OperatorUnary {
@Override
public SymbolType inferType(SymbolTypeSimple operandType) {
if(operandType instanceof SymbolTypePointer || SymbolType.isWord(operandType) || SymbolType.isSWord(operandType)) {
if(operandType instanceof SymbolTypePointer || SymbolType.WORD.equals(operandType) || SymbolType.SWORD.equals(operandType)) {
return SymbolType.BYTE;
} else if(SymbolType.isDWord(operandType) || SymbolType.isSDWord(operandType)) {
} else if(SymbolType.DWORD.equals(operandType) || SymbolType.SDWORD.equals(operandType)) {
return SymbolType.WORD;
} else if(SymbolType.STRING.equals(operandType)) {
return SymbolType.BYTE;

6
src/main/java/dk/camelot64/kickc/model/operators/OperatorPlus.java
View File

@ -23,7 +23,7 @@ public class OperatorPlus extends OperatorBinary {
return new ConstantString(((ConstantString) left).getString() + ((ConstantString) right).getString());
} else if(left instanceof ConstantString && right instanceof ConstantChar) {
return new ConstantString(((ConstantString) left).getString() + ((ConstantChar) right).getChar());
} else if(left instanceof ConstantString && right instanceof ConstantInteger && SymbolType.isByte(((ConstantInteger) right).getType())) {
} else if(left instanceof ConstantString && right instanceof ConstantInteger && SymbolType.BYTE.equals(((ConstantInteger) right).getType())) {
Character character = (char) ((ConstantInteger) right).getInteger().byteValue();
return new ConstantString(((ConstantString) left).getString() + character);
} else if(left instanceof ConstantPointer && right instanceof ConstantInteger) {
@ -62,9 +62,9 @@ public class OperatorPlus extends OperatorBinary {
private boolean isStringLike(SymbolTypeSimple type) {
if(SymbolType.STRING.equals(type)) {
return true;
} else if(SymbolType.isByte(type)) {
} else if(SymbolType.BYTE.equals(type)) {
return true;
} else if(type instanceof SymbolTypeArray && SymbolType.isByte(((SymbolTypeArray) type).getElementType())) {
} else if(type instanceof SymbolTypeArray && SymbolType.BYTE.equals(((SymbolTypeArray) type).getElementType())) {
return true;
}
return false;

12
src/main/java/dk/camelot64/kickc/model/operators/OperatorSetHigh.java
View File

@ -22,17 +22,17 @@ public class OperatorSetHigh extends OperatorBinary {
public SymbolType inferType(SymbolTypeSimple left, SymbolTypeSimple right) {
if(left instanceof SymbolTypePointer) {
return left;
} else if(SymbolType.isByte(left)) {
} else if(SymbolType.BYTE.equals(left)) {
return SymbolType.WORD;
} else if(SymbolType.isSByte(left)) {
} else if(SymbolType.SBYTE.equals(left)) {
return SymbolType.WORD;
} else if(SymbolType.isWord(left)) {
} else if(SymbolType.WORD.equals(left)) {
return SymbolType.WORD;
} else if(SymbolType.isSWord(left)) {
} else if(SymbolType.SWORD.equals(left)) {
return SymbolType.SWORD;
} else if(SymbolType.isDWord(left)) {
} else if(SymbolType.DWORD.equals(left)) {
return SymbolType.DWORD;
} else if(SymbolType.isSDWord(left)) {
} else if(SymbolType.SDWORD.equals(left)) {
return SymbolType.SDWORD;
}
throw new RuntimeException("Type inference case not handled " + left + " " + getOperator() + " " + right);

8
src/main/java/dk/camelot64/kickc/model/operators/OperatorSetLow.java
View File

@ -23,13 +23,13 @@ public class OperatorSetLow extends OperatorBinary {
if(left instanceof SymbolTypePointer) {
return left;
}
if(SymbolType.isWord(left)) {
if(SymbolType.WORD.equals(left)) {
return SymbolType.WORD;
} else if(SymbolType.isSWord(left)) {
} else if(SymbolType.SWORD.equals(left)) {
return SymbolType.SWORD;
} else if(SymbolType.isDWord(left)) {
} else if(SymbolType.DWORD.equals(left)) {
return SymbolType.DWORD;
} else if(SymbolType.isSDWord(left)) {
} else if(SymbolType.SDWORD.equals(left)) {
return SymbolType.SDWORD;
}
throw new RuntimeException("Type inference case not handled " + left + " " + getOperator() + " " + right);

15
src/main/java/dk/camelot64/kickc/model/operators/OperatorSizeOf.java
View File

@ -3,7 +3,6 @@ package dk.camelot64.kickc.model.operators;
import dk.camelot64.kickc.model.symbols.ConstantVar;
import dk.camelot64.kickc.model.symbols.ProgramScope;
import dk.camelot64.kickc.model.types.SymbolType;
import dk.camelot64.kickc.model.types.SymbolTypeMulti;
import dk.camelot64.kickc.model.types.SymbolTypePointer;
import dk.camelot64.kickc.model.types.SymbolTypeSimple;
import dk.camelot64.kickc.model.values.ConstantInteger;
@ -20,7 +19,7 @@ public class OperatorSizeOf extends OperatorUnary {
@Override
public ConstantLiteral calculateLiteral(ConstantLiteral operand, ProgramScope scope) {
SymbolType type = operand.getType(scope);
return new ConstantInteger((long)type.getSizeBytes());
return new ConstantInteger((long) type.getSizeBytes());
}
@Override
@ -30,6 +29,7 @@ public class OperatorSizeOf extends OperatorUnary {
/**
* Get the constant variable containing the size of a specific type
*
* @param programScope The program scope (used for finding/adding the constant).
* @param type The type to get the variable for
* @return The constant variable
@ -37,7 +37,7 @@ public class OperatorSizeOf extends OperatorUnary {
public static ConstantRef getSizeOfConstantVar(ProgramScope programScope, SymbolType type) {
String typeConstName = getSizeofConstantName(type);
ConstantVar typeSizeConstant = programScope.getConstant(typeConstName);
if(typeSizeConstant ==null) {
if(typeSizeConstant == null) {
// Constant not found - create it
long typeSize = type.getSizeBytes();
typeSizeConstant = new ConstantVar(typeConstName, programScope, SymbolType.BYTE, new ConstantInteger(typeSize));
@ -48,18 +48,15 @@ public class OperatorSizeOf extends OperatorUnary {
/**
* Get the name of the constant variable containing the size of a specific type
*
* @param type The type to get the variable for
* @return The name of the constant
*/
public static String getSizeofConstantName(SymbolType type) {
if(type instanceof SymbolTypeMulti) {
// Grab the first sub-type. It will be the smallest
SymbolType subType = OperatorTypeId.getSubTypeToUse((SymbolTypeMulti) type);
return getSizeofConstantName(subType);
} else if(type instanceof SymbolTypePointer) {
if(type instanceof SymbolTypePointer) {
return "SIZEOF_POINTER";
} else {
return "SIZEOF_"+type.getTypeName().toUpperCase().replace(" ", "_");
return "SIZEOF_" + type.getTypeName().toUpperCase().replace(" ", "_");
}
}

36
src/main/java/dk/camelot64/kickc/model/operators/OperatorTypeId.java
View File

@ -36,7 +36,7 @@ public class OperatorTypeId extends OperatorUnary {
* @return The constant variable
*/
public static ConstantRef getTypeIdConstantVar(ProgramScope programScope, SymbolType type) {
String typeConstName = "TYPEID_"+getTypeIdConstantName(type);
String typeConstName = "TYPEID_" + getTypeIdConstantName(type);
ConstantVar typeIdConstant = programScope.getConstant(typeConstName);
if(typeIdConstant == null) {
// Constant not found - create it
@ -54,15 +54,7 @@ public class OperatorTypeId extends OperatorUnary {
* @return The name of the constant
*/
private static String getTypeIdConstantName(SymbolType type) {
if(type instanceof SymbolTypeMulti) {
// Grab the first sub-type. It will be the smallest
SymbolType subType = getSubTypeToUse((SymbolTypeMulti) type);
if(subType==null) {
return "VOID";
} else {
return getTypeIdConstantName(subType);
}
} else if(type instanceof SymbolTypeProcedure) {
if(type instanceof SymbolTypeProcedure) {
return "PROCEDURE";
} else if(type instanceof SymbolTypePointer) {
return "POINTER_" + getTypeIdConstantName(((SymbolTypePointer) type).getElementType());
@ -113,33 +105,9 @@ public class OperatorTypeId extends OperatorUnary {
return 0x0f;
} else if(type instanceof SymbolTypePointer) {
return 0x10 + getTypeId(((SymbolTypePointer) type).getElementType());
} else if(type instanceof SymbolTypeMulti) {
// Return the smallest type ID
SymbolType useType = getSubTypeToUse((SymbolTypeMulti) type);
if(useType==null) return 0;
return getTypeId(useType);
} else {
return 0;
}
}
/**
* Find the sub-type to use for typeid()
* @param type The multi type
* @return The sub-type to use
*/
public static SymbolType getSubTypeToUse(SymbolTypeMulti type) {
SymbolType useType = null;
Integer useID = null;
for(SymbolType subType : type.getTypes()) {
int subId = getTypeId(subType);
if(useType==null || subId < useID) {
useType = subType;
useID = subId;
}
}
return useType;
}
}

3
src/main/java/dk/camelot64/kickc/model/operators/OperatorWord.java
View File

@ -3,7 +3,6 @@ package dk.camelot64.kickc.model.operators;
import dk.camelot64.kickc.model.CompileError;
import dk.camelot64.kickc.model.types.NoMatchingType;
import dk.camelot64.kickc.model.types.SymbolType;
import dk.camelot64.kickc.model.types.SymbolTypePointer;
import dk.camelot64.kickc.model.types.SymbolTypeSimple;
import dk.camelot64.kickc.model.values.ConstantInteger;
import dk.camelot64.kickc.model.values.ConstantLiteral;
@ -25,7 +24,7 @@ public class OperatorWord extends OperatorBinary {
@Override
public SymbolType inferType(SymbolTypeSimple left, SymbolTypeSimple right) {
if(SymbolType.isByte(left) && SymbolType.isByte(right)) {
if(SymbolType.BYTE.equals(left) && SymbolType.BYTE.equals(right)) {
return SymbolType.WORD;
}
throw new NoMatchingType("Word constructor cannot use " + left + " " + getOperator() + " " + right);

60
src/main/java/dk/camelot64/kickc/model/types/SymbolType.java
View File

@ -106,66 +106,6 @@ public interface SymbolType {
*/
int getSizeBytes();
/**
* Is the type {@link #BYTE} or compatible {@link SymbolTypeMulti}
*
* @param type The type to examine
* @return true if the type is BYTE compatible
*/
static boolean isByte(SymbolType type) {
return BYTE.equals(type);
}
/**
* Is the type {@link #SBYTE} or compatible {@link SymbolTypeMulti}
*
* @param type The type to examine
* @return true if the type is SBYTE compatible
*/
static boolean isSByte(SymbolType type) {
return SBYTE.equals(type);
}
/**
* Is the type {@link #WORD} or compatible {@link SymbolTypeMulti}
*
* @param type The type to examine
* @return true if the type is WORD compatible
*/
static boolean isWord(SymbolType type) {
return WORD.equals(type);
}
/**
* Is the type {@link #SWORD} or compatible {@link SymbolTypeMulti}
*
* @param type The type to examine
* @return true if the type is SWORD compatible
*/
static boolean isSWord(SymbolType type) {
return SWORD.equals(type);
}
/**
* Is the type {@link #DWORD} or compatible {@link SymbolTypeMulti}
*
* @param type The type to examine
* @return true if the type is DWORD compatible
*/
static boolean isDWord(SymbolType type) {
return DWORD.equals(type);
}
/**
* Is the type {@link #SDWORD} or compatible {@link SymbolTypeMulti}
*
* @param type The type to examine
* @return true if the type is SDWORD compatible
*/
static boolean isSDWord(SymbolType type) {
return SDWORD.equals(type);
}
/**
* Is the type an integer type (including {@link #NUMBER})
*

4
src/main/java/dk/camelot64/kickc/model/types/SymbolTypeInference.java
View File

@ -148,13 +148,13 @@ public class SymbolTypeInference {
}
}
if(elmType != null) {
if((list.getList().size() == 2 && SymbolType.isByte(elmType) || SymbolType.isSByte(elmType))) {
if((list.getList().size() == 2 && SymbolType.BYTE.equals(elmType) || SymbolType.SBYTE.equals(elmType))) {
// Potentially a word constructor - return a composite type
ArrayList<SymbolType> types = new ArrayList<>();
types.add(new SymbolTypeArray(elmType));
types.add(SymbolType.WORD);
return new SymbolTypeMulti(types);
} else if((list.getList().size() == 2 && SymbolType.isWord(elmType))) {
} else if((list.getList().size() == 2 && SymbolType.WORD.equals(elmType))) {
// Potentially a dword constructor - return a composite type
ArrayList<SymbolType> types = new ArrayList<>();
types.add(new SymbolTypeArray(elmType));

4
src/main/java/dk/camelot64/kickc/passes/Pass2FixInlineConstructors.java
View File

@ -49,7 +49,7 @@ public class Pass2FixInlineConstructors extends Pass2SsaOptimization {
@Override
protected boolean isSubType(SymbolType elmType) {
return SymbolType.isByte(elmType);
return SymbolType.BYTE.equals(elmType);
}
}
@ -62,7 +62,7 @@ public class Pass2FixInlineConstructors extends Pass2SsaOptimization {
@Override
protected boolean isSubType(SymbolType elmType) {
return SymbolType.isWord(elmType);
return SymbolType.WORD.equals(elmType);
}
}

10
src/main/java/dk/camelot64/kickc/passes/Pass2NopCastElimination.java
View File

@ -40,19 +40,19 @@ public class Pass2NopCastElimination extends Pass2SsaOptimization {
SymbolType rValType = SymbolTypeInference.inferType(getScope(), assignment.getrValue2());
boolean isNopCast = false;
SymbolType toType = null;
if(SymbolType.isByte(rValType) && Operators.CAST_SBYTE.equals(assignment.getOperator())) {
if(SymbolType.BYTE.equals(rValType) && Operators.CAST_SBYTE.equals(assignment.getOperator())) {
isNopCast = true;
toType = SymbolType.SBYTE;
} else if(SymbolType.isSByte(rValType) && Operators.CAST_BYTE.equals(assignment.getOperator())) {
} else if(SymbolType.SBYTE.equals(rValType) && Operators.CAST_BYTE.equals(assignment.getOperator())) {
isNopCast = true;
toType = SymbolType.BYTE;
} else if(SymbolType.isWord(rValType) && Operators.CAST_SWORD.equals(assignment.getOperator())) {
} else if(SymbolType.WORD.equals(rValType) && Operators.CAST_SWORD.equals(assignment.getOperator())) {
isNopCast = true;
toType = SymbolType.SWORD;
} else if(SymbolType.isSWord(rValType) && Operators.CAST_WORD.equals(assignment.getOperator())) {
} else if(SymbolType.SWORD.equals(rValType) && Operators.CAST_WORD.equals(assignment.getOperator())) {
isNopCast = true;
toType = SymbolType.WORD;
} else if(SymbolType.isWord(rValType) && assignment.getOperator() instanceof OperatorCastPtr) {
} else if(SymbolType.WORD.equals(rValType) && assignment.getOperator() instanceof OperatorCastPtr) {
isNopCast = true;
OperatorCastPtr castOperator = (OperatorCastPtr) (assignment.getOperator());
toType = new SymbolTypePointer(castOperator.getElementType());

18
src/main/java/dk/camelot64/kickc/passes/Pass4CodeGeneration.java
View File

@ -387,13 +387,13 @@ public class Pass4CodeGeneration {
String asmElement = AsmFormat.getAsmConstant(program, element, 99, scopeRef);
asmElements.add(asmElement);
}
if(SymbolType.isByte(elementType) || SymbolType.isSByte(elementType)) {
if(SymbolType.BYTE.equals(elementType) || SymbolType.SBYTE.equals(elementType)) {
asm.addDataNumeric(asmName.replace("#", "_").replace("$", "_"), AsmDataNumeric.Type.BYTE, asmElements);
added.add(asmName);
} else if(SymbolType.isWord(elementType) || SymbolType.isSWord(elementType)) {
} else if(SymbolType.WORD.equals(elementType) || SymbolType.SWORD.equals(elementType)) {
asm.addDataNumeric(asmName.replace("#", "_").replace("$", "_"), AsmDataNumeric.Type.WORD, asmElements);
added.add(asmName);
} else if(SymbolType.isDWord(elementType) || SymbolType.isSDWord(elementType)) {
} else if(SymbolType.DWORD.equals(elementType) || SymbolType.SDWORD.equals(elementType)) {
asm.addDataNumeric(asmName.replace("#", "_").replace("$", "_"), AsmDataNumeric.Type.DWORD, asmElements);
added.add(asmName);
} else if(elementType instanceof SymbolTypePointer) {
@ -410,27 +410,27 @@ public class Pass4CodeGeneration {
throw new Pass2SsaAssertion.AssertionFailed("Error! Array size is not constant integer " + constantVar.toString(program));
}
int size = ((ConstantInteger) arraySizeConst).getInteger().intValue();
if(SymbolType.isByte(constantArrayFilled.getElementType())) {
if(SymbolType.BYTE.equals(constantArrayFilled.getElementType())) {
String asmSize = AsmFormat.getAsmConstant(program, arraySize, 99, scopeRef);
asm.addDataFilled(asmName.replace("#", "_").replace("$", "_"), AsmDataNumeric.Type.BYTE, asmSize, size, "0");
added.add(asmName);
} else if(SymbolType.isSByte(constantArrayFilled.getElementType())) {
} else if(SymbolType.SBYTE.equals(constantArrayFilled.getElementType())) {
String asmSize = AsmFormat.getAsmConstant(program, arraySize, 99, scopeRef);
asm.addDataFilled(asmName.replace("#", "_").replace("$", "_"), AsmDataNumeric.Type.BYTE, asmSize, size, "0");
added.add(asmName);
} else if(SymbolType.isWord(constantArrayFilled.getElementType())) {
} else if(SymbolType.WORD.equals(constantArrayFilled.getElementType())) {
String asmSize = AsmFormat.getAsmConstant(program, new ConstantBinary(new ConstantInteger(2L), Operators.MULTIPLY, arraySize), 99, scopeRef);
asm.addDataFilled(asmName.replace("#", "_").replace("$", "_"), AsmDataNumeric.Type.WORD, asmSize, size, "0");
added.add(asmName);
} else if(SymbolType.isSWord(constantArrayFilled.getElementType())) {
} else if(SymbolType.SWORD.equals(constantArrayFilled.getElementType())) {
String asmSize = AsmFormat.getAsmConstant(program, new ConstantBinary(new ConstantInteger(2L), Operators.MULTIPLY, arraySize), 99, scopeRef);
asm.addDataFilled(asmName.replace("#", "_").replace("$", "_"), AsmDataNumeric.Type.WORD, asmSize, size, "0");
added.add(asmName);
} else if(SymbolType.isDWord(constantArrayFilled.getElementType())) {
} else if(SymbolType.DWORD.equals(constantArrayFilled.getElementType())) {
String asmSize = AsmFormat.getAsmConstant(program, new ConstantBinary(new ConstantInteger(4L), Operators.MULTIPLY, arraySize), 99, scopeRef);
asm.addDataFilled(asmName.replace("#", "_").replace("$", "_"), AsmDataNumeric.Type.DWORD, asmSize, size, "0");
added.add(asmName);
} else if(SymbolType.isSDWord(constantArrayFilled.getElementType())) {
} else if(SymbolType.SDWORD.equals(constantArrayFilled.getElementType())) {
String asmSize = AsmFormat.getAsmConstant(program, new ConstantBinary(new ConstantInteger(4L), Operators.MULTIPLY, arraySize), 99, scopeRef);
asm.addDataFilled(asmName.replace("#", "_").replace("$", "_"), AsmDataNumeric.Type.DWORD, asmSize, size, "0");
added.add(asmName);

12
src/main/java/dk/camelot64/kickc/passes/Pass4RegistersFinalize.java
View File

@ -195,23 +195,23 @@ public class Pass4RegistersFinalize extends Pass2Base {
*/
private Registers.Register allocateNewRegisterZp(Variable variable) {
SymbolType varType = variable.getType();
if(SymbolType.isByte(varType)) {
if(SymbolType.BYTE.equals(varType)) {
return new Registers.RegisterZpByte(allocateZp((1)));
} else if(SymbolType.isSByte(varType)) {
} else if(SymbolType.SBYTE.equals(varType)) {
return new Registers.RegisterZpByte(allocateZp(1));
} else if(SymbolType.isWord(varType)) {
} else if(SymbolType.WORD.equals(varType)) {
Registers.RegisterZpWord registerZpWord =
new Registers.RegisterZpWord(allocateZp(2));
return registerZpWord;
} else if(SymbolType.isSWord(varType)) {
} else if(SymbolType.SWORD.equals(varType)) {
Registers.RegisterZpWord registerZpWord =
new Registers.RegisterZpWord(allocateZp(2));
return registerZpWord;
} else if(SymbolType.isDWord(varType)) {
} else if(SymbolType.DWORD.equals(varType)) {
Registers.RegisterZpDWord registerZpDWord =
new Registers.RegisterZpDWord(allocateZp(4));
return registerZpDWord;
} else if(SymbolType.isSDWord(varType)) {
} else if(SymbolType.SDWORD.equals(varType)) {
Registers.RegisterZpDWord registerZpDWord =
new Registers.RegisterZpDWord(allocateZp(4));
return registerZpDWord;