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

Number conversion working. Added program expression iterator.

Browse Source
This commit is contained in:
jespergravgaard 2019-05-07 00:59:54 +02:00
parent 49ae6a0e66
commit 7e174898b8
57 changed files with 13641 additions and 1093 deletions

11
src/main/java/dk/camelot64/kickc/Compiler.java

@ -155,7 +155,7 @@ public class Compiler {
new Pass1UnwindBlockScopes(program).execute();
new Pass1Procedures(program).execute();
new PassNTypeInference(program).execute();
new Pass1TypeIdSimplification(program).execute();
new PassNTypeIdSimplification(program).execute();
if(getLog().isVerbosePass1CreateSsa()) {
getLog().append("SYMBOLS");
@ -165,7 +165,7 @@ public class Compiler {
new Pass1FixLValuesLoHi(program).execute();
new Pass1AssertNoLValueIntermediate(program).execute();
new Pass1PointerSizeofFix(program).execute();
new PassNAddTypeConversions(program).execute();
new PassNAddTypeConversionsNew(program).execute();
new Pass1EarlyConstantIdentification(program).execute();
new PassNStatementIndices(program).step();
new PassNCallGraphAnalysis(program).step();
@ -231,9 +231,10 @@ public class Compiler {
private void pass2Optimize() {
List<Pass2SsaOptimization> optimizations = new ArrayList<>();
optimizations.add(new PassNTypeInference(program));
optimizations.add(new PassNAddTypeConversions(program));
optimizations.add(new PassNAddTypeConversionsNew(program));
optimizations.add(new PassNAddNumberTypeConversions(program));
optimizations.add(new PassNTypeInference(program));
optimizations.add(new PassNTypeIdSimplification(program));
optimizations.add(new Pass2CullEmptyBlocks(program));
optimizations.add(new PassNStatementIndices(program));
optimizations.add(new PassNVariableReferenceInfos(program));
@ -264,6 +265,7 @@ public class Compiler {
optimizations.add(new Pass2SizeOfSimplification(program));
optimizations.add(new Pass2InlineDerefIdx(program));
optimizations.add(new Pass2DeInlineWordDerefIdx(program));
optimizations.add(new Pass2ConstantCastSimplification(program));
pass2Execute(optimizations);
}
@ -303,6 +305,7 @@ public class Compiler {
constantOptimizations.add(new Pass2ConstantIdentification(program));
constantOptimizations.add(new Pass2ConstantAdditionElimination(program));
constantOptimizations.add(new Pass2ConstantSimplification(program));
constantOptimizations.add(new Pass2ConstantCastSimplification(program));
constantOptimizations.add(new Pass2ConstantIfs(program));
pass2Execute(constantOptimizations);

166
src/main/java/dk/camelot64/kickc/model/iterator/BinaryExpression.java

@ -1,166 +0,0 @@
package dk.camelot64.kickc.model.iterator;
import dk.camelot64.kickc.model.operators.OperatorBinary;
import dk.camelot64.kickc.model.operators.Operators;
import dk.camelot64.kickc.model.statements.StatementAssignment;
import dk.camelot64.kickc.model.statements.StatementConditionalJump;
import dk.camelot64.kickc.model.types.SymbolType;
import dk.camelot64.kickc.model.values.*;
/**
* A binary expression in the program being iterated by {@link BinaryExpressionIterator}
*/
public interface BinaryExpression {
/**
* Get the left operand
*
* @return The left operand
*/
RValue getLeft();
/**
* Get the binary operator
*
* @return the operator
*/
OperatorBinary getOperator();
/**
* Get the right operand
*
* @return The right operand
*/
RValue getRight();
/**
* Adds a cast to the right operand
* @param toType The toType to cast to
*/
void addRightCast(SymbolType toType);
/** Binary expression assignment rvalue. */
class BinaryExpressionAssignmentRValue implements BinaryExpression {
private final StatementAssignment assignment;
BinaryExpressionAssignmentRValue(StatementAssignment assignment) {
this.assignment = assignment;
}
@Override
public RValue getLeft() {
return assignment.getrValue1();
}
@Override
public OperatorBinary getOperator() {
return (OperatorBinary) assignment.getOperator();
}
@Override
public RValue getRight() {
return assignment.getrValue2();
}
@Override
public void addRightCast(SymbolType toType) {
if(assignment.getrValue2() instanceof ConstantValue) {
assignment.setrValue2(new ConstantCastValue(toType, (ConstantValue) assignment.getrValue2()));
} else {
throw new InternalError("Not implemented!");
}
}
}
/** Binary expression - assignment lvalue and the "total" rvalue. */
class BinaryExpressionAssignmentLValue implements BinaryExpression {
private final StatementAssignment assignment;
BinaryExpressionAssignmentLValue(StatementAssignment assignment) {
this.assignment = assignment;
}
@Override
public RValue getLeft() {
return assignment.getlValue();
}
@Override
public OperatorBinary getOperator() {
return Operators.ASSIGNMENT;
}
@Override
public RValue getRight() {
return new AssignmentRValue(assignment);
}
@Override
public void addRightCast(SymbolType toType) {
throw new InternalError("Not implemented!");
}
}
/** Binary expression conditional jump. */
class BinaryExpressionConditionalJump implements BinaryExpression {
private final StatementConditionalJump conditionalJump;
BinaryExpressionConditionalJump(StatementConditionalJump assignment) {
this.conditionalJump = assignment;
}
@Override
public RValue getLeft() {
return conditionalJump.getrValue1();
}
@Override
public OperatorBinary getOperator() {
return (OperatorBinary) conditionalJump.getOperator();
}
@Override
public RValue getRight() {
return conditionalJump.getrValue2();
}
@Override
public void addRightCast(SymbolType toType) {
throw new InternalError("Not implemented!");
}
}
/** Binary expression as part of a constant expression. */
class BinaryExpressionConstant implements BinaryExpression {
private ConstantBinary constantBinary;
BinaryExpressionConstant(ConstantBinary constantBinary) {
this.constantBinary = constantBinary;
}
@Override
public RValue getLeft() {
return constantBinary.getLeft();
}
@Override
public OperatorBinary getOperator() {
return constantBinary.getOperator();
}
@Override
public RValue getRight() {
return constantBinary.getRight();
}
@Override
public void addRightCast(SymbolType toType) {
constantBinary.setRight(new ConstantCastValue(toType, constantBinary.getRight()));
}
}
}

28
src/main/java/dk/camelot64/kickc/model/iterator/ProgramExpression.java Normal file

@ -0,0 +1,28 @@
package dk.camelot64.kickc.model.iterator;
import dk.camelot64.kickc.model.operators.Operator;
import dk.camelot64.kickc.model.values.ConstantRef;
import dk.camelot64.kickc.model.values.RValue;
import dk.camelot64.kickc.model.values.Value;
/** A unary or binary operator expression.
* Iterable using {@link ProgramExpressionIterator}.
* */
public interface ProgramExpression {
/**
* Get the operator
*
* @return the operator
*/
Operator getOperator();
/**
* Replace the unary/binary expression with a new value.
*
* Throws an exception if replacement is not possible
*
* @param value The new value.
*/
void set(Value value);
}

262
src/main/java/dk/camelot64/kickc/model/iterator/ProgramExpressionBinary.java Normal file

@ -0,0 +1,262 @@
package dk.camelot64.kickc.model.iterator;
import dk.camelot64.kickc.model.Comment;
import dk.camelot64.kickc.model.InternalError;
import dk.camelot64.kickc.model.operators.OperatorBinary;
import dk.camelot64.kickc.model.operators.Operators;
import dk.camelot64.kickc.model.statements.Statement;
import dk.camelot64.kickc.model.statements.StatementAssignment;
import dk.camelot64.kickc.model.statements.StatementConditionalJump;
import dk.camelot64.kickc.model.symbols.ProgramScope;
import dk.camelot64.kickc.model.symbols.Scope;
import dk.camelot64.kickc.model.symbols.VariableIntermediate;
import dk.camelot64.kickc.model.types.SymbolType;
import dk.camelot64.kickc.model.types.SymbolTypeInference;
import dk.camelot64.kickc.model.values.*;
import java.util.ListIterator;
/**
* A binary expression in the program being iterated by {@link ProgramExpressionIterator}
*/
public interface ProgramExpressionBinary extends ProgramExpression {
/**
* Get the left operand
*
* @return The left operand
*/
RValue getLeft();
/**
* Get the binary operator
*
* @return the operator
*/
OperatorBinary getOperator();
/**
* Get the right operand
*
* @return The right operand
*/
RValue getRight();
/**
* Adds a cast to the left operand
* @param toType The toType to cast to
*/
void addLeftCast(SymbolType toType, ListIterator<Statement> stmtIt, ScopeRef currentScope, ProgramScope symbols);
/**
* Adds a cast to the right operand
* @param toType The toType to cast to
*/
void addRightCast(SymbolType toType, ListIterator<Statement> stmtIt, ScopeRef currentScope, ProgramScope symbols);
/** Binary expression assignment rvalue. */
class ProgramExpressionBinaryAssignmentRValue implements ProgramExpressionBinary {
private final StatementAssignment assignment;
ProgramExpressionBinaryAssignmentRValue(StatementAssignment assignment) {
this.assignment = assignment;
}
@Override
public RValue getLeft() {
return assignment.getrValue1();
}
@Override
public OperatorBinary getOperator() {
return (OperatorBinary) assignment.getOperator();
}
@Override
public RValue getRight() {
return assignment.getrValue2();
}
@Override
public void set(Value value) {
assignment.setrValue2((RValue) value);
assignment.setOperator(null);
assignment.setrValue1(null);
}
@Override
public void addLeftCast(SymbolType toType, ListIterator<Statement> stmtIt, ScopeRef currentScope, ProgramScope symbols) {
if(assignment.getrValue1() instanceof ConstantValue) {
assignment.setrValue1(new ConstantCastValue(toType, (ConstantValue) assignment.getrValue1()));
} else {
Scope blockScope = symbols.getScope(currentScope);
VariableIntermediate tmpVar = blockScope.addVariableIntermediate();
tmpVar.setType(toType);
StatementAssignment newAssignment = new StatementAssignment(tmpVar.getRef(), Operators.getCastUnary(toType), assignment.getrValue1(), assignment.getSource(), Comment.NO_COMMENTS);
assignment.setrValue1(tmpVar.getRef());
stmtIt.add(newAssignment);
}
}
@Override
public void addRightCast(SymbolType toType, ListIterator<Statement> stmtIt, ScopeRef currentScope, ProgramScope symbols) {
if(assignment.getrValue2() instanceof ConstantValue) {
assignment.setrValue2(new ConstantCastValue(toType, (ConstantValue) assignment.getrValue2()));
} else {
Scope blockScope = symbols.getScope(currentScope);
VariableIntermediate tmpVar = blockScope.addVariableIntermediate();
tmpVar.setType(toType);
StatementAssignment newAssignment = new StatementAssignment(tmpVar.getRef(), Operators.getCastUnary(toType), assignment.getrValue2(), assignment.getSource(), Comment.NO_COMMENTS);
assignment.setrValue2(tmpVar.getRef());
stmtIt.add(newAssignment);
}
}
}
/** Binary expression - assignment lvalue and the "total" rvalue. */
class ProgramExpressionBinaryAssignmentLValue implements ProgramExpressionBinary {
private final StatementAssignment assignment;
ProgramExpressionBinaryAssignmentLValue(StatementAssignment assignment) {
this.assignment = assignment;
}
@Override
public RValue getLeft() {
return assignment.getlValue();
}
@Override
public OperatorBinary getOperator() {
return Operators.ASSIGNMENT;
}
@Override
public RValue getRight() {
if(assignment.getrValue1()==null && assignment.getOperator()==null) {
return assignment.getrValue2();
} else {
return new AssignmentRValue(assignment);
}
}
@Override
public void set(Value value) {
throw new InternalError("Updating an entire assignment is not allowed!");
}
@Override
public void addLeftCast(SymbolType toType, ListIterator<Statement> stmtIt, ScopeRef currentScope, ProgramScope symbols) {
Scope blockScope = symbols.getScope(currentScope);
VariableIntermediate tmpVar = blockScope.addVariableIntermediate();
SymbolType rightType = SymbolTypeInference.inferType(symbols, getRight());
tmpVar.setType(rightType);
StatementAssignment newAssignment = new StatementAssignment(assignment.getlValue(), Operators.getCastUnary(toType), tmpVar.getRef(), assignment.getSource(), Comment.NO_COMMENTS);
assignment.setlValue(tmpVar.getRef());
stmtIt.add(newAssignment);
}
@Override
public void addRightCast(SymbolType toType, ListIterator<Statement> stmtIt, ScopeRef currentScope, ProgramScope symbols) {
if(assignment.getrValue1()==null && assignment.getOperator()==null) {
//if(assignment.getrValue2() instanceof ConstantInteger) {
// ((ConstantInteger) assignment.getrValue2()).setType(toType);
//} else {
assignment.setOperator(Operators.getCastUnary(toType));
//}
} else {
throw new InternalError("Not implemented!");
}
}
}
/** Binary expression conditional jump. */
class ProgramExpressionBinaryConditionalJump implements ProgramExpressionBinary {
private final StatementConditionalJump conditionalJump;
ProgramExpressionBinaryConditionalJump(StatementConditionalJump assignment) {
this.conditionalJump = assignment;
}
@Override
public RValue getLeft() {
return conditionalJump.getrValue1();
}
@Override
public OperatorBinary getOperator() {
return (OperatorBinary) conditionalJump.getOperator();
}
@Override
public RValue getRight() {
return conditionalJump.getrValue2();
}
@Override
public void set(Value value) {
conditionalJump.setrValue2((RValue) value);
conditionalJump.setOperator(null);
conditionalJump.setrValue1(null);
}
@Override
public void addLeftCast(SymbolType toType, ListIterator<Statement> stmtIt, ScopeRef currentScope, ProgramScope symbols) {
throw new InternalError("Not implemented!");
}
@Override
public void addRightCast(SymbolType toType, ListIterator<Statement> stmtIt, ScopeRef currentScope, ProgramScope symbols) {
throw new InternalError("Not implemented!");
}
}
/** Binary expression as part of a constant expression. */
class ProgramExpressionBinaryConstant implements ProgramExpressionBinary {
/** A program value containing a {@link ConstantBinary}. */
private ProgramValue programValue;
public ProgramExpressionBinaryConstant(ProgramValue programValue) {
this.programValue = programValue;
}
public ConstantBinary getConstantBinary() {
return (ConstantBinary)programValue.get();
}
@Override
public RValue getLeft() {
return getConstantBinary().getLeft();
}
@Override
public OperatorBinary getOperator() {
return getConstantBinary().getOperator();
}
@Override
public RValue getRight() {
return getConstantBinary().getRight();
}
@Override
public void set(Value value) {
programValue.set(value);
}
@Override
public void addLeftCast(SymbolType toType, ListIterator<Statement> stmtIt, ScopeRef currentScope, ProgramScope symbols) {
getConstantBinary().setLeft(new ConstantCastValue(toType, getConstantBinary().getLeft()));
}
@Override
public void addRightCast(SymbolType toType, ListIterator<Statement> stmtIt, ScopeRef currentScope, ProgramScope symbols) {
getConstantBinary().setRight(new ConstantCastValue(toType, getConstantBinary().getRight()));
}
}
}

15
src/main/java/dk/camelot64/kickc/model/iterator/BinaryExpressionHandler.java → src/main/java/dk/camelot64/kickc/model/iterator/ProgramExpressionHandler.java

@ -5,21 +5,22 @@ import dk.camelot64.kickc.model.statements.Statement;
import java.util.ListIterator;
/** A handler that performs some action for binary expressions in the program.
* A {@link BinaryExpressionIterator} can be used to iterate all binary expressions in a part of the program.
* The Handler then receives all binary expressions one at a time. The Handler has the option of modifying the binary expression. After the handler is executed all sub-values are recursed.
/** A handler that performs some action for unary/binary expressions in the program.
* A {@link ProgramExpressionIterator} can be used to iterate all unary/binary expressions in a part of the program.
* The Handler then receives all unary/binary expressions one at a time.
* The Handler has the option of modifying the expression. After the handler is executed all sub-values are recursed.
* The execute() method furthermore receives some extra parameters with information about the context of the passed value.
*/
public interface BinaryExpressionHandler {
public interface ProgramExpressionHandler {
/**
* Handle a single binary expression
* Handle a single expression
*
* @param binaryExpression The binary expression
* @param programExpression The expression
* @param currentStmt The statement iterator - just past the current statement that the value is a part of. Current statment can be retrieved by calling
* @param stmtIt The statement iterator - just past the current statement. Can be used for modifying the control flow block.
* @param currentBlock The current block that the value is a part of
*/
void execute(BinaryExpression binaryExpression, Statement currentStmt, ListIterator<Statement> stmtIt, ControlFlowBlock currentBlock);
void execute(ProgramExpression programExpression, Statement currentStmt, ListIterator<Statement> stmtIt, ControlFlowBlock currentBlock);
}

28
src/main/java/dk/camelot64/kickc/model/iterator/BinaryExpressionIterator.java → src/main/java/dk/camelot64/kickc/model/iterator/ProgramExpressionIterator.java

@ -6,15 +6,16 @@ import dk.camelot64.kickc.model.statements.Statement;
import dk.camelot64.kickc.model.statements.StatementAssignment;
import dk.camelot64.kickc.model.statements.StatementConditionalJump;
import dk.camelot64.kickc.model.values.ConstantBinary;
import dk.camelot64.kickc.model.values.ConstantUnary;
import java.util.ListIterator;
/**
* Capable of iterating the different structures of a Program (graph, block, statement, symboltable, symbol).
* Creates appropriate BinaryExpressions and passes them to a BinaryExpressionHandler.
* Creates appropriate BinaryExpressions and passes them to a ProgramExpressionHandler.
* Iteration might be guided (eg. filtering some types of the structure to iterate at call-time)
*/
public class BinaryExpressionIterator {
public class ProgramExpressionIterator {
/**
* Execute a handler on all values in the entire program (both in the control flow graph and the symbol table.)
@ -22,12 +23,11 @@ public class BinaryExpressionIterator {
* @param program The program
* @param handler The handler to execute
*/
public static void execute(Program program, BinaryExpressionHandler handler) {
public static void execute(Program program, ProgramExpressionHandler handler) {
// Iterate all symbols
ProgramValueIterator.execute(program.getScope(), (programValue, currentStmt, stmtIt, currentBlock) -> {
if(programValue.get() instanceof ConstantBinary) {
ConstantBinary constantBinary = (ConstantBinary) programValue.get();
handler.execute( new BinaryExpression.BinaryExpressionConstant(constantBinary), null, null, null);
handler.execute(new ProgramExpressionBinary.ProgramExpressionBinaryConstant(programValue), null, null, null);
}
});
@ -38,22 +38,26 @@ public class BinaryExpressionIterator {
Statement stmt = stmtIt.next();
if(stmt instanceof StatementAssignment) {
StatementAssignment assignment = (StatementAssignment) stmt;
if(assignment.getrValue1() != null && assignment.getOperator()!=null &&assignment.getrValue2() != null) {
handler.execute( new BinaryExpression.BinaryExpressionAssignmentRValue(assignment), stmt, stmtIt, block);
if(assignment.getrValue1() != null && assignment.getOperator() != null && assignment.getrValue2() != null) {
handler.execute(new ProgramExpressionBinary.ProgramExpressionBinaryAssignmentRValue(assignment), stmt, stmtIt, block);
} else if(assignment.getrValue1() == null && assignment.getOperator() != null && assignment.getrValue2() != null) {
handler.execute(new ProgramExpressionUnary.ProgramExpressionUnaryAssignmentRValue(assignment), stmt, stmtIt, block);
}
handler.execute( new BinaryExpression.BinaryExpressionAssignmentLValue(assignment), stmt, stmtIt, block);
handler.execute(new ProgramExpressionBinary.ProgramExpressionBinaryAssignmentLValue(assignment), stmt, stmtIt, block);
} else if(stmt instanceof StatementConditionalJump) {
StatementConditionalJump condJump = (StatementConditionalJump) stmt;
if(condJump.getrValue1()!=null && condJump.getOperator()!=null && condJump.getrValue2()!=null) {
handler.execute( new BinaryExpression.BinaryExpressionConditionalJump(condJump), stmt, stmtIt, block);
if(condJump.getrValue1() != null && condJump.getOperator() != null && condJump.getrValue2() != null) {
handler.execute(new ProgramExpressionBinary.ProgramExpressionBinaryConditionalJump(condJump), stmt, stmtIt, block);
}
}
// Iterate all statement values
ProgramValueIterator.execute(stmt, (programValue, currentStmt, stmtIt1, currentBlock) -> {
if(programValue.get() instanceof ConstantBinary) {
ConstantBinary constantBinary = (ConstantBinary) programValue.get();
handler.execute( new BinaryExpression.BinaryExpressionConstant(constantBinary), stmt, stmtIt, block);
handler.execute(new ProgramExpressionBinary.ProgramExpressionBinaryConstant(programValue), stmt, stmtIt, block);
} else if(programValue.get() instanceof ConstantUnary) {
handler.execute(new ProgramExpressionUnary.ProgramExpressionUnaryConstant(programValue), stmt, stmtIt, block);
}
}, stmtIt, block);
}
}

84
src/main/java/dk/camelot64/kickc/model/iterator/ProgramExpressionUnary.java Normal file

@ -0,0 +1,84 @@
package dk.camelot64.kickc.model.iterator;
import dk.camelot64.kickc.model.operators.OperatorUnary;
import dk.camelot64.kickc.model.statements.StatementAssignment;
import dk.camelot64.kickc.model.values.ConstantUnary;
import dk.camelot64.kickc.model.values.RValue;
import dk.camelot64.kickc.model.values.Value;
/**
* A binary expression in the program being iterated by {@link ProgramExpressionIterator}
*/
public interface ProgramExpressionUnary extends ProgramExpression {
/**
* Get the unary operator
*
* @return the operator
*/
OperatorUnary getOperator();
/**
* Get the right operand
*
* @return The right operand
*/
RValue getOperand();
/** Unary expression assignment rvalue. */
class ProgramExpressionUnaryAssignmentRValue implements ProgramExpressionUnary {
private final StatementAssignment assignment;
ProgramExpressionUnaryAssignmentRValue(StatementAssignment assignment) {
this.assignment = assignment;
}
@Override
public OperatorUnary getOperator() {
return (OperatorUnary) assignment.getOperator();
}
@Override
public RValue getOperand() {
return assignment.getrValue2();
}
@Override
public void set(Value value) {
assignment.setrValue2((RValue) value);
assignment.setOperator(null);
}
}
/** Unary expression as part of a constant expression. */
class ProgramExpressionUnaryConstant implements ProgramExpressionUnary {
/** A ProgramValue containing a {@link ConstantUnary}. */
private ProgramValue programValue;
ProgramExpressionUnaryConstant(ProgramValue programValue) {
this.programValue = programValue;
}
public ConstantUnary getConstantUnary() {
return (ConstantUnary) programValue.get();
}
@Override
public OperatorUnary getOperator() {
return (getConstantUnary()).getOperator();
}
@Override
public RValue getOperand() {
return getConstantUnary().getOperand();
}
@Override
public void set(Value value) {
programValue.set(value);
}
}
}

989
src/main/java/dk/camelot64/kickc/model/iterator/ProgramValue.java

File diff suppressed because it is too large Load Diff

50
src/main/java/dk/camelot64/kickc/model/iterator/ProgramValueIterator.java

@ -50,10 +50,10 @@ public class ProgramValueIterator {
*/
public static void execute(SymbolVariable symbolVariable, ProgramValueHandler programValueHandler) {
if(symbolVariable.getType() instanceof SymbolTypeArray) {
execute(new ProgramValue.TypeArraySize((SymbolTypeArray) symbolVariable.getType()), programValueHandler, null, null, null);
execute(new ProgramValue.ProgramValueTypeArraySize((SymbolTypeArray) symbolVariable.getType()), programValueHandler, null, null, null);
}
if(symbolVariable instanceof ConstantVar) {
execute(new ProgramValue.ConstantVariableValue((ConstantVar) symbolVariable), programValueHandler, null, null, null);
execute(new ProgramValue.ProgramValueConstantVar((ConstantVar) symbolVariable), programValueHandler, null, null, null);
}
}
@ -98,7 +98,7 @@ public class ProgramValueIterator {
// The sequence RValue1, RValue2, LValue is important - as it is essential for {@link dk.camelot64.kickc.passes.Pass1GenerateSingleStaticAssignmentForm} to create the correct SSA
execute(new ProgramValue.RValue1((StatementAssignment) statement), handler, statement, statementsIt, block);
execute(new ProgramValue.RValue2((StatementAssignment) statement), handler, statement, statementsIt, block);
execute(new ProgramValue.LValue((StatementLValue) statement), handler, statement, statementsIt, block);
execute(new ProgramValue.ProgramValueLValue((StatementLValue) statement), handler, statement, statementsIt, block);
} else if(statement instanceof StatementCall) {
StatementCall call = (StatementCall) statement;
if(call.getParameters() != null) {
@ -107,7 +107,7 @@ public class ProgramValueIterator {
execute(new ProgramValue.CallParameter(call, i), handler, statement, statementsIt, block);
}
}
execute(new ProgramValue.LValue((StatementLValue) statement), handler, statement, statementsIt, block);
execute(new ProgramValue.ProgramValueLValue((StatementLValue) statement), handler, statement, statementsIt, block);
} else if(statement instanceof StatementCallPointer) {
StatementCallPointer call = (StatementCallPointer) statement;
execute(new ProgramValue.CallPointerProcedure((StatementCallPointer) statement), handler, statement, statementsIt, block);
@ -117,7 +117,7 @@ public class ProgramValueIterator {
execute(new ProgramValue.CallPointerParameter(call, i), handler, statement, statementsIt, block);
}
}
execute(new ProgramValue.LValue((StatementLValue) statement), handler, statement, statementsIt, block);
execute(new ProgramValue.ProgramValueLValue((StatementLValue) statement), handler, statement, statementsIt, block);
} else if(statement instanceof StatementConditionalJump) {
execute(new ProgramValue.CondRValue1((StatementConditionalJump) statement), handler, statement, statementsIt, block);
execute(new ProgramValue.CondRValue2((StatementConditionalJump) statement), handler, statement, statementsIt, block);
@ -137,15 +137,15 @@ public class ProgramValueIterator {
StatementKickAsm statementKickAsm = (StatementKickAsm) statement;
RValue location = statementKickAsm.getLocation();
if(location!=null) {
execute(new ProgramValue.KickAsmLocation(statementKickAsm), handler, statement, statementsIt, block);
execute(new ProgramValue.ProgramValueKickAsmLocation(statementKickAsm), handler, statement, statementsIt, block);
}
RValue bytes = statementKickAsm.getLocation();
if(bytes!=null) {
execute(new ProgramValue.KickAsmBytes(statementKickAsm), handler, statement, statementsIt, block);
execute(new ProgramValue.ProgramValueKickAsmBytes(statementKickAsm), handler, statement, statementsIt, block);
}
RValue cycles = statementKickAsm.getLocation();
if(cycles!=null) {
execute(new ProgramValue.KickAsmCycles(statementKickAsm), handler, statement, statementsIt, block);
execute(new ProgramValue.ProgramValueKickAsmCycles(statementKickAsm), handler, statement, statementsIt, block);
}
List<SymbolVariableRef> uses = statementKickAsm.getUses();
for(int i = 0; i < uses.size(); i++) {
@ -155,7 +155,7 @@ public class ProgramValueIterator {
StatementAsm statementAsm = (StatementAsm) statement;
Map<String, SymbolVariableRef> referenced = statementAsm.getReferenced();
for(String label : referenced.keySet()) {
execute(new ProgramValue.AsmReferenced(statementAsm, label), handler, statement, statementsIt, block);
execute(new ProgramValue.ProgramValueAsmReferenced(statementAsm, label), handler, statement, statementsIt, block);
}
}
}
@ -182,42 +182,42 @@ public class ProgramValueIterator {
private static Collection<ProgramValue> getSubValues(Value value) {
ArrayList<ProgramValue> subValues = new ArrayList<>();
if(value instanceof PointerDereferenceIndexed) {
subValues.add(new ProgramValue.Pointer((PointerDereference) value));
subValues.add(new ProgramValue.PointerIndex((PointerDereferenceIndexed) value));
subValues.add(new ProgramValue.ProgramValuePointer((PointerDereference) value));
subValues.add(new ProgramValue.ProgramValuePointerIndex((PointerDereferenceIndexed) value));
} else if(value instanceof PointerDereferenceSimple) {
subValues.add(new ProgramValue.Pointer((PointerDereference) value));
subValues.add(new ProgramValue.ProgramValuePointer((PointerDereference) value));
} else if(value instanceof ValueList) {
ValueList valueList = (ValueList) value;
int size = valueList.getList().size();
for(int i = 0; i < size; i++) {
subValues.add(new ProgramValue.ListElement(valueList, i));
subValues.add(new ProgramValue.ProgramValueListElement(valueList, i));
}
} else if(value instanceof ConstantArrayList) {
ConstantArrayList constantArrayList = (ConstantArrayList) value;
int size = constantArrayList.getElements().size();
for(int i = 0; i < size; i++) {
subValues.add(new ProgramValue.ConstantArrayElement(constantArrayList, i));
subValues.add(new ProgramValue.ProgramValueConstantArrayElement(constantArrayList, i));
}
} else if(value instanceof CastValue) {
subValues.add(new ProgramValue.CastValue((CastValue) value));
subValues.add(new ProgramValue.ProgramValueCastValue((CastValue) value));
} else if(value instanceof ConstantCastValue) {
subValues.add(new ProgramValue.ConstantCastValue((ConstantCastValue) value));
subValues.add(new ProgramValue.ProgramValueConstantCastValue((ConstantCastValue) value));
} else if(value instanceof ConstantSymbolPointer) {
subValues.add(new ProgramValue.ConstantSymbolPointerTo((ConstantSymbolPointer) value));
subValues.add(new ProgramValue.ProgramValueConstantSymbolPointerTo((ConstantSymbolPointer) value));
} else if(value instanceof RangeValue) {
subValues.add(new ProgramValue.RangeFirst((RangeValue) value));
subValues.add(new ProgramValue.RangeLast((RangeValue) value));
subValues.add(new ProgramValue.ProgramValueRangeFirst((RangeValue) value));
subValues.add(new ProgramValue.ProgramValueRangeLast((RangeValue) value));
} else if(value instanceof ConstantBinary) {
subValues.add(new ProgramValue.ConstantBinaryLeft((ConstantBinary) value));
subValues.add(new ProgramValue.ConstantBinaryRight((ConstantBinary) value));
subValues.add(new ProgramValue.ProgramValueConstantBinaryLeft((ConstantBinary) value));
subValues.add(new ProgramValue.ProgramValueConstantBinaryRight((ConstantBinary) value));
} else if(value instanceof ConstantUnary) {
subValues.add(new ProgramValue.ConstantUnaryValue((ConstantUnary) value));
subValues.add(new ProgramValue.ProgramValueConstantUnaryValue((ConstantUnary) value));
} else if(value instanceof ArrayFilled) {
subValues.add(new ProgramValue.ArrayFilledSize((ArrayFilled) value));
subValues.add(new ProgramValue.ProgramValueArrayFilledSize((ArrayFilled) value));
} else if(value instanceof ConstantArrayFilled) {
subValues.add(new ProgramValue.ConstantArrayFilledSize((ConstantArrayFilled) value));
subValues.add(new ProgramValue.ProgramValueConstantArrayFilledSize((ConstantArrayFilled) value));
} else if(value instanceof LvalueIntermediate) {
subValues.add(new ProgramValue.LValueIntermediateVariable((LvalueIntermediate) value));
subValues.add(new ProgramValue.ProgramValueLValueIntermediateVariable((LvalueIntermediate) value));
} else if(value == null ||
value instanceof VariableRef ||
value instanceof ProcedureRef ||

7
src/main/java/dk/camelot64/kickc/model/operators/OperatorBitwiseAnd.java

@ -1,10 +1,7 @@
package dk.camelot64.kickc.model.operators;
import dk.camelot64.kickc.model.CompileError;
import dk.camelot64.kickc.model.types.SymbolType;
import dk.camelot64.kickc.model.types.SymbolTypeInteger;
import dk.camelot64.kickc.model.types.SymbolTypePointer;
import dk.camelot64.kickc.model.types.SymbolTypeSimple;
import dk.camelot64.kickc.model.types.*;
import dk.camelot64.kickc.model.values.ConstantInteger;
import dk.camelot64.kickc.model.values.ConstantLiteral;
@ -34,7 +31,7 @@ public class OperatorBitwiseAnd extends OperatorBinary {
}
// Handle numeric types
if(SymbolType.isInteger(type1) && SymbolType.isInteger(type2)) {
return SymbolType.convertedMathType((SymbolTypeInteger) type1, (SymbolTypeInteger) type2);
return SymbolTypeConversion.convertedMathType((SymbolTypeInteger) type1, (SymbolTypeInteger) type2);
}
throw new CompileError("Type inference case not handled " + type1 + " " + getOperator() + " " + type2);

2
src/main/java/dk/camelot64/kickc/model/operators/OperatorBitwiseOr.java

@ -31,7 +31,7 @@ public class OperatorBitwiseOr extends OperatorBinary {
}
// Handle numeric types
if(SymbolType.isInteger(type1) && SymbolType.isInteger(type2)) {
return SymbolType.convertedMathType((SymbolTypeInteger) type1, (SymbolTypeInteger) type2);
return SymbolTypeConversion.convertedMathType((SymbolTypeInteger) type1, (SymbolTypeInteger) type2);
}
throw new CompileError("Type inference case not handled " + type1 + " " + getOperator() + " " + type2);
}

2
src/main/java/dk/camelot64/kickc/model/operators/OperatorBitwiseXor.java

@ -31,7 +31,7 @@ public class OperatorBitwiseXor extends OperatorBinary {
}
// Handle numeric types
if(SymbolType.isInteger(type1) && SymbolType.isInteger(type2)) {
return SymbolType.convertedMathType((SymbolTypeInteger) type1, (SymbolTypeInteger) type2);
return SymbolTypeConversion.convertedMathType((SymbolTypeInteger) type1, (SymbolTypeInteger) type2);
}
throw new CompileError("Type inference case not handled " + type1 + " " + getOperator() + " " + type2);
}

18
src/main/java/dk/camelot64/kickc/model/operators/OperatorCast.java Normal file

@ -0,0 +1,18 @@
package dk.camelot64.kickc.model.operators;
import dk.camelot64.kickc.model.types.SymbolType;
/** Abstract cast operator. */
public abstract class OperatorCast extends OperatorUnary {
private SymbolType toType;
public OperatorCast(String operator, String asmOperator, int precedence, SymbolType toType) {
super(operator, asmOperator, precedence);
this.toType = toType;
}
public SymbolType getToType() {
return toType;
}
}

4
src/main/java/dk/camelot64/kickc/model/operators/OperatorCastBool.java

@ -9,10 +9,10 @@ import dk.camelot64.kickc.model.values.ConstantLiteral;
import dk.camelot64.kickc.model.values.ConstantPointer;
/** Unary Cast to boolean operator ( (boolean) x ) */
public class OperatorCastBool extends OperatorUnary {
public class OperatorCastBool extends OperatorCast {
public OperatorCastBool(int precedence) {
super("((bool))", "_bool_", precedence);
super("((bool))", "_bool_", precedence, SymbolType.BOOLEAN);
}
@Override

4
src/main/java/dk/camelot64/kickc/model/operators/OperatorCastByte.java

@ -9,10 +9,10 @@ import dk.camelot64.kickc.model.values.ConstantLiteral;
import dk.camelot64.kickc.model.values.ConstantPointer;
/** Unary Cast to byte operator ( (byte) x ) */
public class OperatorCastByte extends OperatorUnary {
public class OperatorCastByte extends OperatorCast {
public OperatorCastByte(int precedence) {
super("((byte))", "_byte_", precedence);
super("((byte))", "_byte_", precedence, SymbolType.BYTE);
}
@Override

4
src/main/java/dk/camelot64/kickc/model/operators/OperatorCastDWord.java

@ -9,10 +9,10 @@ import dk.camelot64.kickc.model.values.ConstantLiteral;
import dk.camelot64.kickc.model.values.ConstantPointer;
/** Unary Cast to double word operator ( (dword) x ) */
public class OperatorCastDWord extends OperatorUnary {
public class OperatorCastDWord extends OperatorCast {
public OperatorCastDWord(int precedence) {
super("((dword))", "_dword_", precedence);
super("((dword))", "_dword_", precedence, SymbolType.DWORD);
}
@Override

4
src/main/java/dk/camelot64/kickc/model/operators/OperatorCastPtr.java

@ -10,12 +10,12 @@ import dk.camelot64.kickc.model.values.ConstantLiteral;
import dk.camelot64.kickc.model.values.ConstantPointer;
/** Unary Cast to a pointer ( type* ) */
public class OperatorCastPtr extends OperatorUnary {
public class OperatorCastPtr extends OperatorCast {
private final SymbolType elementType;
public OperatorCastPtr(int precedence, SymbolType elementType) {
super("((" + elementType.toString() + "*))", "_ptr_", precedence);
super("((" + elementType.toString() + "*))", "_ptr_", precedence, new SymbolTypePointer(elementType));
this.elementType = elementType;
}

4
src/main/java/dk/camelot64/kickc/model/operators/OperatorCastSByte.java

@ -8,10 +8,10 @@ import dk.camelot64.kickc.model.values.ConstantInteger;
import dk.camelot64.kickc.model.values.ConstantLiteral;
/** Unary Cast to signed byte operator ( (signed byte) x ) */
public class OperatorCastSByte extends OperatorUnary {
public class OperatorCastSByte extends OperatorCast {
public OperatorCastSByte(int precedence) {
super("((signed byte))", "_sbyte_", precedence);
super("((signed byte))", "_sbyte_", precedence, SymbolType.SBYTE);
}
@Override

4
src/main/java/dk/camelot64/kickc/model/operators/OperatorCastSDWord.java

@ -8,10 +8,10 @@ import dk.camelot64.kickc.model.values.ConstantInteger;
import dk.camelot64.kickc.model.values.ConstantLiteral;
/** Unary Cast to signed double word operator ( (signed dword) x ) */
public class OperatorCastSDWord extends OperatorUnary {
public class OperatorCastSDWord extends OperatorCast {
public OperatorCastSDWord(int precedence) {
super("((signed dword))", "_sdword_", precedence);
super("((signed dword))", "_sdword_", precedence, SymbolType.SDWORD);
}
@Override

4
src/main/java/dk/camelot64/kickc/model/operators/OperatorCastSWord.java

@ -8,10 +8,10 @@ import dk.camelot64.kickc.model.values.ConstantInteger;
import dk.camelot64.kickc.model.values.ConstantLiteral;
/** Unary Cast to signed word operator ( (signed word) x ) */
public class OperatorCastSWord extends OperatorUnary {
public class OperatorCastSWord extends OperatorCast {
public OperatorCastSWord(int precedence) {
super("((signed word))", "_sword_", precedence);
super("((signed word))", "_sword_", precedence, SymbolType.SWORD);
}
@Override

4
src/main/java/dk/camelot64/kickc/model/operators/OperatorCastWord.java

@ -9,10 +9,10 @@ import dk.camelot64.kickc.model.values.ConstantLiteral;
import dk.camelot64.kickc.model.values.ConstantPointer;
/** Unary Cast to word operator ( (word) x ) */
public class OperatorCastWord extends OperatorUnary {
public class OperatorCastWord extends OperatorCast {
public OperatorCastWord(int precedence) {
super("((word))", "_word_", precedence);
super("((word))", "_word_", precedence, SymbolType.WORD);
}
@Override

2
src/main/java/dk/camelot64/kickc/model/operators/OperatorDivide.java

@ -38,7 +38,7 @@ public class OperatorDivide extends OperatorBinary {
}
// Handle numeric types through proper promotion
if(SymbolType.isInteger(left) && SymbolType.isInteger(right)) {
return SymbolType.convertedMathType( (SymbolTypeInteger) left, (SymbolTypeInteger)right);
return SymbolTypeConversion.convertedMathType( (SymbolTypeInteger) left, (SymbolTypeInteger)right);
}
throw new RuntimeException("Type inference case not handled " + left + " " + getOperator() + " " + right);

2
src/main/java/dk/camelot64/kickc/model/operators/OperatorMinus.java

@ -38,7 +38,7 @@ public class OperatorMinus extends OperatorBinary {
}
// Handle numeric types through proper promotion
if(SymbolType.isInteger(type1) && SymbolType.isInteger(type2)) {
return SymbolType.convertedMathType((SymbolTypeInteger) type1, (SymbolTypeInteger) type2);
return SymbolTypeConversion.convertedMathType((SymbolTypeInteger) type1, (SymbolTypeInteger) type2);
}
throw new RuntimeException("Type inference case not handled " + type1 + " " + getOperator() + " " + type2);
}

2
src/main/java/dk/camelot64/kickc/model/operators/OperatorModulo.java

@ -27,7 +27,7 @@ public class OperatorModulo extends OperatorBinary {
public SymbolType inferType(SymbolTypeSimple left, SymbolTypeSimple right) {
// Handle numeric types through proper promotion
if(SymbolType.isInteger(left) && SymbolType.isInteger(right)) {
return SymbolType.convertedMathType((SymbolTypeInteger) left, (SymbolTypeInteger) right);
return SymbolTypeConversion.convertedMathType((SymbolTypeInteger) left, (SymbolTypeInteger) right);
}
if(left instanceof ConstantPointer && right instanceof ConstantInteger) {
return ((ConstantInteger) right).getType();

7
src/main/java/dk/camelot64/kickc/model/operators/OperatorMultiply.java

@ -1,10 +1,7 @@
package dk.camelot64.kickc.model.operators;
import dk.camelot64.kickc.model.CompileError;
import dk.camelot64.kickc.model.types.SymbolType;
import dk.camelot64.kickc.model.types.SymbolTypeInteger;
import dk.camelot64.kickc.model.types.SymbolTypeIntegerFixed;
import dk.camelot64.kickc.model.types.SymbolTypeSimple;
import dk.camelot64.kickc.model.types.*;
import dk.camelot64.kickc.model.values.ConstantInteger;
import dk.camelot64.kickc.model.values.ConstantLiteral;
@ -27,7 +24,7 @@ public class OperatorMultiply extends OperatorBinary {
public SymbolType inferType(SymbolTypeSimple left, SymbolTypeSimple right) {
// Handle numeric types through proper promotion
if(SymbolType.isInteger(left) && SymbolType.isInteger(right)) {
return SymbolType.convertedMathType((SymbolTypeInteger) left, (SymbolTypeInteger) right);
return SymbolTypeConversion.convertedMathType((SymbolTypeInteger) left, (SymbolTypeInteger) right);
}
throw new RuntimeException("Type inference case not handled " + left + " " + getOperator() + " " + right);
}

2
src/main/java/dk/camelot64/kickc/model/operators/OperatorPlus.java

@ -46,7 +46,7 @@ public class OperatorPlus extends OperatorBinary {
}
// Handle numeric types through proper promotion
if(SymbolType.isInteger(type1) && SymbolType.isInteger(type2)) {
return SymbolType.convertedMathType( (SymbolTypeInteger) type1, (SymbolTypeInteger)type2);
return SymbolTypeConversion.convertedMathType( (SymbolTypeInteger) type1, (SymbolTypeInteger)type2);
}
throw new CompileError("Type inference case not handled " + type1 + " " + getOperator() + " " + type2);

1
src/main/java/dk/camelot64/kickc/model/operators/Operators.java

@ -159,4 +159,5 @@ public class Operators {
}
}
}

79
src/main/java/dk/camelot64/kickc/model/types/SymbolType.java

@ -1,10 +1,5 @@
package dk.camelot64.kickc.model.types;
import dk.camelot64.kickc.model.CompileError;
import java.util.ArrayList;
import java.util.Collection;
/** Symbol Types */
public interface SymbolType {
@ -91,6 +86,8 @@ public interface SymbolType {
return BOOLEAN;
case "void":
return VOID;
case "number":
return NUMBER;
}
return null;
}
@ -105,7 +102,7 @@ public interface SymbolType {
/**
* Get the size of the type (in bytes).
* @return The size
* @return The size. -1 if the type is compile-time only.
*/
int getSizeBytes();
@ -215,74 +212,4 @@ public interface SymbolType {
return SDWORD.equals(type) || DWORD.equals(type) || SWORD.equals(type) || WORD.equals(type) || SBYTE.equals(type) || BYTE.equals(type) || NUMBER.equals(type);
}
/**
* Get all integer types.
*
* @return All integeer types
*/
static Collection<SymbolTypeIntegerFixed> getIntegerFixedTypes() {
ArrayList<SymbolTypeIntegerFixed> types = new ArrayList<>();
types.add(BYTE);
types.add(SBYTE);
types.add(WORD);
types.add(SWORD);
types.add(DWORD);
types.add(SDWORD);
return types;
}
/**
* Find the integer type that results from a binary operator according to C99 6.3.1.8
* http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf#page=70
*
* @param type1 Left type in a binary expression
* @param type2 Right type in a binary expression
* @return The type resulting from a binary operator performed on the two parameters
*/
static SymbolType convertedMathType(SymbolTypeInteger type1, SymbolTypeInteger type2) {
if(SymbolType.NUMBER.equals(type1) || SymbolType.NUMBER.equals(type2)) {
return NUMBER;
}
SymbolTypeIntegerFixed fixed1 = (SymbolTypeIntegerFixed) type1;
SymbolTypeIntegerFixed fixed2 = (SymbolTypeIntegerFixed) type2;
// C99 6.3.1.8 a. If two operands have the same type no conversion is performed
if(type1.equals(type2))
return type1;
// C99 6.3.1.8 b. If both are signed or both are unsigned then the smallest type is converted to the size of the large type (byte->word->sword, sbyte->sword->sdword)
if(fixed1.isSigned()==fixed2.isSigned())
return (fixed1.getBits()>fixed2.getBits()) ? fixed1 : fixed2;
// C99 6.3.1.8 c. One is signed and one unsigned.
// If the signed type can contain all values of the unsigned type then the unsigned value is converted to the signed type. (byte->sword, byte->sdword, word->sdword).
SymbolTypeIntegerFixed typeS, typeU;
if(fixed1.isSigned()) {
typeS = fixed1;
typeU = fixed2;
} else {
typeS = fixed2;
typeU = fixed1;
}
if(typeS.getBits()>typeU.getBits())
return typeS;
// C99 6.3.1.8 d. The unsigned type is the same size as or larger than the signed type.
// The signed value is first converted to the size of the unsigned type and then converted to unsigned changing the sign and the value
// (sbyte->byte, sbyte->word, sbyte->dword, sword->word, sword->dword, sdword->dword).
return typeU;
}
/**
* Find the unsigned integer type that contains both sub-types usable for binary operations ( & | ^ ).
*
* @param type1 Left type in a binary expression
* @param type2 Right type in a binary expression
* @return
*/
static SymbolType promotedBitwiseType(SymbolTypeIntegerFixed type1, SymbolTypeIntegerFixed type2) {
for(SymbolTypeIntegerFixed candidate : getIntegerFixedTypes()) {
if(!candidate.isSigned() && type1.getBits()<=candidate.getBits() && type2.getBits()<=candidate.getBits()) {
return candidate;
}
}
throw new CompileError("Cannot promote to a common type for "+type1.toString()+" and "+type2.toString());
}
}

134
src/main/java/dk/camelot64/kickc/model/types/SymbolTypeConversion.java Normal file

@ -0,0 +1,134 @@
package dk.camelot64.kickc.model.types;
import dk.camelot64.kickc.model.CompileError;
import dk.camelot64.kickc.model.InternalError;
import dk.camelot64.kickc.model.statements.Statement;
import dk.camelot64.kickc.model.symbols.ProgramScope;
import dk.camelot64.kickc.model.values.ConstantInteger;
import dk.camelot64.kickc.model.values.ConstantLiteral;
import dk.camelot64.kickc.model.values.ConstantValue;
import dk.camelot64.kickc.model.values.RValue;
/**
* Rules for converting integer types.
*
* Integer conversion implements C99 6.3.1.8 http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf#page=70
*
* The special number type is converted as described here https://gitlab.com/camelot/kickc/issues/181
*
*/
public class SymbolTypeConversion {
/**
* Find the integer type that results from a binary operator according to C99 6.3.1.8
* http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf#page=70
*
* @param type1 Left type in a binary expression
* @param type2 Right type in a binary expression
* @return The type resulting from a binary operator performed on the two parameters
*/
public static SymbolType convertedMathType(SymbolTypeInteger type1, SymbolTypeInteger type2) {
if(SymbolType.NUMBER.equals(type1) || SymbolType.NUMBER.equals(type2)) {
return SymbolType.NUMBER;
}
SymbolTypeIntegerFixed fixed1 = (SymbolTypeIntegerFixed) type1;
SymbolTypeIntegerFixed fixed2 = (SymbolTypeIntegerFixed) type2;
// C99 6.3.1.8 a. If two operands have the same type no conversion is performed
if(type1.equals(type2))
return type1;
// C99 6.3.1.8 b. If both are signed or both are unsigned then the smallest type is converted to the size of the large type (byte->word->sword, sbyte->sword->sdword)
if(fixed1.isSigned()==fixed2.isSigned())
return (fixed1.getBits()>fixed2.getBits()) ? fixed1 : fixed2;
// C99 6.3.1.8 c. One is signed and one unsigned.
// If the signed type can contain all values of the unsigned type then the unsigned value is converted to the signed type. (byte->sword, byte->sdword, word->sdword).
SymbolTypeIntegerFixed typeS, typeU;
if(fixed1.isSigned()) {
typeS = fixed1;
typeU = fixed2;
} else {
typeS = fixed2;
typeU = fixed1;
}
if(typeS.getBits()>typeU.getBits())
return typeS;
// C99 6.3.1.8 d. The unsigned type is the same size as or larger than the signed type.
// The signed value is first converted to the size of the unsigned type and then converted to unsigned changing the sign and the value
// (sbyte->byte, sbyte->word, sbyte->dword, sword->word, sword->dword, sdword->dword).
return typeU;
}
/**
* Find the integer type that results from a binary operator according to the special number type conversion https://gitlab.com/camelot/kickc/issues/181
* @param left The left value
* @param right The right value
* @param symbols The program scope symbols (used for looking up symbols and constants)
* @param currentStmt The current statement (used only for exception context)
* @return a non-null fixed integer type if a number type conversion is relevant.
*/
public static SymbolType convertedNumberType(RValue left, RValue right, ProgramScope symbols, Statement currentStmt) {
SymbolType leftType = SymbolTypeInference.inferType(symbols, left);
SymbolType rightType = SymbolTypeInference.inferType(symbols, right);
if(SymbolType.NUMBER.equals(leftType) || SymbolType.NUMBER.equals(rightType)) {
// A special type number is assigned to integer constants without a postfix literal.
// Numbers are flexible and will take a type based on their actual value when they meet a typed number in a calculation.
// Number types are only usable at compile time.
if(leftType.equals(rightType)) {
// a) If the two operands are numbers the result is a number
return null;
}
RValue numberVal;
SymbolTypeIntegerFixed fixedType;
if(SymbolType.NUMBER.equals(leftType) && SymbolType.isInteger(rightType)) {
// Left is the number type - right is the fixed type
numberVal = left;
fixedType = (SymbolTypeIntegerFixed) rightType;
} else if(SymbolType.NUMBER.equals(rightType) && SymbolType.isInteger(leftType)) {
// Right is the number type - left is the fixed type
numberVal = right;
fixedType = (SymbolTypeIntegerFixed) leftType;
} else {
// Binary operator combining number and non-integer
throw new CompileError("Error! Incompatible operands " + left.toString() + " and " + right.toString(), currentStmt);
}
if(numberVal instanceof ConstantValue) {
ConstantLiteral constantLiteral = ((ConstantValue) numberVal).calculateLiteral(symbols);
if(constantLiteral instanceof ConstantInteger) {
ConstantInteger constantInteger = (ConstantInteger) constantLiteral;
if(SymbolType.NUMBER.equals(constantInteger.getType())) {
Long value = constantInteger.getValue();
if(fixedType.isSigned()) {
// b) If one operand is a signed type and the other a number they are both converted to the smallest signed type that can hold the values.
SymbolTypeIntegerFixed smallestSignedType = SymbolTypeIntegerFixed.getSmallestSigned(value);
if(smallestSignedType == null) {
throw new CompileError("Number constant has value that cannot be represented by a signed type " + value, currentStmt);
}
return smallestSignedType.getBits() > fixedType.getBits() ? smallestSignedType : fixedType;
} else {
// c) If one operand is an unsigned type and the other a number they are both converted to the smallest unsigned type that can hold the values.
// If the number value is negative it is converted to unsigned using two's complement.
SymbolTypeIntegerFixed smallestUnsignedType;
if(value < 0) {
smallestUnsignedType = SymbolTypeIntegerFixed.getSmallestUnsigned(-value);
} else {
smallestUnsignedType = SymbolTypeIntegerFixed.getSmallestUnsigned(value);
}
return smallestUnsignedType.getBits() > fixedType.getBits() ? smallestUnsignedType : fixedType;
}
} else {
throw new InternalError("Non-number constant has type number " + right.toString(), currentStmt);
}
}
} else {
// Postpone til later!
return null;
}
}
// No number conversion
return null;
}
}

55
src/main/java/dk/camelot64/kickc/model/types/SymbolTypeIntegerFixed.java

@ -1,5 +1,8 @@
package dk.camelot64.kickc.model.types;
import java.util.ArrayList;
import java.util.Collection;
/** Integer type with a fixed size (byte, signed byte, word, ...). */
public class SymbolTypeIntegerFixed implements SymbolTypeInteger {
@ -17,6 +20,58 @@ public class SymbolTypeIntegerFixed implements SymbolTypeInteger {
this.bits = bits;
}
/**
* Get all fixed size integer types.
*
* @return All fixed size integer types
*/
public static Collection<SymbolTypeIntegerFixed> getIntegerFixedTypes() {
ArrayList<SymbolTypeIntegerFixed> types = new ArrayList<>();
types.add(BYTE);
types.add(SBYTE);
types.add(WORD);
types.add(SWORD);
types.add(DWORD);
types.add(SDWORD);
return types;
}
/**
* Find the smallest signed type that can hold the passed value
* @param value The value
* @return The smallest signed type that can hold the value
*/
public static SymbolTypeIntegerFixed getSmallestSigned(Long value) {
for(SymbolTypeIntegerFixed fixedType : getIntegerFixedTypes()) {
if(fixedType.isSigned() && fixedType.contains(value))
return fixedType;
}
return null;
}
/**
* Find the smallest unsigned type that can hold the passed value
* @param value The value
* @return The smallest unsigned type that can hold the value
*/
public static SymbolTypeIntegerFixed getSmallestUnsigned(Long value) {
for(SymbolTypeIntegerFixed fixedType : getIntegerFixedTypes()) {
if(!fixedType.isSigned() && fixedType.contains(value))
return fixedType;
}
return null;
}
/**
* Determines if a value can be represented by the type without loss of information
*
* @param value The value to examine
* @return true if the type contains the value
*/
public boolean contains(Long number) {
return number >= getMinValue() && number <= getMaxValue();
}
@Override
public String getTypeName() {
return typeName;

16
src/main/java/dk/camelot64/kickc/model/types/SymbolTypeMulti.java

@ -26,22 +26,6 @@ public class SymbolTypeMulti implements SymbolType {
return types;
}
/**
* Get the multi-type that can contain the passed number.
* @param number The number
* @return The multi-type
*/
public static SymbolType getMultiType(Long number) {
ArrayList<SymbolType> potentialTypes = new ArrayList<>();
for(SymbolTypeIntegerFixed typeInteger : SymbolType.getIntegerFixedTypes()) {
if(number >= typeInteger.getMinValue() && number <= typeInteger.getMaxValue()) {
potentialTypes.add(typeInteger);
}
}
return new SymbolTypeMulti(potentialTypes);
}
@Override
public int getSizeBytes() {
// Find the minimal sizeof - and return that

4
src/main/java/dk/camelot64/kickc/model/types/SymbolTypeNumberInference.java

@ -90,8 +90,8 @@ public class SymbolTypeNumberInference {
ArrayList<SymbolTypeIntegerFixed> potentialTypes = new ArrayList<>();
ConstantInteger constantInteger = (ConstantInteger) literal;
Long number = constantInteger.getValue();
for(SymbolTypeIntegerFixed typeInteger : SymbolType.getIntegerFixedTypes()) {
if(number >= typeInteger.getMinValue() && number <= typeInteger.getMaxValue()) {
for(SymbolTypeIntegerFixed typeInteger : SymbolTypeIntegerFixed.getIntegerFixedTypes()) {
if(typeInteger.contains(number)) {
potentialTypes.add(typeInteger);
}
}

2
src/main/java/dk/camelot64/kickc/model/values/AssignmentRValue.java

@ -3,7 +3,7 @@ package dk.camelot64.kickc.model.values;
import dk.camelot64.kickc.model.Program;
import dk.camelot64.kickc.model.statements.StatementAssignment;
/** The "total" RValue of an assigment. */
/** The "total" RValue of an assignment. */
public class AssignmentRValue implements RValue {
private StatementAssignment assignment;

2
src/main/java/dk/camelot64/kickc/passes/Pass1GenerateSingleStaticAssignmentForm.java

@ -96,7 +96,7 @@ public class Pass1GenerateSingleStaticAssignmentForm extends Pass1Base {
programValue.set(version.getRef());
}
// Update map of versions encountered in the block
if(currentStmt instanceof StatementAssignment && programValue instanceof ProgramValue.LValue) {
if(currentStmt instanceof StatementAssignment && programValue instanceof ProgramValue.ProgramValueLValue) {
StatementAssignment assignment = (StatementAssignment) currentStmt;
LValue lValue = assignment.getlValue();
if(lValue instanceof VariableRef) {

43
src/main/java/dk/camelot64/kickc/passes/Pass2ConstantCastSimplification.java Normal file

@ -0,0 +1,43 @@
package dk.camelot64.kickc.passes;
import dk.camelot64.kickc.model.Program;
import dk.camelot64.kickc.model.iterator.ProgramExpression;
import dk.camelot64.kickc.model.iterator.ProgramExpressionIterator;
import dk.camelot64.kickc.model.iterator.ProgramExpressionUnary;
import dk.camelot64.kickc.model.operators.OperatorCast;
import dk.camelot64.kickc.model.types.SymbolType;
import dk.camelot64.kickc.model.values.ConstantInteger;
import dk.camelot64.kickc.model.values.ConstantValue;
import java.util.concurrent.atomic.AtomicBoolean;
/** Simplifies casts of (number) constants to a type. */
public class Pass2ConstantCastSimplification extends Pass2SsaOptimization {
public Pass2ConstantCastSimplification(Program program) {
super(program);
}
@Override
public boolean step() {
AtomicBoolean optimized = new AtomicBoolean(false);
ProgramExpressionIterator.execute(getProgram(), (programExpression, currentStmt, stmtIt, currentBlock) -> {
if(programExpression.getOperator() instanceof OperatorCast) {
OperatorCast operatorCast = (OperatorCast) programExpression.getOperator();
ProgramExpressionUnary unary = (ProgramExpressionUnary) programExpression;
if(unary.getOperand() instanceof ConstantInteger) {
ConstantInteger constantInteger = (ConstantInteger) unary.getOperand();
if(constantInteger.getType().equals(SymbolType.NUMBER)) {
SymbolType castType = operatorCast.getToType();
ConstantInteger newConstInt = new ConstantInteger(constantInteger.getInteger(), castType);
programExpression.set(newConstInt);
getLog().append("Simplifying constant integer cast "+newConstInt);
}
}
}
});
return optimized.get();
}
}

108
src/main/java/dk/camelot64/kickc/passes/PassNAddNumberTypeConversions.java

@ -1,15 +1,11 @@
package dk.camelot64.kickc.passes;
import dk.camelot64.kickc.model.CompileError;
import dk.camelot64.kickc.model.InternalError;
import dk.camelot64.kickc.model.Program;
import dk.camelot64.kickc.model.iterator.BinaryExpressionIterator;
import dk.camelot64.kickc.model.iterator.ProgramExpressionBinary;
import dk.camelot64.kickc.model.iterator.ProgramExpressionIterator;
import dk.camelot64.kickc.model.types.SymbolType;
import dk.camelot64.kickc.model.types.SymbolTypeConversion;
import dk.camelot64.kickc.model.types.SymbolTypeInference;
import dk.camelot64.kickc.model.types.SymbolTypeIntegerFixed;
import dk.camelot64.kickc.model.values.ConstantInteger;
import dk.camelot64.kickc.model.values.ConstantLiteral;
import dk.camelot64.kickc.model.values.ConstantValue;
import dk.camelot64.kickc.model.values.RValue;
/**
@ -23,89 +19,29 @@ public class PassNAddNumberTypeConversions extends Pass2SsaOptimization {
@Override
public boolean step() {
BinaryExpressionIterator.execute(getProgram(), (binaryExpression, currentStmt, stmtIt, currentBlock) -> {
RValue left = binaryExpression.getLeft();
RValue right = binaryExpression.getRight();
SymbolType conversionType = getNumberConversionType(left, right);
if(conversionType != null) {
// Convert both left and right to the found type
getLog().append("Adding number conversion cast (" + fixedType+ ") " + binaryExpression.getRight().toString() + " in " + currentStmt.toString(getProgram(), false));
ProgramExpressionIterator.execute(getProgram(), (binaryExpression, currentStmt, stmtIt, currentBlock) -> {
if(binaryExpression instanceof ProgramExpressionBinary) {
ProgramExpressionBinary binary = (ProgramExpressionBinary) binaryExpression;
RValue left = binary.getLeft();
RValue right = binary.getRight();
SymbolType conversionType = SymbolTypeConversion.convertedNumberType(left, right, getScope(), currentStmt);
if(conversionType != null) {
// Convert both left and right to the found type
SymbolType leftType = SymbolTypeInference.inferType(getProgram().getScope(), left);
if(!leftType.equals(conversionType)) {
getLog().append("Adding number conversion cast (" + conversionType + ") " + binary.getLeft().toString() + " in " + currentStmt.toString(getProgram(), false));
binary.addLeftCast(conversionType, stmtIt, currentBlock.getScope(), getScope());
}
SymbolType rightType = SymbolTypeInference.inferType(getProgram().getScope(), right);
if(!rightType.equals(conversionType)) {
getLog().append("Adding number conversion cast (" + conversionType + ") " + binary.getRight().toString() + " in " + currentStmt.toString(getProgram(), false));
binary.addRightCast(conversionType, stmtIt, currentBlock.getScope(), getScope());
}
}
}
});
return false;
}
private SymbolType getNumberConversionType(RValue left, RValue right) {
SymbolType leftType = SymbolTypeInference.inferType(getProgram().getScope(), left);
SymbolType rightType = SymbolTypeInference.inferType(getProgram().getScope(), right);
if(SymbolType.NUMBER.equals(leftType) || SymbolType.NUMBER.equals(rightType)) {
// A special type number is assigned to integer constants without a postfix literal.
// Numbers are flexible and will take a type based on their actual value when they meet a typed number in a calculation.
// Number types are only usable at compile time.
if(leftType.equals(rightType)) {
// a) If the two operands are numbers the result is a number
return null;
}
RValue numberVal;
SymbolTypeIntegerFixed fixedType;
if(SymbolType.NUMBER.equals(leftType) && SymbolType.isInteger(rightType)) {
// Left is the number
numberVal = left;
fixedType = (SymbolTypeIntegerFixed) rightType;
} else if(SymbolType.NUMBER.equals(rightType) && SymbolType.isInteger(leftType)) {
// Right is the number
numberVal = right;
fixedType = (SymbolTypeIntegerFixed) leftType;
} else {
// Non-integer number binary
throw new CompileError("Error! Incompatible operands "+left.toString()+" and "+right.toString());
}
if(numberVal instanceof ConstantValue) {
ConstantLiteral constantLiteral = ((ConstantValue) numberVal).calculateLiteral(getProgram().getScope());
if(constantLiteral instanceof ConstantInteger) {
ConstantInteger constantInteger = (ConstantInteger) constantLiteral;
if(SymbolType.NUMBER.equals(constantInteger.getType())) {
Long value = constantInteger.getValue();
if(fixedType.getMinValue() <= value && fixedType.getMaxValue() >= value) {
// The value matches the left type!
binaryExpression.addRightCast(leftIntType);
} else {
throw new InternalError("TODO: Implement number conversion for non-equal types " + right.toString(), currentStmt);
}
} else {
throw new InternalError("Non-number constant has type number " + right.toString(), currentStmt);
}
}
} else {
// Postpone til later!
// Maybe handle AssignmentRValue separately!
getLog().append("Postponed number conversion " + right.toString());
}
}
// No number conversion
return null;
if(SymbolType.isInteger(leftType) && !SymbolType.NUMBER.equals(leftType) && SymbolType.NUMBER.equals(rightType)) {
SymbolTypeIntegerFixed leftIntType = (SymbolTypeIntegerFixed) leftType;
// Attempt to find number conversion!
}
return null;
}
}

143
src/main/java/dk/camelot64/kickc/passes/PassNAddTypeConversions.java

@ -1,143 +0,0 @@
package dk.camelot64.kickc.passes;
import dk.camelot64.kickc.model.Comment;
import dk.camelot64.kickc.model.CompileError;
import dk.camelot64.kickc.model.ControlFlowBlock;
import dk.camelot64.kickc.model.Program;
import dk.camelot64.kickc.model.operators.Operators;
import dk.camelot64.kickc.model.statements.Statement;
import dk.camelot64.kickc.model.statements.StatementAssignment;
import dk.camelot64.kickc.model.symbols.Scope;
import dk.camelot64.kickc.model.symbols.VariableIntermediate;
import dk.camelot64.kickc.model.types.*;
import dk.camelot64.kickc.model.values.ConstantInteger;
import dk.camelot64.kickc.model.values.LValue;
import dk.camelot64.kickc.model.values.RValue;
import dk.camelot64.kickc.model.values.ScopeRef;
import java.util.List;
import java.util.ListIterator;
/**
* Add casts in all assignments where types are not equal, but the rValue type can be converted to the lValue type.
*/
public class PassNAddTypeConversions extends Pass2SsaOptimization {
public PassNAddTypeConversions(Program program) {
super(program);
}
@Override
public boolean step() {
for(ControlFlowBlock block : getProgram().getGraph().getAllBlocks()) {
List<Statement> statements = block.getStatements();
ListIterator<Statement> stmtIt = statements.listIterator();
while(stmtIt.hasNext()) {
Statement statement = stmtIt.next();
if(statement instanceof StatementAssignment) {
doConversionAssignment((StatementAssignment) statement, stmtIt, block);
}
// TODO: Implement conversion for calls
}
}
return false;
}
/**
* Examines an assignment to determine if a cast of the rValue is needed (the lvalue type and the rvalue type is not equal)
* and possible (the types are conversion compatible).
* <p>
* If a conversion is needed it is added by adding a new tmp-var with a cast and modifying the statement.
*
* @param assignment The assignment to examine
* @param stmtIt Iterator allowing the method to add a tmp-var-assignment.
*/
private void doConversionAssignment(StatementAssignment assignment, ListIterator<Statement> stmtIt, ControlFlowBlock block) {
LValue lValue = assignment.getlValue();
SymbolType lValueType = SymbolTypeInference.inferType(getScope(), lValue);
SymbolType rValueType = SymbolTypeInference.inferTypeRValue(getScope(), assignment);
if(lValueType.equals(rValueType)) {
return;
}
if(SymbolType.NUMBER.equals(rValueType)) {
// If the rValue is number type - find the potential types based on the literal value
List<SymbolTypeIntegerFixed> potentialTypes = SymbolTypeNumberInference.inferTypesRValue(getScope(), assignment);
if(potentialTypes.size()==0) {
// number type cannot be calculated currently - save for later
return;
}
for(SymbolTypeIntegerFixed potentialType : potentialTypes) {
if(lValueType.equals(potentialType) || canConvert(lValueType, potentialType)) {
addConversionCast(assignment, stmtIt, block, lValueType, rValueType);
return;
}
}
} else {
// No direct type match - attempt conversion
if(canConvert(lValueType, rValueType)) {
addConversionCast(assignment, stmtIt, block, lValueType, rValueType);
return;
}
}
// Conversion not possible - report a type error!
String msg = "ERROR! Type mismatch (" + lValueType.getTypeName() + ") cannot be assigned from (" + rValueType.getTypeName() + "). " +
"In " + assignment.toString(getProgram(), false);
getProgram().getLog().append(msg);
throw new CompileError(msg, assignment.getSource());
}
/**
* Add a conversion cast to the rvalue of an assignment
*
* @param assignment The assignment to add the cast to
* @param lValueType The type of the lValue
* @param rValueType The type of the rValue
*/
private void addConversionCast(StatementAssignment assignment, ListIterator<Statement> stmtIt, ControlFlowBlock currentBlock, SymbolType lValueType, SymbolType rValueType) {
// Promotion possible - add tmp-var and a cast
if(assignment.getOperator() == null) {
// No operator - add cast directly!
RValue rValue = assignment.getrValue2();
if((rValue instanceof ConstantInteger) && SymbolType.NUMBER.equals(((ConstantInteger) rValue).getType()) && SymbolType.isInteger(lValueType)) {
((ConstantInteger) rValue).setType(lValueType);
} else {
assignment.setOperator(Operators.getCastUnary(lValueType));
}
getLog().append("Converting " + rValueType + " to " + lValueType + " in " + assignment);
} else {
ScopeRef currentScope = currentBlock.getScope();
Scope blockScope = getScope().getScope(currentScope);
VariableIntermediate tmpVar = blockScope.addVariableIntermediate();
tmpVar.setType(rValueType);
StatementAssignment newAssignment = new StatementAssignment(assignment.getlValue(), Operators.getCastUnary(lValueType), tmpVar.getRef(), assignment.getSource(), Comment.NO_COMMENTS);
getLog().append("Converting " + rValueType + " to " + lValueType + " in " + assignment + " adding "+tmpVar);
assignment.setlValue(tmpVar.getRef());
stmtIt.add(newAssignment);
}
}
/**
* Determines if it is possible to convert one type to another
* as described in C99 6.3.1.8 http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf#page=70
*
* @param lValueType The type of the lValue
* @param rValueType The type of the rValue (that will be cast)
* @return True if a cast is possible without any loss
*/
private boolean canConvert(SymbolType lValueType, SymbolType rValueType) {
if(lValueType instanceof SymbolTypePointer && SymbolType.isWord(rValueType)) {
return true;
}
if(lValueType instanceof SymbolTypeInteger && rValueType instanceof SymbolTypeInteger) {
SymbolType convertedMathType = SymbolType.convertedMathType((SymbolTypeInteger) lValueType, (SymbolTypeInteger) rValueType);
if(lValueType.equals(convertedMathType)) {
return true;
}
}
// No type promotion found
return false;
}
}

55
src/main/java/dk/camelot64/kickc/passes/PassNAddTypeConversionsNew.java Normal file

@ -0,0 +1,55 @@
package dk.camelot64.kickc.passes;
import dk.camelot64.kickc.model.Program;
import dk.camelot64.kickc.model.iterator.ProgramExpressionBinary;
import dk.camelot64.kickc.model.iterator.ProgramExpressionIterator;
import dk.camelot64.kickc.model.types.*;
import dk.camelot64.kickc.model.values.RValue;
/**
* Add casts in binary expressions where left/right types are not equal according to the C99 type conversion rules
* 6.3.1.8 http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf#page=70.
*/
public class PassNAddTypeConversionsNew extends Pass2SsaOptimization {
public PassNAddTypeConversionsNew(Program program) {
super(program);
}
@Override
public boolean step() {
ProgramExpressionIterator.execute(getProgram(), (programExpression, currentStmt, stmtIt, currentBlock) -> {
if(programExpression instanceof ProgramExpressionBinary) {
ProgramExpressionBinary binary = (ProgramExpressionBinary) programExpression;
RValue left = binary.getLeft();
RValue right = binary.getRight();
SymbolType leftType = SymbolTypeInference.inferType(getProgram().getScope(), left);
SymbolType rightType = SymbolTypeInference.inferType(getProgram().getScope(), right);
// Special handling of assigning a pointer from an unsigned word
if((programExpression instanceof ProgramExpressionBinary.ProgramExpressionBinaryAssignmentLValue) && (leftType instanceof SymbolTypePointer) && SymbolType.isInteger(rightType)) {
getLog().append("Adding pointer type conversion cast (" + leftType + ") " + binary.getLeft().toString() + " in " + currentStmt.toString(getProgram(), false));
binary.addLeftCast(leftType, stmtIt, currentBlock.getScope(), getScope());
}
if(SymbolType.isInteger(leftType) && SymbolType.isInteger(rightType)) {
SymbolType conversionType = SymbolTypeConversion.convertedMathType((SymbolTypeInteger) leftType, (SymbolTypeInteger) rightType);
if(conversionType != null && !SymbolType.NUMBER.equals(conversionType)) {
// Convert both left and right to the found type
if(!leftType.equals(conversionType)) {
getLog().append("Adding type conversion cast (" + conversionType + ") " + binary.getLeft().toString() + " in " + currentStmt.toString(getProgram(), false));
binary.addLeftCast(conversionType, stmtIt, currentBlock.getScope(), getScope());
}
if(!rightType.equals(conversionType)) {
getLog().append("Adding type conversion cast (" + conversionType + ") " + binary.getRight().toString() + " in " + currentStmt.toString(getProgram(), false));
binary.addRightCast(conversionType, stmtIt, currentBlock.getScope(), getScope());
}
}
}
}
});
return false;
}
}

46
src/main/java/dk/camelot64/kickc/passes/Pass1TypeIdSimplification.java → src/main/java/dk/camelot64/kickc/passes/PassNTypeIdSimplification.java

@ -1,50 +1,63 @@
package dk.camelot64.kickc.passes;
import dk.camelot64.kickc.model.ControlFlowBlock;
import dk.camelot64.kickc.model.InternalError;
import dk.camelot64.kickc.model.Program;
import dk.camelot64.kickc.model.iterator.ProgramExpressionIterator;
import dk.camelot64.kickc.model.iterator.ProgramExpressionUnary;
import dk.camelot64.kickc.model.operators.OperatorTypeId;
import dk.camelot64.kickc.model.operators.Operators;
import dk.camelot64.kickc.model.statements.Statement;
import dk.camelot64.kickc.model.statements.StatementAssignment;
import dk.camelot64.kickc.model.types.SymbolType;
import dk.camelot64.kickc.model.types.SymbolTypeInference;
import dk.camelot64.kickc.model.types.SymbolTypeIntegerFixed;
import dk.camelot64.kickc.model.types.SymbolTypeNumberInference;
import dk.camelot64.kickc.model.values.ConstantLiteral;
import dk.camelot64.kickc.model.values.ConstantRef;
import dk.camelot64.kickc.model.values.ConstantValue;
import dk.camelot64.kickc.model.values.RValue;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Converts typeid() operators to constants
*/
public class Pass1TypeIdSimplification extends Pass1Base {
public class PassNTypeIdSimplification extends Pass2SsaOptimization {
public Pass1TypeIdSimplification(Program program) {
public PassNTypeIdSimplification(Program program) {
super(program);
}
@Override
public boolean step() {
boolean modified = false;
AtomicBoolean modified = new AtomicBoolean(false);
ProgramExpressionIterator.execute(getProgram(), (programExpression, currentStmt, stmtIt, currentBlock) -> {
if(programExpression instanceof ProgramExpressionUnary) {
ProgramExpressionUnary unary = (ProgramExpressionUnary) programExpression;
if(Operators.TYPEID.equals(unary.getOperator())) {
RValue rValue = unary.getOperand();
SymbolType symbolType = SymbolTypeInference.inferType(getScope(), rValue);
if(symbolType.equals(SymbolType.VAR) || symbolType.equals(SymbolType.NUMBER)) {
} else {
getLog().append("Resolving typeid() " + currentStmt.toString(getProgram(), false));
ConstantRef typeIDConstantVar = OperatorTypeId.getTypeIdConstantVar(getScope(), symbolType);
unary.set(typeIDConstantVar);
modified.set(true);
}
}
}
});
/*
for(ControlFlowBlock block : getGraph().getAllBlocks()) {
for(Statement statement : block.getStatements()) {
if(statement instanceof StatementAssignment) {
StatementAssignment assignment = (StatementAssignment) statement;
if(Operators.TYPEID.equals(assignment.getOperator())) {
RValue rValue = assignment.getrValue2();
SymbolType symbolType = SymbolTypeInference.inferType(getScope(), rValue);
SymbolType symbolType = SymbolTypeInference.inferType(getSymbols(), rValue);
if(SymbolType.NUMBER.equals(symbolType)) {
if(rValue instanceof ConstantValue) {
List<SymbolTypeIntegerFixed> fixedTypes = SymbolTypeNumberInference.inferTypes(getScope(), (ConstantLiteral) rValue);
List<SymbolTypeIntegerFixed> fixedTypes = SymbolTypeNumberInference.inferTypes(getSymbols(), (ConstantLiteral) rValue);
throw new InternalError("TODO: Implement typeof(const)!");
}
} else {
getLog().append("Resolving typeid() " + assignment.toString(getProgram(), false));
ConstantRef typeIDConstantVar = OperatorTypeId.getTypeIdConstantVar(getScope(), symbolType);
ConstantRef typeIDConstantVar = OperatorTypeId.getTypeIdConstantVar(getSymbols(), symbolType);
assignment.setrValue2(typeIDConstantVar);
assignment.setOperator(null);
modified = true;
@ -53,6 +66,7 @@ public class Pass1TypeIdSimplification extends Pass1Base {
}
}
}
return modified;
*/
return modified.get();
}
}

4
src/test/java/dk/camelot64/kickc/test/TestPrograms.java

@ -34,12 +34,12 @@ public class TestPrograms {
@Test
public void testNumberConversion() throws IOException, URISyntaxException {
compileAndCompare("number-conversion", log());
compileAndCompare("number-conversion");
}
@Test
public void testNumberType() throws IOException, URISyntaxException {
compileAndCompare("number-type");
compileAndCompare("number-type", log());
}
@Test

17
src/test/kc/number-conversion.kc

@ -10,15 +10,13 @@ void main() {
idx = 0ub;
assertType(typeid(12sb+12), typeid(signed byte));
assertType(typeid(12sb+130), typeid(signed word));
assertType(typeid(12sb+32000), typeid(signed dword));
assertType(typeid(12sb+33000), typeid(signed dword));
assertType(typeid(12sw+12), typeid(signed word));
assertType(typeid(12sw+130), typeid(signed word));
assertType(typeid(12sw+100000), typeid(signed dword));
assertType(typeid(12sd+12), typeid(signed dword));
assertType(typeid(12sd+130), typeid(signed dword));
assertType(typeid(12sd+100000), typeid(signed dword));
// Test number larger than largest signed type
assertType(typeid(12sb+3000000000), typeid(unsigned dword));
// Unsigned type and positive number
// b) If one operand is an unsigned type and the other a positive number.
@ -36,7 +34,7 @@ void main() {
assertType(typeid(12ud+12), typeid(unsigned dword));
assertType(typeid(12ud+130), typeid(unsigned dword));
assertType(typeid(12ud+66000), typeid(unsigned dword));
assertType(typeid(12sb+3000000000), typeid(unsigned dword));
assertType(typeid(12ub+3000000000), typeid(unsigned dword));
// Unsigned type and negative number
// If one operand is an unsigned type and the other a negative number.
@ -47,16 +45,19 @@ void main() {
idx = 80ub;
assertType(typeid(12ub+-12), typeid(unsigned byte));
assertType(typeid(12ub+-120), typeid(unsigned byte));
assertType(typeid(12ub+-250), typeid(unsigned word));
assertType(typeid(12ub+-32000), typeid(unsigned dword));
assertType(typeid(12ub+-250), typeid(unsigned byte));
assertType(typeid(12ub+-260), typeid(unsigned word));
assertType(typeid(12ub+-65000), typeid(unsigned word));
assertType(typeid(12ub+-66000), typeid(unsigned dword));
assertType(typeid(12uw+-12), typeid(unsigned word));
assertType(typeid(12uw+-130), typeid(unsigned word));
assertType(typeid(12uw+-32000), typeid(unsigned dword));
assertType(typeid(12uw+-65000), typeid(unsigned word));
assertType(typeid(12uw+-66000), typeid(unsigned dword));
assertType(typeid(12ud+-12), typeid(unsigned dword));
assertType(typeid(12ud+-130), typeid(unsigned dword));
assertType(typeid(12ud+-66000), typeid(unsigned dword));
assertType(typeid(12sb+-3000000000), typeid(unsigned dword));
assertType(typeid(12sb+-2100000000), typeid(unsigned dword));
}

242
src/test/ref/int-conversion.asm Normal file

@ -0,0 +1,242 @@
// Tests different integer literal types
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const TYPEID_BYTE = 1
.const TYPEID_SIGNED_BYTE = 2
.const TYPEID_WORD = 3
.const TYPEID_SIGNED_WORD = 4
.const TYPEID_DWORD = 5
.const TYPEID_SIGNED_DWORD = 6
.const RED = 2
.const GREEN = 5
.label SCREEN = $400
.label COLS = $d800
main: {
.label s = 2
lda #<SCREEN
sta s
lda #>SCREEN
sta s+1
b1:
lda #' '
ldy #0
sta (s),y
inc s
bne !+
inc s+1
!:
lda s+1
cmp #>SCREEN+$3e8
bcc b1
bne !+
lda s
cmp #<SCREEN+$3e8
bcc b1
!:
jsr testUnaryOperator
jsr testBinaryOperator
rts
}
testBinaryOperator: {
ldx #$28
lda #TYPEID_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
inx
lda #TYPEID_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
inx
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
ldx #$50
lda #TYPEID_SIGNED_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
inx
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
inx
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
rts
}
// Check that the two passed type IDs are equal.
// Shows a letter symbolizing t1
// If they are equal the letter is green - if not it is red.
// assertType(byte register(Y) t1, byte zeropage(4) t2)
assertType: {
.label t2 = 4
tya
cmp t2
beq b1
lda #RED
sta COLS,x
b2:
tya
sta SCREEN,x
inx
rts
b1:
lda #GREEN
sta COLS,x
jmp b2
}
testUnaryOperator: {
ldx #0
lda #TYPEID_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
rts
}

222
src/test/ref/int-conversion.cfg Normal file

@ -0,0 +1,222 @@
@begin: scope:[] from
[0] phi()
to:@1
@1: scope:[] from @begin
[1] phi()
[2] call main
to:@end
@end: scope:[] from @1
[3] phi()
main: scope:[main] from @1
[4] phi()
to:main::@1
main::@1: scope:[main] from main main::@1
[5] (byte*) main::s#2 ← phi( main/(const byte*) SCREEN#0 main::@1/(byte*) main::s#1 )
[6] *((byte*) main::s#2) ← (byte) ' '
[7] (byte*) main::s#1 ← ++ (byte*) main::s#2
[8] if((byte*) main::s#1<(const byte*) SCREEN#0+(word) $3e8) goto main::@1
to:main::@2
main::@2: scope:[main] from main::@1
[9] phi()
[10] call testUnaryOperator
to:main::@3
main::@3: scope:[main] from main::@2
[11] phi()
[12] call testBinaryOperator
to:main::@return
main::@return: scope:[main] from main::@3
[13] return
to:@return
testBinaryOperator: scope:[testBinaryOperator] from main::@3
[14] phi()
[15] call assertType
to:testBinaryOperator::@1
testBinaryOperator::@1: scope:[testBinaryOperator] from testBinaryOperator
[16] phi()
[17] call assertType
to:testBinaryOperator::@2
testBinaryOperator::@2: scope:[testBinaryOperator] from testBinaryOperator::@1
[18] phi()
[19] call assertType
to:testBinaryOperator::@3
testBinaryOperator::@3: scope:[testBinaryOperator] from testBinaryOperator::@2
[20] phi()
[21] call assertType
to:testBinaryOperator::@4
testBinaryOperator::@4: scope:[testBinaryOperator] from testBinaryOperator::@3
[22] phi()
[23] call assertType
to:testBinaryOperator::@5
testBinaryOperator::@5: scope:[testBinaryOperator] from testBinaryOperator::@4
[24] phi()
[25] call assertType
to:testBinaryOperator::@6
testBinaryOperator::@6: scope:[testBinaryOperator] from testBinaryOperator::@5
[26] (byte) idx#19 ← ++ (byte) idx#108
[27] call assertType
to:testBinaryOperator::@7
testBinaryOperator::@7: scope:[testBinaryOperator] from testBinaryOperator::@6
[28] phi()
[29] call assertType
to:testBinaryOperator::@8
testBinaryOperator::@8: scope:[testBinaryOperator] from testBinaryOperator::@7
[30] phi()
[31] call assertType
to:testBinaryOperator::@9
testBinaryOperator::@9: scope:[testBinaryOperator] from testBinaryOperator::@8
[32] phi()
[33] call assertType
to:testBinaryOperator::@10
testBinaryOperator::@10: scope:[testBinaryOperator] from testBinaryOperator::@9
[34] phi()
[35] call assertType
to:testBinaryOperator::@11
testBinaryOperator::@11: scope:[testBinaryOperator] from testBinaryOperator::@10
[36] phi()
[37] call assertType
to:testBinaryOperator::@12
testBinaryOperator::@12: scope:[testBinaryOperator] from testBinaryOperator::@11
[38] (byte) idx#26 ← ++ (byte) idx#108
[39] call assertType
to:testBinaryOperator::@13
testBinaryOperator::@13: scope:[testBinaryOperator] from testBinaryOperator::@12
[40] phi()
[41] call assertType
to:testBinaryOperator::@14
testBinaryOperator::@14: scope:[testBinaryOperator] from testBinaryOperator::@13
[42] phi()
[43] call assertType
to:testBinaryOperator::@15
testBinaryOperator::@15: scope:[testBinaryOperator] from testBinaryOperator::@14
[44] phi()
[45] call assertType
to:testBinaryOperator::@16
testBinaryOperator::@16: scope:[testBinaryOperator] from testBinaryOperator::@15
[46] phi()
[47] call assertType
to:testBinaryOperator::@17
testBinaryOperator::@17: scope:[testBinaryOperator] from testBinaryOperator::@16
[48] phi()
[49] call assertType
to:testBinaryOperator::@18
testBinaryOperator::@18: scope:[testBinaryOperator] from testBinaryOperator::@17
[50] phi()
[51] call assertType
to:testBinaryOperator::@19
testBinaryOperator::@19: scope:[testBinaryOperator] from testBinaryOperator::@18
[52] phi()
[53] call assertType
to:testBinaryOperator::@20
testBinaryOperator::@20: scope:[testBinaryOperator] from testBinaryOperator::@19
[54] phi()
[55] call assertType
to:testBinaryOperator::@21
testBinaryOperator::@21: scope:[testBinaryOperator] from testBinaryOperator::@20
[56] phi()
[57] call assertType
to:testBinaryOperator::@22
testBinaryOperator::@22: scope:[testBinaryOperator] from testBinaryOperator::@21
[58] phi()
[59] call assertType
to:testBinaryOperator::@23
testBinaryOperator::@23: scope:[testBinaryOperator] from testBinaryOperator::@22
[60] phi()
[61] call assertType
to:testBinaryOperator::@24
testBinaryOperator::@24: scope:[testBinaryOperator] from testBinaryOperator::@23
[62] (byte) idx#40 ← ++ (byte) idx#108
[63] call assertType
to:testBinaryOperator::@25
testBinaryOperator::@25: scope:[testBinaryOperator] from testBinaryOperator::@24
[64] phi()
[65] call assertType
to:testBinaryOperator::@26
testBinaryOperator::@26: scope:[testBinaryOperator] from testBinaryOperator::@25
[66] phi()
[67] call assertType
to:testBinaryOperator::@27
testBinaryOperator::@27: scope:[testBinaryOperator] from testBinaryOperator::@26
[68] phi()
[69] call assertType
to:testBinaryOperator::@28
testBinaryOperator::@28: scope:[testBinaryOperator] from testBinaryOperator::@27
[70] phi()
[71] call assertType
to:testBinaryOperator::@29
testBinaryOperator::@29: scope:[testBinaryOperator] from testBinaryOperator::@28
[72] phi()
[73] call assertType
to:testBinaryOperator::@30
testBinaryOperator::@30: scope:[testBinaryOperator] from testBinaryOperator::@29
[74] (byte) idx#47 ← ++ (byte) idx#108
[75] call assertType
to:testBinaryOperator::@31
testBinaryOperator::@31: scope:[testBinaryOperator] from testBinaryOperator::@30
[76] phi()
[77] call assertType
to:testBinaryOperator::@32
testBinaryOperator::@32: scope:[testBinaryOperator] from testBinaryOperator::@31
[78] phi()
[79] call assertType
to:testBinaryOperator::@33
testBinaryOperator::@33: scope:[testBinaryOperator] from testBinaryOperator::@32
[80] phi()
[81] call assertType
to:testBinaryOperator::@34
testBinaryOperator::@34: scope:[testBinaryOperator] from testBinaryOperator::@33
[82] phi()
[83] call assertType
to:testBinaryOperator::@35
testBinaryOperator::@35: scope:[testBinaryOperator] from testBinaryOperator::@34
[84] phi()
[85] call assertType
to:testBinaryOperator::@return
testBinaryOperator::@return: scope:[testBinaryOperator] from testBinaryOperator::@35
[86] return
to:@return
assertType: scope:[assertType] from testBinaryOperator testBinaryOperator::@1 testBinaryOperator::@10 testBinaryOperator::@11 testBinaryOperator::@12 testBinaryOperator::@13 testBinaryOperator::@14 testBinaryOperator::@15 testBinaryOperator::@16 testBinaryOperator::@17 testBinaryOperator::@18 testBinaryOperator::@19 testBinaryOperator::@2 testBinaryOperator::@20 testBinaryOperator::@21 testBinaryOperator::@22 testBinaryOperator::@23 testBinaryOperator::@24 testBinaryOperator::@25 testBinaryOperator::@26 testBinaryOperator::@27 testBinaryOperator::@28 testBinaryOperator::@29 testBinaryOperator::@3 testBinaryOperator::@30 testBinaryOperator::@31 testBinaryOperator::@32 testBinaryOperator::@33 testBinaryOperator::@34 testBinaryOperator::@35 testBinaryOperator::@4 testBinaryOperator::@5 testBinaryOperator::@6 testBinaryOperator::@7 testBinaryOperator::@8 testBinaryOperator::@9 testUnaryOperator testUnaryOperator::@1 testUnaryOperator::@2 testUnaryOperator::@3 testUnaryOperator::@4 testUnaryOperator::@5
[87] (byte) idx#105 ← phi( testBinaryOperator/(byte) $28 testBinaryOperator::@1/(byte) idx#108 testBinaryOperator::@10/(byte) idx#108 testBinaryOperator::@11/(byte) idx#108 testBinaryOperator::@12/(byte) idx#26 testBinaryOperator::@13/(byte) idx#108 testBinaryOperator::@14/(byte) idx#108 testBinaryOperator::@15/(byte) idx#108 testBinaryOperator::@16/(byte) idx#108 testBinaryOperator::@17/(byte) idx#108 testBinaryOperator::@18/(byte) $50 testBinaryOperator::@19/(byte) idx#108 testBinaryOperator::@2/(byte) idx#108 testBinaryOperator::@20/(byte) idx#108 testBinaryOperator::@21/(byte) idx#108 testBinaryOperator::@22/(byte) idx#108 testBinaryOperator::@23/(byte) idx#108 testBinaryOperator::@24/(byte) idx#40 testBinaryOperator::@25/(byte) idx#108 testBinaryOperator::@26/(byte) idx#108 testBinaryOperator::@27/(byte) idx#108 testBinaryOperator::@28/(byte) idx#108 testBinaryOperator::@29/(byte) idx#108 testBinaryOperator::@3/(byte) idx#108 testBinaryOperator::@30/(byte) idx#47 testBinaryOperator::@31/(byte) idx#108 testBinaryOperator::@32/(byte) idx#108 testBinaryOperator::@33/(byte) idx#108 testBinaryOperator::@34/(byte) idx#108 testBinaryOperator::@35/(byte) idx#108 testBinaryOperator::@4/(byte) idx#108 testBinaryOperator::@5/(byte) idx#108 testBinaryOperator::@6/(byte) idx#19 testBinaryOperator::@7/(byte) idx#108 testBinaryOperator::@8/(byte) idx#108 testBinaryOperator::@9/(byte) idx#108 testUnaryOperator/(byte) 0 testUnaryOperator::@1/(byte) idx#108 testUnaryOperator::@2/(byte) idx#108 testUnaryOperator::@3/(byte) idx#108 testUnaryOperator::@4/(byte) idx#108 testUnaryOperator::@5/(byte) idx#108 )
[87] (byte) assertType::t2#42 ← phi( testBinaryOperator/(const byte) TYPEID_BYTE testBinaryOperator::@1/(const byte) TYPEID_BYTE testBinaryOperator::@10/(const byte) TYPEID_DWORD testBinaryOperator::@11/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@12/(const byte) TYPEID_WORD testBinaryOperator::@13/(const byte) TYPEID_WORD testBinaryOperator::@14/(const byte) TYPEID_WORD testBinaryOperator::@15/(const byte) TYPEID_WORD testBinaryOperator::@16/(const byte) TYPEID_DWORD testBinaryOperator::@17/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@18/(const byte) TYPEID_SIGNED_WORD testBinaryOperator::@19/(const byte) TYPEID_SIGNED_WORD testBinaryOperator::@2/(const byte) TYPEID_WORD testBinaryOperator::@20/(const byte) TYPEID_WORD testBinaryOperator::@21/(const byte) TYPEID_SIGNED_WORD testBinaryOperator::@22/(const byte) TYPEID_DWORD testBinaryOperator::@23/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@24/(const byte) TYPEID_DWORD testBinaryOperator::@25/(const byte) TYPEID_DWORD testBinaryOperator::@26/(const byte) TYPEID_DWORD testBinaryOperator::@27/(const byte) TYPEID_DWORD testBinaryOperator::@28/(const byte) TYPEID_DWORD testBinaryOperator::@29/(const byte) TYPEID_DWORD testBinaryOperator::@3/(const byte) TYPEID_SIGNED_WORD testBinaryOperator::@30/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@31/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@32/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@33/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@34/(const byte) TYPEID_DWORD testBinaryOperator::@35/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@4/(const byte) TYPEID_DWORD testBinaryOperator::@5/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@6/(const byte) TYPEID_BYTE testBinaryOperator::@7/(const byte) TYPEID_SIGNED_BYTE testBinaryOperator::@8/(const byte) TYPEID_WORD testBinaryOperator::@9/(const byte) TYPEID_SIGNED_WORD testUnaryOperator/(const byte) TYPEID_BYTE testUnaryOperator::@1/(const byte) TYPEID_SIGNED_BYTE testUnaryOperator::@2/(const byte) TYPEID_WORD testUnaryOperator::@3/(const byte) TYPEID_SIGNED_WORD testUnaryOperator::@4/(const byte) TYPEID_DWORD testUnaryOperator::@5/(const byte) TYPEID_SIGNED_DWORD )
[87] (byte) assertType::t1#42 ← phi( testBinaryOperator/(const byte) TYPEID_BYTE testBinaryOperator::@1/(const byte) TYPEID_BYTE testBinaryOperator::@10/(const byte) TYPEID_DWORD testBinaryOperator::@11/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@12/(const byte) TYPEID_WORD testBinaryOperator::@13/(const byte) TYPEID_WORD testBinaryOperator::@14/(const byte) TYPEID_WORD testBinaryOperator::@15/(const byte) TYPEID_WORD testBinaryOperator::@16/(const byte) TYPEID_DWORD testBinaryOperator::@17/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@18/(const byte) TYPEID_SIGNED_WORD testBinaryOperator::@19/(const byte) TYPEID_SIGNED_WORD testBinaryOperator::@2/(const byte) TYPEID_WORD testBinaryOperator::@20/(const byte) TYPEID_WORD testBinaryOperator::@21/(const byte) TYPEID_SIGNED_WORD testBinaryOperator::@22/(const byte) TYPEID_DWORD testBinaryOperator::@23/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@24/(const byte) TYPEID_DWORD testBinaryOperator::@25/(const byte) TYPEID_DWORD testBinaryOperator::@26/(const byte) TYPEID_DWORD testBinaryOperator::@27/(const byte) TYPEID_DWORD testBinaryOperator::@28/(const byte) TYPEID_DWORD testBinaryOperator::@29/(const byte) TYPEID_DWORD testBinaryOperator::@3/(const byte) TYPEID_SIGNED_WORD testBinaryOperator::@30/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@31/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@32/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@33/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@34/(const byte) TYPEID_DWORD testBinaryOperator::@35/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@4/(const byte) TYPEID_DWORD testBinaryOperator::@5/(const byte) TYPEID_SIGNED_DWORD testBinaryOperator::@6/(const byte) TYPEID_BYTE testBinaryOperator::@7/(const byte) TYPEID_SIGNED_BYTE testBinaryOperator::@8/(const byte) TYPEID_WORD testBinaryOperator::@9/(const byte) TYPEID_SIGNED_WORD testUnaryOperator/(const byte) TYPEID_BYTE testUnaryOperator::@1/(const byte) TYPEID_SIGNED_BYTE testUnaryOperator::@2/(const byte) TYPEID_WORD testUnaryOperator::@3/(const byte) TYPEID_SIGNED_WORD testUnaryOperator::@4/(const byte) TYPEID_DWORD testUnaryOperator::@5/(const byte) TYPEID_SIGNED_DWORD )
[88] if((byte) assertType::t1#42==(byte) assertType::t2#42) goto assertType::@1
to:assertType::@3
assertType::@3: scope:[assertType] from assertType
[89] *((const byte*) COLS#0 + (byte) idx#105) ← (const byte) RED#0
to:assertType::@2
assertType::@2: scope:[assertType] from assertType::@1 assertType::@3
[90] *((const byte*) SCREEN#0 + (byte) idx#105) ← (byte) assertType::t1#42
[91] (byte) idx#108 ← ++ (byte) idx#105
to:assertType::@return
assertType::@return: scope:[assertType] from assertType::@2
[92] return
to:@return
assertType::@1: scope:[assertType] from assertType
[93] *((const byte*) COLS#0 + (byte) idx#105) ← (const byte) GREEN#0
to:assertType::@2
testUnaryOperator: scope:[testUnaryOperator] from main::@2
[94] phi()
[95] call assertType
to:testUnaryOperator::@1
testUnaryOperator::@1: scope:[testUnaryOperator] from testUnaryOperator
[96] phi()
[97] call assertType
to:testUnaryOperator::@2
testUnaryOperator::@2: scope:[testUnaryOperator] from testUnaryOperator::@1
[98] phi()
[99] call assertType
to:testUnaryOperator::@3
testUnaryOperator::@3: scope:[testUnaryOperator] from testUnaryOperator::@2
[100] phi()
[101] call assertType
to:testUnaryOperator::@4
testUnaryOperator::@4: scope:[testUnaryOperator] from testUnaryOperator::@3
[102] phi()
[103] call assertType
to:testUnaryOperator::@5
testUnaryOperator::@5: scope:[testUnaryOperator] from testUnaryOperator::@4
[104] phi()
[105] call assertType
to:testUnaryOperator::@return
testUnaryOperator::@return: scope:[testUnaryOperator] from testUnaryOperator::@5
[106] return
to:@return

4159
src/test/ref/int-conversion.log Normal file

File diff suppressed because it is too large Load Diff

90
src/test/ref/int-conversion.sym Normal file

@ -0,0 +1,90 @@
(label) @1
(label) @begin
(label) @end
(byte*) COLS
(const byte*) COLS#0 COLS = ((byte*))(word) $d800
(byte) GREEN
(const byte) GREEN#0 GREEN = (byte) 5
(byte) RED
(const byte) RED#0 RED = (byte) 2
(byte*) SCREEN
(const byte*) SCREEN#0 SCREEN = ((byte*))(word) $400
(const byte) TYPEID_BYTE TYPEID_BYTE = (number) 1
(const byte) TYPEID_DWORD TYPEID_DWORD = (number) 5
(const byte) TYPEID_SIGNED_BYTE TYPEID_SIGNED_BYTE = (number) 2
(const byte) TYPEID_SIGNED_DWORD TYPEID_SIGNED_DWORD = (number) 6
(const byte) TYPEID_SIGNED_WORD TYPEID_SIGNED_WORD = (number) 4
(const byte) TYPEID_WORD TYPEID_WORD = (number) 3
(void()) assertType((byte) assertType::t1 , (byte) assertType::t2)
(label) assertType::@1
(label) assertType::@2
(label) assertType::@3
(label) assertType::@return
(byte) assertType::t1
(byte) assertType::t1#42 reg byte y 1.0
(byte) assertType::t2
(byte) assertType::t2#42 t2 zp ZP_BYTE:4 2.0
(byte) idx
(byte) idx#105 reg byte x 17.200000000000003
(byte) idx#108 reg byte x 1.0526315789473677
(byte) idx#19 reg byte x 4.0
(byte) idx#26 reg byte x 4.0
(byte) idx#40 reg byte x 4.0
(byte) idx#47 reg byte x 4.0
(void()) main()
(label) main::@1
(label) main::@2
(label) main::@3
(label) main::@return
(byte*) main::s
(byte*) main::s#1 s zp ZP_WORD:2 16.5
(byte*) main::s#2 s zp ZP_WORD:2 16.5
(void()) testBinaryOperator()
(label) testBinaryOperator::@1
(label) testBinaryOperator::@10
(label) testBinaryOperator::@11
(label) testBinaryOperator::@12
(label) testBinaryOperator::@13
(label) testBinaryOperator::@14
(label) testBinaryOperator::@15
(label) testBinaryOperator::@16
(label) testBinaryOperator::@17
(label) testBinaryOperator::@18
(label) testBinaryOperator::@19
(label) testBinaryOperator::@2
(label) testBinaryOperator::@20
(label) testBinaryOperator::@21
(label) testBinaryOperator::@22
(label) testBinaryOperator::@23
(label) testBinaryOperator::@24
(label) testBinaryOperator::@25
(label) testBinaryOperator::@26
(label) testBinaryOperator::@27
(label) testBinaryOperator::@28
(label) testBinaryOperator::@29
(label) testBinaryOperator::@3
(label) testBinaryOperator::@30
(label) testBinaryOperator::@31
(label) testBinaryOperator::@32
(label) testBinaryOperator::@33
(label) testBinaryOperator::@34
(label) testBinaryOperator::@35
(label) testBinaryOperator::@4
(label) testBinaryOperator::@5
(label) testBinaryOperator::@6
(label) testBinaryOperator::@7
(label) testBinaryOperator::@8
(label) testBinaryOperator::@9
(label) testBinaryOperator::@return
(void()) testUnaryOperator()
(label) testUnaryOperator::@1
(label) testUnaryOperator::@2
(label) testUnaryOperator::@3
(label) testUnaryOperator::@4
(label) testUnaryOperator::@5
(label) testUnaryOperator::@return
zp ZP_WORD:2 [ main::s#2 main::s#1 ]
reg byte y [ assertType::t1#42 ]
zp ZP_BYTE:4 [ assertType::t2#42 ]
reg byte x [ idx#105 idx#108 idx#26 idx#40 idx#47 idx#19 ]

122
src/test/ref/int-literals.asm Normal file

@ -0,0 +1,122 @@
// Tests different integer literal types
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const TYPEID_BYTE = 1
.const TYPEID_SIGNED_BYTE = 2
.const TYPEID_WORD = 3
.const TYPEID_SIGNED_WORD = 4
.const TYPEID_DWORD = 5
.const TYPEID_SIGNED_DWORD = 6
.const RED = 2
.const GREEN = 5
main: {
.label s = 2
lda #<$400
sta s
lda #>$400
sta s+1
b1:
lda #' '
ldy #0
sta (s),y
inc s
bne !+
inc s+1
!:
lda s+1
cmp #>$400+$3e8
bcc b1
bne !+
lda s
cmp #<$400+$3e8
bcc b1
!:
jsr testSimpleTypes
rts
}
testSimpleTypes: {
ldx #0
lda #TYPEID_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
rts
}
// Check that the two passed type IDs are equal.
// Shows a letter symbolizing t1
// If they are equal the letter is green - if not it is red.
// assertType(byte register(Y) t1, byte zeropage(4) t2)
assertType: {
.label t2 = 4
tya
cmp t2
beq b1
lda #RED
sta $d800,x
b2:
tya
sta $400,x
inx
rts
b1:
lda #GREEN
sta $d800,x
jmp b2
}

107
src/test/ref/int-literals.cfg Normal file

@ -0,0 +1,107 @@
@begin: scope:[] from
[0] phi()
to:@1
@1: scope:[] from @begin
[1] phi()
[2] call main
to:@end
@end: scope:[] from @1
[3] phi()
main: scope:[main] from @1
[4] phi()
to:main::@1
main::@1: scope:[main] from main main::@1
[5] (byte*) main::s#2 ← phi( main/(byte*)(word) $400 main::@1/(byte*) main::s#1 )
[6] *((byte*) main::s#2) ← (byte) ' '
[7] (byte*) main::s#1 ← ++ (byte*) main::s#2
[8] if((byte*) main::s#1<(byte*)(word) $400+(word) $3e8) goto main::@1
to:main::@2
main::@2: scope:[main] from main::@1
[9] phi()
[10] call testSimpleTypes
to:main::@return
main::@return: scope:[main] from main::@2
[11] return
to:@return
testSimpleTypes: scope:[testSimpleTypes] from main::@2
[12] phi()
[13] call assertType
to:testSimpleTypes::@1
testSimpleTypes::@1: scope:[testSimpleTypes] from testSimpleTypes
[14] phi()
[15] call assertType
to:testSimpleTypes::@2
testSimpleTypes::@2: scope:[testSimpleTypes] from testSimpleTypes::@1
[16] phi()
[17] call assertType
to:testSimpleTypes::@3
testSimpleTypes::@3: scope:[testSimpleTypes] from testSimpleTypes::@2
[18] phi()
[19] call assertType
to:testSimpleTypes::@4
testSimpleTypes::@4: scope:[testSimpleTypes] from testSimpleTypes::@3
[20] phi()
[21] call assertType
to:testSimpleTypes::@5
testSimpleTypes::@5: scope:[testSimpleTypes] from testSimpleTypes::@4
[22] phi()
[23] call assertType
to:testSimpleTypes::@6
testSimpleTypes::@6: scope:[testSimpleTypes] from testSimpleTypes::@5
[24] phi()
[25] call assertType
to:testSimpleTypes::@7
testSimpleTypes::@7: scope:[testSimpleTypes] from testSimpleTypes::@6
[26] phi()
[27] call assertType
to:testSimpleTypes::@8
testSimpleTypes::@8: scope:[testSimpleTypes] from testSimpleTypes::@7
[28] phi()
[29] call assertType
to:testSimpleTypes::@9
testSimpleTypes::@9: scope:[testSimpleTypes] from testSimpleTypes::@8
[30] phi()
[31] call assertType
to:testSimpleTypes::@10
testSimpleTypes::@10: scope:[testSimpleTypes] from testSimpleTypes::@9
[32] phi()
[33] call assertType
to:testSimpleTypes::@11
testSimpleTypes::@11: scope:[testSimpleTypes] from testSimpleTypes::@10
[34] phi()
[35] call assertType
to:testSimpleTypes::@12
testSimpleTypes::@12: scope:[testSimpleTypes] from testSimpleTypes::@11
[36] phi()
[37] call assertType
to:testSimpleTypes::@13
testSimpleTypes::@13: scope:[testSimpleTypes] from testSimpleTypes::@12
[38] phi()
[39] call assertType
to:testSimpleTypes::@14
testSimpleTypes::@14: scope:[testSimpleTypes] from testSimpleTypes::@13
[40] phi()
[41] call assertType
to:testSimpleTypes::@return
testSimpleTypes::@return: scope:[testSimpleTypes] from testSimpleTypes::@14
[42] return
to:@return
assertType: scope:[assertType] from testSimpleTypes testSimpleTypes::@1 testSimpleTypes::@10 testSimpleTypes::@11 testSimpleTypes::@12 testSimpleTypes::@13 testSimpleTypes::@14 testSimpleTypes::@2 testSimpleTypes::@3 testSimpleTypes::@4 testSimpleTypes::@5 testSimpleTypes::@6 testSimpleTypes::@7 testSimpleTypes::@8 testSimpleTypes::@9
[43] (byte) idx#41 ← phi( testSimpleTypes/(byte) 0 testSimpleTypes::@1/(byte) idx#20 testSimpleTypes::@10/(byte) idx#20 testSimpleTypes::@11/(byte) idx#20 testSimpleTypes::@12/(byte) idx#20 testSimpleTypes::@13/(byte) idx#20 testSimpleTypes::@14/(byte) idx#20 testSimpleTypes::@2/(byte) idx#20 testSimpleTypes::@3/(byte) idx#20 testSimpleTypes::@4/(byte) idx#20 testSimpleTypes::@5/(byte) idx#20 testSimpleTypes::@6/(byte) idx#20 testSimpleTypes::@7/(byte) idx#20 testSimpleTypes::@8/(byte) idx#20 testSimpleTypes::@9/(byte) idx#20 )
[43] (byte) assertType::t2#15 ← phi( testSimpleTypes/(const byte) TYPEID_BYTE testSimpleTypes::@1/(const byte) TYPEID_BYTE testSimpleTypes::@10/(const byte) TYPEID_DWORD testSimpleTypes::@11/(const byte) TYPEID_DWORD testSimpleTypes::@12/(const byte) TYPEID_SIGNED_DWORD testSimpleTypes::@13/(const byte) TYPEID_SIGNED_DWORD testSimpleTypes::@14/(const byte) TYPEID_SIGNED_DWORD testSimpleTypes::@2/(const byte) TYPEID_SIGNED_BYTE testSimpleTypes::@3/(const byte) TYPEID_SIGNED_BYTE testSimpleTypes::@4/(const byte) TYPEID_WORD testSimpleTypes::@5/(const byte) TYPEID_WORD testSimpleTypes::@6/(const byte) TYPEID_WORD testSimpleTypes::@7/(const byte) TYPEID_SIGNED_WORD testSimpleTypes::@8/(const byte) TYPEID_SIGNED_WORD testSimpleTypes::@9/(const byte) TYPEID_SIGNED_WORD )
[43] (byte) assertType::t1#15 ← phi( testSimpleTypes/(const byte) TYPEID_BYTE testSimpleTypes::@1/(const byte) TYPEID_BYTE testSimpleTypes::@10/(const byte) TYPEID_DWORD testSimpleTypes::@11/(const byte) TYPEID_DWORD testSimpleTypes::@12/(const byte) TYPEID_SIGNED_DWORD testSimpleTypes::@13/(const byte) TYPEID_SIGNED_DWORD testSimpleTypes::@14/(const byte) TYPEID_SIGNED_DWORD testSimpleTypes::@2/(const byte) TYPEID_SIGNED_BYTE testSimpleTypes::@3/(const byte) TYPEID_SIGNED_BYTE testSimpleTypes::@4/(const byte) TYPEID_WORD testSimpleTypes::@5/(const byte) TYPEID_WORD testSimpleTypes::@6/(const byte) TYPEID_WORD testSimpleTypes::@7/(const byte) TYPEID_SIGNED_WORD testSimpleTypes::@8/(const byte) TYPEID_SIGNED_WORD testSimpleTypes::@9/(const byte) TYPEID_SIGNED_WORD )
[44] if((byte) assertType::t1#15==(byte) assertType::t2#15) goto assertType::@1
to:assertType::@3
assertType::@3: scope:[assertType] from assertType
[45] *((byte*)(word) $d800 + (byte) idx#41) ← (const byte) RED#0
to:assertType::@2
assertType::@2: scope:[assertType] from assertType::@1 assertType::@3
[46] *((byte*)(word) $400 + (byte) idx#41) ← (byte) assertType::t1#15
[47] (byte) idx#20 ← ++ (byte) idx#41
to:assertType::@return
assertType::@return: scope:[assertType] from assertType::@2
[48] return
to:@return
assertType::@1: scope:[assertType] from assertType
[49] *((byte*)(word) $d800 + (byte) idx#41) ← (const byte) GREEN#0
to:assertType::@2

1947
src/test/ref/int-literals.log Normal file

File diff suppressed because it is too large Load Diff

55
src/test/ref/int-literals.sym Normal file

@ -0,0 +1,55 @@
(label) @1
(label) @begin
(label) @end
(byte*) COLS
(byte) GREEN
(const byte) GREEN#0 GREEN = (byte) 5
(byte) RED
(const byte) RED#0 RED = (byte) 2
(byte*) SCREEN
(const byte) TYPEID_BYTE TYPEID_BYTE = (number) 1
(const byte) TYPEID_DWORD TYPEID_DWORD = (number) 5
(const byte) TYPEID_SIGNED_BYTE TYPEID_SIGNED_BYTE = (number) 2
(const byte) TYPEID_SIGNED_DWORD TYPEID_SIGNED_DWORD = (number) 6
(const byte) TYPEID_SIGNED_WORD TYPEID_SIGNED_WORD = (number) 4
(const byte) TYPEID_WORD TYPEID_WORD = (number) 3
(void()) assertType((byte) assertType::t1 , (byte) assertType::t2)
(label) assertType::@1
(label) assertType::@2
(label) assertType::@3
(label) assertType::@return
(byte) assertType::t1
(byte) assertType::t1#15 reg byte y 1.0
(byte) assertType::t2
(byte) assertType::t2#15 t2 zp ZP_BYTE:4 2.0
(byte) idx
(byte) idx#20 reg byte x 0.9999999999999999
(byte) idx#41 reg byte x 7.200000000000002
(void()) main()
(label) main::@1
(label) main::@2
(label) main::@return
(byte*) main::s
(byte*) main::s#1 s zp ZP_WORD:2 16.5
(byte*) main::s#2 s zp ZP_WORD:2 16.5
(void()) testSimpleTypes()
(label) testSimpleTypes::@1
(label) testSimpleTypes::@10
(label) testSimpleTypes::@11
(label) testSimpleTypes::@12
(label) testSimpleTypes::@13
(label) testSimpleTypes::@14
(label) testSimpleTypes::@2
(label) testSimpleTypes::@3
(label) testSimpleTypes::@4
(label) testSimpleTypes::@5
(label) testSimpleTypes::@6
(label) testSimpleTypes::@7
(label) testSimpleTypes::@8
(label) testSimpleTypes::@9
(label) testSimpleTypes::@return
zp ZP_WORD:2 [ main::s#2 main::s#1 ]
reg byte y [ assertType::t1#15 ]
zp ZP_BYTE:4 [ assertType::t2#15 ]
reg byte x [ idx#41 idx#20 ]

180
src/test/ref/number-conversion.asm Normal file

@ -0,0 +1,180 @@
// Tests conversion of numbers to correct int types
// See https://gitlab.com/camelot/kickc/issues/181
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
.const TYPEID_SIGNED_BYTE = 2
.const TYPEID_SIGNED_WORD = 4
.const TYPEID_SIGNED_DWORD = 6
.const TYPEID_BYTE = 1
.const TYPEID_WORD = 3
.const TYPEID_DWORD = 5
.const RED = 2
.const GREEN = 5
main: {
ldx #0
lda #TYPEID_SIGNED_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_SIGNED_DWORD
sta assertType.t2
tay
jsr assertType
ldx #$28
lda #TYPEID_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
ldx #$50
lda #TYPEID_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_BYTE
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_WORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
tay
jsr assertType
lda #TYPEID_DWORD
sta assertType.t2
ldy #TYPEID_SIGNED_DWORD
jsr assertType
rts
}
// Check that the two passed type IDs are equal.
// Shows a letter symbolizing t1
// If they are equal the letter is green - if not it is red.
// assertType(byte register(Y) t1, byte zeropage(2) t2)
assertType: {
.label t2 = 2
tya
cmp t2
beq b1
lda #RED
sta $d800,x
b2:
tya
sta $400,x
inx
rts
b1:
lda #GREEN
sta $d800,x
jmp b2
}

171
src/test/ref/number-conversion.cfg Normal file

@ -0,0 +1,171 @@
@begin: scope:[] from
[0] phi()
to:@1
@1: scope:[] from @begin
[1] phi()
[2] call main
to:@end
@end: scope:[] from @1
[3] phi()
main: scope:[main] from @1
[4] phi()
[5] call assertType
to:main::@1
main::@1: scope:[main] from main
[6] phi()
[7] call assertType
to:main::@2
main::@2: scope:[main] from main::@1
[8] phi()
[9] call assertType
to:main::@3
main::@3: scope:[main] from main::@2
[10] phi()
[11] call assertType
to:main::@4
main::@4: scope:[main] from main::@3
[12] phi()
[13] call assertType
to:main::@5
main::@5: scope:[main] from main::@4
[14] phi()
[15] call assertType
to:main::@6
main::@6: scope:[main] from main::@5
[16] phi()
[17] call assertType
to:main::@7
main::@7: scope:[main] from main::@6
[18] phi()
[19] call assertType
to:main::@8
main::@8: scope:[main] from main::@7
[20] phi()
[21] call assertType
to:main::@9
main::@9: scope:[main] from main::@8
[22] phi()
[23] call assertType
to:main::@10
main::@10: scope:[main] from main::@9
[24] phi()
[25] call assertType
to:main::@11
main::@11: scope:[main] from main::@10
[26] phi()
[27] call assertType
to:main::@12
main::@12: scope:[main] from main::@11
[28] phi()
[29] call assertType
to:main::@13
main::@13: scope:[main] from main::@12
[30] phi()
[31] call assertType
to:main::@14
main::@14: scope:[main] from main::@13
[32] phi()
[33] call assertType
to:main::@15
main::@15: scope:[main] from main::@14
[34] phi()
[35] call assertType
to:main::@16
main::@16: scope:[main] from main::@15
[36] phi()
[37] call assertType
to:main::@17
main::@17: scope:[main] from main::@16
[38] phi()
[39] call assertType
to:main::@18
main::@18: scope:[main] from main::@17
[40] phi()
[41] call assertType
to:main::@19
main::@19: scope:[main] from main::@18
[42] phi()
[43] call assertType
to:main::@20
main::@20: scope:[main] from main::@19
[44] phi()
[45] call assertType
to:main::@21
main::@21: scope:[main] from main::@20
[46] phi()
[47] call assertType
to:main::@22
main::@22: scope:[main] from main::@21
[48] phi()
[49] call assertType
to:main::@23
main::@23: scope:[main] from main::@22
[50] phi()
[51] call assertType
to:main::@24
main::@24: scope:[main] from main::@23
[52] phi()
[53] call assertType
to:main::@25
main::@25: scope:[main] from main::@24
[54] phi()
[55] call assertType
to:main::@26
main::@26: scope:[main] from main::@25
[56] phi()
[57] call assertType
to:main::@27
main::@27: scope:[main] from main::@26
[58] phi()
[59] call assertType
to:main::@28
main::@28: scope:[main] from main::@27
[60] phi()
[61] call assertType
to:main::@29
main::@29: scope:[main] from main::@28
[62] phi()
[63] call assertType
to:main::@30
main::@30: scope:[main] from main::@29
[64] phi()
[65] call assertType
to:main::@31
main::@31: scope:[main] from main::@30
[66] phi()
[67] call assertType
to:main::@32
main::@32: scope:[main] from main::@31
[68] phi()
[69] call assertType
to:main::@33
main::@33: scope:[main] from main::@32
[70] phi()
[71] call assertType
to:main::@34
main::@34: scope:[main] from main::@33
[72] phi()
[73] call assertType
to:main::@return
main::@return: scope:[main] from main::@34
[74] return
to:@return
assertType: scope:[assertType] from main main::@1 main::@10 main::@11 main::@12 main::@13 main::@14 main::@15 main::@16 main::@17 main::@18 main::@19 main::@2 main::@20 main::@21 main::@22 main::@23 main::@24 main::@25 main::@26 main::@27 main::@28 main::@29 main::@3 main::@30 main::@31 main::@32 main::@33 main::@34 main::@4 main::@5 main::@6 main::@7 main::@8 main::@9
[75] (byte) idx#79 ← phi( main/(byte) 0 main::@1/(byte) idx#40 main::@10/(byte) idx#40 main::@11/(byte) idx#40 main::@12/(byte) idx#40 main::@13/(byte) idx#40 main::@14/(byte) idx#40 main::@15/(byte) idx#40 main::@16/(byte) idx#40 main::@17/(byte) idx#40 main::@18/(byte) idx#40 main::@19/(byte) idx#40 main::@2/(byte) idx#40 main::@20/(byte) idx#40 main::@21/(byte) $50 main::@22/(byte) idx#40 main::@23/(byte) idx#40 main::@24/(byte) idx#40 main::@25/(byte) idx#40 main::@26/(byte) idx#40 main::@27/(byte) idx#40 main::@28/(byte) idx#40 main::@29/(byte) idx#40 main::@3/(byte) idx#40 main::@30/(byte) idx#40 main::@31/(byte) idx#40 main::@32/(byte) idx#40 main::@33/(byte) idx#40 main::@34/(byte) idx#40 main::@4/(byte) idx#40 main::@5/(byte) idx#40 main::@6/(byte) idx#40 main::@7/(byte) idx#40 main::@8/(byte) idx#40 main::@9/(byte) $28 )
[75] (byte) assertType::t2#35 ← phi( main/(const byte) TYPEID_SIGNED_BYTE main::@1/(const byte) TYPEID_SIGNED_WORD main::@10/(const byte) TYPEID_BYTE main::@11/(const byte) TYPEID_WORD main::@12/(const byte) TYPEID_WORD main::@13/(const byte) TYPEID_DWORD main::@14/(const byte) TYPEID_WORD main::@15/(const byte) TYPEID_WORD main::@16/(const byte) TYPEID_DWORD main::@17/(const byte) TYPEID_DWORD main::@18/(const byte) TYPEID_DWORD main::@19/(const byte) TYPEID_DWORD main::@2/(const byte) TYPEID_SIGNED_DWORD main::@20/(const byte) TYPEID_DWORD main::@21/(const byte) TYPEID_BYTE main::@22/(const byte) TYPEID_BYTE main::@23/(const byte) TYPEID_BYTE main::@24/(const byte) TYPEID_WORD main::@25/(const byte) TYPEID_WORD main::@26/(const byte) TYPEID_DWORD main::@27/(const byte) TYPEID_WORD main::@28/(const byte) TYPEID_WORD main::@29/(const byte) TYPEID_WORD main::@3/(const byte) TYPEID_SIGNED_WORD main::@30/(const byte) TYPEID_DWORD main::@31/(const byte) TYPEID_DWORD main::@32/(const byte) TYPEID_DWORD main::@33/(const byte) TYPEID_DWORD main::@34/(const byte) TYPEID_DWORD main::@4/(const byte) TYPEID_SIGNED_WORD main::@5/(const byte) TYPEID_SIGNED_DWORD main::@6/(const byte) TYPEID_SIGNED_DWORD main::@7/(const byte) TYPEID_SIGNED_DWORD main::@8/(const byte) TYPEID_SIGNED_DWORD main::@9/(const byte) TYPEID_BYTE )
[75] (byte) assertType::t1#35 ← phi( main/(const byte) TYPEID_SIGNED_BYTE main::@1/(const byte) TYPEID_SIGNED_WORD main::@10/(const byte) TYPEID_BYTE main::@11/(const byte) TYPEID_WORD main::@12/(const byte) TYPEID_WORD main::@13/(const byte) TYPEID_DWORD main::@14/(const byte) TYPEID_WORD main::@15/(const byte) TYPEID_WORD main::@16/(const byte) TYPEID_DWORD main::@17/(const byte) TYPEID_DWORD main::@18/(const byte) TYPEID_DWORD main::@19/(const byte) TYPEID_DWORD main::@2/(const byte) TYPEID_SIGNED_DWORD main::@20/(const byte) TYPEID_DWORD main::@21/(const byte) TYPEID_BYTE main::@22/(const byte) TYPEID_BYTE main::@23/(const byte) TYPEID_BYTE main::@24/(const byte) TYPEID_WORD main::@25/(const byte) TYPEID_WORD main::@26/(const byte) TYPEID_DWORD main::@27/(const byte) TYPEID_WORD main::@28/(const byte) TYPEID_WORD main::@29/(const byte) TYPEID_WORD main::@3/(const byte) TYPEID_SIGNED_WORD main::@30/(const byte) TYPEID_DWORD main::@31/(const byte) TYPEID_DWORD main::@32/(const byte) TYPEID_DWORD main::@33/(const byte) TYPEID_DWORD main::@34/(const byte) TYPEID_SIGNED_DWORD main::@4/(const byte) TYPEID_SIGNED_WORD main::@5/(const byte) TYPEID_SIGNED_DWORD main::@6/(const byte) TYPEID_SIGNED_DWORD main::@7/(const byte) TYPEID_SIGNED_DWORD main::@8/(const byte) TYPEID_SIGNED_DWORD main::@9/(const byte) TYPEID_BYTE )
[76] if((byte) assertType::t1#35==(byte) assertType::t2#35) goto assertType::@1
to:assertType::@3
assertType::@3: scope:[assertType] from assertType
[77] *((byte*)(word) $d800 + (byte) idx#79) ← (const byte) RED#0
to:assertType::@2
assertType::@2: scope:[assertType] from assertType::@1 assertType::@3
[78] *((byte*)(word) $400 + (byte) idx#79) ← (byte) assertType::t1#35
[79] (byte) idx#40 ← ++ (byte) idx#79
to:assertType::@return
assertType::@return: scope:[assertType] from assertType::@2
[80] return
to:@return
assertType::@1: scope:[assertType] from assertType
[81] *((byte*)(word) $d800 + (byte) idx#79) ← (const byte) GREEN#0
to:assertType::@2

3609
src/test/ref/number-conversion.log Normal file

File diff suppressed because it is too large Load Diff

67
src/test/ref/number-conversion.sym Normal file

@ -0,0 +1,67 @@
(label) @1
(label) @begin
(label) @end
(byte*) COLS
(byte) GREEN
(const byte) GREEN#0 GREEN = (byte) 5
(byte) RED
(const byte) RED#0 RED = (byte) 2
(byte*) SCREEN
(const byte) TYPEID_BYTE TYPEID_BYTE = (number) 1
(const byte) TYPEID_DWORD TYPEID_DWORD = (number) 5
(const byte) TYPEID_SIGNED_BYTE TYPEID_SIGNED_BYTE = (number) 2
(const byte) TYPEID_SIGNED_DWORD TYPEID_SIGNED_DWORD = (number) 6
(const byte) TYPEID_SIGNED_WORD TYPEID_SIGNED_WORD = (number) 4
(const byte) TYPEID_WORD TYPEID_WORD = (number) 3
(void()) assertType((byte) assertType::t1 , (byte) assertType::t2)
(label) assertType::@1
(label) assertType::@2
(label) assertType::@3
(label) assertType::@return
(byte) assertType::t1
(byte) assertType::t1#35 reg byte y 1.0
(byte) assertType::t2
(byte) assertType::t2#35 t2 zp ZP_BYTE:2 2.0
(byte) idx
(byte) idx#40 reg byte x 0.9999999999999993
(byte) idx#79 reg byte x 14.400000000000007
(void()) main()
(label) main::@1
(label) main::@10
(label) main::@11
(label) main::@12
(label) main::@13
(label) main::@14
(label) main::@15
(label) main::@16
(label) main::@17
(label) main::@18
(label) main::@19
(label) main::@2
(label) main::@20
(label) main::@21
(label) main::@22
(label) main::@23
(label) main::@24
(label) main::@25
(label) main::@26
(label) main::@27
(label) main::@28
(label) main::@29
(label) main::@3
(label) main::@30
(label) main::@31
(label) main::@32
(label) main::@33
(label) main::@34
(label) main::@4
(label) main::@5
(label) main::@6
(label) main::@7
(label) main::@8
(label) main::@9
(label) main::@return
reg byte y [ assertType::t1#35 ]
zp ZP_BYTE:2 [ assertType::t2#35 ]
reg byte x [ idx#79 idx#40 ]

69
src/test/ref/number-type.asm Normal file

@ -0,0 +1,69 @@
// Tests the number type used for constant expressions
.pc = $801 "Basic"
:BasicUpstart(main)
.pc = $80d "Program"
main: {
jsr testBytes
jsr testSBytes
rts
}
testSBytes: {
// Constant values resolvable to signed bytes
.label SCREEN = $428
lda #-$c
sta SCREEN
lda #-6-6
sta SCREEN+1
lda #-$12+6
sta SCREEN+2
lda #-$714+$708
sta SCREEN+3
lda #-1-2-3-6
sta SCREEN+4
lda #-2*6
sta SCREEN+5
lda #-3<<2
sta SCREEN+6
lda #-$18>>1
sta SCREEN+7
lda #-4&-9
sta SCREEN+8
lda #-$10|-$fc
sta SCREEN+9
lda #(-2-2)*$f/5
sta SCREEN+$a
lda #$ff&$1000-$c
sta SCREEN+$b
rts
}
testBytes: {
// Constant values resolvable to bytes
.label SCREEN = $400
lda #$c
sta SCREEN
lda #6+6
sta SCREEN+1
lda #$12-6
sta SCREEN+2
lda #$714-$708
sta SCREEN+3
lda #1+2+3+6
sta SCREEN+4
lda #2*6
sta SCREEN+5
lda #3<<2
sta SCREEN+6
lda #$18>>1
sta SCREEN+7
lda #$f&$1c
sta SCREEN+8
lda #4|8
sta SCREEN+9
lda #5^9
sta SCREEN+$a
lda #(2+2)*$f/5
sta SCREEN+$b
lda #$ff&$1000+$c
sta SCREEN+$c
rts
}

55
src/test/ref/number-type.cfg Normal file

@ -0,0 +1,55 @@
@begin: scope:[] from
[0] phi()
to:@1
@1: scope:[] from @begin
[1] phi()
[2] call main
to:@end
@end: scope:[] from @1
[3] phi()
main: scope:[main] from @1
[4] phi()
[5] call testBytes
to:main::@1
main::@1: scope:[main] from main
[6] phi()
[7] call testSBytes
to:main::@return
main::@return: scope:[main] from main::@1
[8] return
to:@return
testSBytes: scope:[testSBytes] from main::@1
[9] *((const signed byte*) testSBytes::SCREEN#0) ← ((signed byte))-(number) $c
[10] *((const signed byte*) testSBytes::SCREEN#0+(number) 1) ← ((signed byte))-(number) 6-(number) 6
[11] *((const signed byte*) testSBytes::SCREEN#0+(number) 2) ← ((signed byte))-(number) $12+(number) 6
[12] *((const signed byte*) testSBytes::SCREEN#0+(number) 3) ← ((signed byte))-(number) $714+(number) $708
[13] *((const signed byte*) testSBytes::SCREEN#0+(number) 4) ← ((signed byte))-(number) 1-(number) 2-(number) 3-(number) 6
[14] *((const signed byte*) testSBytes::SCREEN#0+(number) 5) ← ((signed byte))-(number) 2*(number) 6
[15] *((const signed byte*) testSBytes::SCREEN#0+(number) 6) ← ((signed byte))-(number) 3<<(number) 2
[16] *((const signed byte*) testSBytes::SCREEN#0+(number) 7) ← ((signed byte))-(number) $18>>(number) 1
[17] *((const signed byte*) testSBytes::SCREEN#0+(number) 8) ← ((signed byte))-(number) 4&-(number) 9
[18] *((const signed byte*) testSBytes::SCREEN#0+(number) 9) ← ((signed byte))-(number) $10|-(number) $fc
[19] *((const signed byte*) testSBytes::SCREEN#0+(number) $a) ← ((signed byte))-(number) 2-(number) 2*(number) $f/(number) 5
[20] *((const signed byte*) testSBytes::SCREEN#0+(number) $b) ← ((signed byte))(number) $1000-(number) $c
to:testSBytes::@return
testSBytes::@return: scope:[testSBytes] from testSBytes
[21] return
to:@return
testBytes: scope:[testBytes] from main
[22] *((const byte*) testBytes::SCREEN#0) ← (byte) $c
[23] *((const byte*) testBytes::SCREEN#0+(number) 1) ← ((byte))(number) 6+(number) 6
[24] *((const byte*) testBytes::SCREEN#0+(number) 2) ← ((byte))(number) $12-(number) 6
[25] *((const byte*) testBytes::SCREEN#0+(number) 3) ← ((byte))(number) $714-(number) $708
[26] *((const byte*) testBytes::SCREEN#0+(number) 4) ← ((byte))(number) 1+(number) 2+(number) 3+(number) 6
[27] *((const byte*) testBytes::SCREEN#0+(number) 5) ← ((byte))(number) 2*(number) 6
[28] *((const byte*) testBytes::SCREEN#0+(number) 6) ← ((byte))(number) 3<<(number) 2
[29] *((const byte*) testBytes::SCREEN#0+(number) 7) ← ((byte))(number) $18>>(number) 1
[30] *((const byte*) testBytes::SCREEN#0+(number) 8) ← ((byte))(number) $f&(number) $1c
[31] *((const byte*) testBytes::SCREEN#0+(number) 9) ← ((byte))(number) 4|(number) 8
[32] *((const byte*) testBytes::SCREEN#0+(number) $a) ← ((byte))(number) 5^(number) 9
[33] *((const byte*) testBytes::SCREEN#0+(number) $b) ← ((byte))(number) 2+(number) 2*(number) $f/(number) 5
[34] *((const byte*) testBytes::SCREEN#0+(number) $c) ← ((byte))(number) $1000+(number) $c
to:testBytes::@return
testBytes::@return: scope:[testBytes] from testBytes
[35] return
to:@return

1204
src/test/ref/number-type.log Normal file

File diff suppressed because it is too large Load Diff

17
src/test/ref/number-type.sym Normal file

@ -0,0 +1,17 @@
(label) @1
(label) @begin
(label) @end
(void()) main()
(label) main::@1
(label) main::@return
(void()) testBytes()
(label) testBytes::@return
(byte*) testBytes::SCREEN
(const byte*) testBytes::SCREEN#0 SCREEN = ((byte*))(number) $400
(byte) testBytes::idx
(void()) testSBytes()
(label) testSBytes::@return
(signed byte*) testSBytes::SCREEN
(const signed byte*) testSBytes::SCREEN#0 SCREEN = ((signed byte*))(number) $428
(byte) testSBytes::idx