From 0ff5b79353412af78873601d9e5ef80ba33476e0 Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Sat, 8 Feb 2020 01:31:41 +0100 Subject: [PATCH] code inspection cleanups --- compiler/src/prog8/ast/AstToSourceCode.kt | 4 +- compiler/src/prog8/ast/AstToplevel.kt | 5 +- .../prog8/ast/expressions/AstExpressions.kt | 10 +- .../src/prog8/ast/processing/AstChecker.kt | 12 +- .../ast/processing/AstIdentifiersChecker.kt | 2 +- .../ast/processing/IAstModifyingVisitor.kt | 4 +- .../src/prog8/ast/processing/IAstVisitor.kt | 4 +- .../ast/processing/StatementReorderer.kt | 6 +- .../prog8/ast/processing/TypecastsAdder.kt | 8 +- .../VarInitValueAndAddressOfCreator.kt | 8 +- .../src/prog8/ast/statements/AstStatements.kt | 6 +- .../compiler/target/c64/codegen/AsmGen.kt | 6 +- .../c64/codegen/BuiltinFunctionsAsmGen.kt | 46 +++---- .../target/c64/codegen/FunctionCallAsmGen.kt | 4 +- .../src/prog8/optimizer/ConstExprEvaluator.kt | 126 +++++++++--------- .../src/prog8/optimizer/ConstantFolding.kt | 30 ++--- .../src/prog8/optimizer/StatementOptimizer.kt | 10 +- compiler/src/prog8/vm/astvm/AstVm.kt | 43 +++--- compiler/src/prog8/vm/astvm/Expressions.kt | 2 +- 19 files changed, 167 insertions(+), 169 deletions(-) diff --git a/compiler/src/prog8/ast/AstToSourceCode.kt b/compiler/src/prog8/ast/AstToSourceCode.kt index 7c54c2f17..b77631e65 100644 --- a/compiler/src/prog8/ast/AstToSourceCode.kt +++ b/compiler/src/prog8/ast/AstToSourceCode.kt @@ -196,9 +196,9 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program): private fun printout(call: IFunctionCall) { call.target.accept(this) output("(") - for(arg in call.arglist) { + for(arg in call.args) { arg.accept(this) - if(arg!==call.arglist.last()) + if(arg!==call.args.last()) output(", ") } output(")") diff --git a/compiler/src/prog8/ast/AstToplevel.kt b/compiler/src/prog8/ast/AstToplevel.kt index 9afd52637..7e8c1415b 100644 --- a/compiler/src/prog8/ast/AstToplevel.kt +++ b/compiler/src/prog8/ast/AstToplevel.kt @@ -37,7 +37,7 @@ interface Node { interface IFunctionCall { var target: IdentifierReference - var arglist: MutableList + var args: MutableList } interface INameScope { @@ -243,8 +243,7 @@ class GlobalNamespace(val modules: List): Node, INameScope { } } // lookup something from the module. - val stmt = localContext.definingModule().lookup(scopedName, localContext) - return when (stmt) { + return when (val stmt = localContext.definingModule().lookup(scopedName, localContext)) { is Label, is VarDecl, is Block, is Subroutine -> stmt null -> null else -> throw NameError("wrong identifier target: $stmt", stmt.position) diff --git a/compiler/src/prog8/ast/expressions/AstExpressions.kt b/compiler/src/prog8/ast/expressions/AstExpressions.kt index 5d692e5e3..18fb76f62 100644 --- a/compiler/src/prog8/ast/expressions/AstExpressions.kt +++ b/compiler/src/prog8/ast/expressions/AstExpressions.kt @@ -657,14 +657,14 @@ data class IdentifierReference(val nameInSource: List, override val posi } class FunctionCall(override var target: IdentifierReference, - override var arglist: MutableList, + override var args: MutableList, override val position: Position) : Expression(), IFunctionCall { override lateinit var parent: Node override fun linkParents(parent: Node) { this.parent = parent target.linkParents(this) - arglist.forEach { it.linkParents(this) } + args.forEach { it.linkParents(this) } } override fun constValue(program: Program) = constValue(program, true) @@ -679,7 +679,7 @@ class FunctionCall(override var target: IdentifierReference, if(func!=null) { val exprfunc = func.constExpressionFunc if(exprfunc!=null) - resultValue = exprfunc(arglist, position, program) + resultValue = exprfunc(args, position, program) else if(func.returntype==null) throw ExpressionError("builtin function ${target.nameInSource[0]} can't be used here because it doesn't return a value", position) } @@ -705,7 +705,7 @@ class FunctionCall(override var target: IdentifierReference, override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this) override fun accept(visitor: IAstVisitor) = visitor.visit(this) - override fun referencesIdentifiers(vararg name: String): Boolean = target.referencesIdentifiers(*name) || arglist.any{it.referencesIdentifiers(*name)} + override fun referencesIdentifiers(vararg name: String): Boolean = target.referencesIdentifiers(*name) || args.any{it.referencesIdentifiers(*name)} override fun inferType(program: Program): InferredTypes.InferredType { val constVal = constValue(program ,false) @@ -718,7 +718,7 @@ class FunctionCall(override var target: IdentifierReference, target.nameInSource[0] == "clear_carry" || target.nameInSource[0]=="clear_irqd") { return InferredTypes.void() // these have no return value } - return builtinFunctionReturnType(target.nameInSource[0], this.arglist, program) + return builtinFunctionReturnType(target.nameInSource[0], this.args, program) } is Subroutine -> { if(stmt.returntypes.isEmpty()) diff --git a/compiler/src/prog8/ast/processing/AstChecker.kt b/compiler/src/prog8/ast/processing/AstChecker.kt index 998910d03..1d3c9e847 100644 --- a/compiler/src/prog8/ast/processing/AstChecker.kt +++ b/compiler/src/prog8/ast/processing/AstChecker.kt @@ -505,9 +505,9 @@ internal class AstChecker(private val program: Program, decl.datatype in NumericDatatypes -> { // initialize numeric var with value zero by default. val litVal = - when { - decl.datatype in ByteDatatypes -> NumericLiteralValue(decl.datatype, 0, decl.position) - decl.datatype in WordDatatypes -> NumericLiteralValue(decl.datatype, 0, decl.position) + when (decl.datatype) { + in ByteDatatypes -> NumericLiteralValue(decl.datatype, 0, decl.position) + in WordDatatypes -> NumericLiteralValue(decl.datatype, 0, decl.position) else -> NumericLiteralValue(decl.datatype, 0.0, decl.position) } litVal.parent = decl @@ -817,14 +817,14 @@ internal class AstChecker(private val program: Program, val targetStatement = checkFunctionOrLabelExists(functionCall.target, stmtOfExpression) if(targetStatement!=null) - checkFunctionCall(targetStatement, functionCall.arglist, functionCall.position) + checkFunctionCall(targetStatement, functionCall.args, functionCall.position) super.visit(functionCall) } override fun visit(functionCallStatement: FunctionCallStatement) { val targetStatement = checkFunctionOrLabelExists(functionCallStatement.target, functionCallStatement) if(targetStatement!=null) - checkFunctionCall(targetStatement, functionCallStatement.arglist, functionCallStatement.position) + checkFunctionCall(targetStatement, functionCallStatement.args, functionCallStatement.position) if(targetStatement is Subroutine && targetStatement.returntypes.isNotEmpty()) { if(targetStatement.returntypes.size==1) printWarning("result value of subroutine call is discarded", functionCallStatement.position) @@ -834,7 +834,7 @@ internal class AstChecker(private val program: Program, if(functionCallStatement.target.nameInSource.last() in setOf("lsl", "lsr", "rol", "ror", "rol2", "ror2", "swap", "sort", "reverse")) { // in-place modification, can't be done on literals - if(functionCallStatement.arglist.any { it !is IdentifierReference && it !is RegisterExpr && it !is ArrayIndexedExpression && it !is DirectMemoryRead }) { + if(functionCallStatement.args.any { it !is IdentifierReference && it !is RegisterExpr && it !is ArrayIndexedExpression && it !is DirectMemoryRead }) { checkResult.add(ExpressionError("can't use that as argument to a in-place modifying function", functionCallStatement.position)) } } diff --git a/compiler/src/prog8/ast/processing/AstIdentifiersChecker.kt b/compiler/src/prog8/ast/processing/AstIdentifiersChecker.kt index 68c08cd65..93fc5e69d 100644 --- a/compiler/src/prog8/ast/processing/AstIdentifiersChecker.kt +++ b/compiler/src/prog8/ast/processing/AstIdentifiersChecker.kt @@ -50,7 +50,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi override fun visit(functionCall: FunctionCall): Expression { if(functionCall.target.nameInSource.size==1 && functionCall.target.nameInSource[0]=="lsb") { // lsb(...) is just an alias for type cast to ubyte, so replace with "... as ubyte" - val typecast = TypecastExpression(functionCall.arglist.single(), DataType.UBYTE, false, functionCall.position) + val typecast = TypecastExpression(functionCall.args.single(), DataType.UBYTE, false, functionCall.position) typecast.linkParents(functionCall.parent) return super.visit(typecast) } diff --git a/compiler/src/prog8/ast/processing/IAstModifyingVisitor.kt b/compiler/src/prog8/ast/processing/IAstModifyingVisitor.kt index 6c8043929..29832a894 100644 --- a/compiler/src/prog8/ast/processing/IAstModifyingVisitor.kt +++ b/compiler/src/prog8/ast/processing/IAstModifyingVisitor.kt @@ -52,7 +52,7 @@ interface IAstModifyingVisitor { functionCall.target = newtarget else throw FatalAstException("cannot change class of function call target") - functionCall.arglist = functionCall.arglist.map { it.accept(this) }.toMutableList() + functionCall.args = functionCall.args.map { it.accept(this) }.toMutableList() return functionCall } @@ -62,7 +62,7 @@ interface IAstModifyingVisitor { functionCallStatement.target = newtarget else throw FatalAstException("cannot change class of function call target") - functionCallStatement.arglist = functionCallStatement.arglist.map { it.accept(this) }.toMutableList() + functionCallStatement.args = functionCallStatement.args.map { it.accept(this) }.toMutableList() return functionCallStatement } diff --git a/compiler/src/prog8/ast/processing/IAstVisitor.kt b/compiler/src/prog8/ast/processing/IAstVisitor.kt index 3a3c4116d..826dad9b5 100644 --- a/compiler/src/prog8/ast/processing/IAstVisitor.kt +++ b/compiler/src/prog8/ast/processing/IAstVisitor.kt @@ -41,12 +41,12 @@ interface IAstVisitor { fun visit(functionCall: FunctionCall) { functionCall.target.accept(this) - functionCall.arglist.forEach { it.accept(this) } + functionCall.args.forEach { it.accept(this) } } fun visit(functionCallStatement: FunctionCallStatement) { functionCallStatement.target.accept(this) - functionCallStatement.arglist.forEach { it.accept(this) } + functionCallStatement.args.forEach { it.accept(this) } } fun visit(identifier: IdentifierReference) { diff --git a/compiler/src/prog8/ast/processing/StatementReorderer.kt b/compiler/src/prog8/ast/processing/StatementReorderer.kt index 79d19ce28..8d597673d 100644 --- a/compiler/src/prog8/ast/processing/StatementReorderer.kt +++ b/compiler/src/prog8/ast/processing/StatementReorderer.kt @@ -13,8 +13,8 @@ private fun flattenStructAssignmentFromIdentifier(structAssignment: Assignment, val identifierName = identifier.nameInSource.single() val targetVar = identifier.targetVarDecl(program.namespace)!! val struct = targetVar.struct!! - when { - structAssignment.value is IdentifierReference -> { + when (structAssignment.value) { + is IdentifierReference -> { val sourceVar = (structAssignment.value as IdentifierReference).targetVarDecl(program.namespace)!! if (sourceVar.struct == null) throw FatalAstException("can only assign arrays or structs to structs") @@ -39,7 +39,7 @@ private fun flattenStructAssignmentFromIdentifier(structAssignment: Assignment, assign } } - structAssignment.value is StructLiteralValue -> { + is StructLiteralValue -> { throw IllegalArgumentException("not going to flatten a structLv assignment here") } else -> throw FatalAstException("strange struct value") diff --git a/compiler/src/prog8/ast/processing/TypecastsAdder.kt b/compiler/src/prog8/ast/processing/TypecastsAdder.kt index bc2053b3d..4161134c0 100644 --- a/compiler/src/prog8/ast/processing/TypecastsAdder.kt +++ b/compiler/src/prog8/ast/processing/TypecastsAdder.kt @@ -78,7 +78,7 @@ internal class TypecastsAdder(private val program: Program): IAstModifyingVisito // see if a typecast is needed to convert the arguments into the required parameter's type when(val sub = call.target.targetStatement(scope)) { is Subroutine -> { - for(arg in sub.parameters.zip(call.arglist.withIndex())) { + for(arg in sub.parameters.zip(call.args.withIndex())) { val argItype = arg.second.value.inferType(program) if(argItype.isKnown) { val argtype = argItype.typeOrElse(DataType.STRUCT) @@ -87,7 +87,7 @@ internal class TypecastsAdder(private val program: Program): IAstModifyingVisito if (argtype isAssignableTo requiredType) { val typecasted = TypecastExpression(arg.second.value, requiredType, true, arg.second.value.position) typecasted.linkParents(arg.second.value.parent) - call.arglist[arg.second.index] = typecasted + call.args[arg.second.index] = typecasted } // if they're not assignable, we'll get a proper error later from the AstChecker } @@ -98,7 +98,7 @@ internal class TypecastsAdder(private val program: Program): IAstModifyingVisito val func = BuiltinFunctions.getValue(sub.name) if(func.pure) { // non-pure functions don't get automatic typecasts because sometimes they act directly on their parameters - for (arg in func.parameters.zip(call.arglist.withIndex())) { + for (arg in func.parameters.zip(call.args.withIndex())) { val argItype = arg.second.value.inferType(program) if (argItype.isKnown) { val argtype = argItype.typeOrElse(DataType.STRUCT) @@ -108,7 +108,7 @@ internal class TypecastsAdder(private val program: Program): IAstModifyingVisito if (argtype isAssignableTo possibleType) { val typecasted = TypecastExpression(arg.second.value, possibleType, true, arg.second.value.position) typecasted.linkParents(arg.second.value.parent) - call.arglist[arg.second.index] = typecasted + call.args[arg.second.index] = typecasted break } } diff --git a/compiler/src/prog8/ast/processing/VarInitValueAndAddressOfCreator.kt b/compiler/src/prog8/ast/processing/VarInitValueAndAddressOfCreator.kt index f0281102b..b02e6cbf7 100644 --- a/compiler/src/prog8/ast/processing/VarInitValueAndAddressOfCreator.kt +++ b/compiler/src/prog8/ast/processing/VarInitValueAndAddressOfCreator.kt @@ -79,11 +79,11 @@ internal class VarInitValueAndAddressOfCreator(private val program: Program): IA parentStatement = parentStatement.parent val targetStatement = functionCall.target.targetSubroutine(program.namespace) if(targetStatement!=null) { - addAddressOfExprIfNeeded(targetStatement, functionCall.arglist, parentStatement) + addAddressOfExprIfNeeded(targetStatement, functionCall.args, parentStatement) } else { val builtinFunc = BuiltinFunctions[functionCall.target.nameInSource.joinToString (".")] if(builtinFunc!=null) - addAddressOfExprIfNeededForBuiltinFuncs(builtinFunc, functionCall.arglist, parentStatement) + addAddressOfExprIfNeededForBuiltinFuncs(builtinFunc, functionCall.args, parentStatement) } return functionCall } @@ -91,11 +91,11 @@ internal class VarInitValueAndAddressOfCreator(private val program: Program): IA override fun visit(functionCallStatement: FunctionCallStatement): Statement { val targetStatement = functionCallStatement.target.targetSubroutine(program.namespace) if(targetStatement!=null) { - addAddressOfExprIfNeeded(targetStatement, functionCallStatement.arglist, functionCallStatement) + addAddressOfExprIfNeeded(targetStatement, functionCallStatement.args, functionCallStatement) } else { val builtinFunc = BuiltinFunctions[functionCallStatement.target.nameInSource.joinToString (".")] if(builtinFunc!=null) - addAddressOfExprIfNeededForBuiltinFuncs(builtinFunc, functionCallStatement.arglist, functionCallStatement) + addAddressOfExprIfNeededForBuiltinFuncs(builtinFunc, functionCallStatement.args, functionCallStatement) } return functionCallStatement } diff --git a/compiler/src/prog8/ast/statements/AstStatements.kt b/compiler/src/prog8/ast/statements/AstStatements.kt index 610f03b04..ca22fbf53 100644 --- a/compiler/src/prog8/ast/statements/AstStatements.kt +++ b/compiler/src/prog8/ast/statements/AstStatements.kt @@ -477,16 +477,16 @@ class Jump(val address: Int?, } class FunctionCallStatement(override var target: IdentifierReference, - override var arglist: MutableList, + override var args: MutableList, override val position: Position) : Statement(), IFunctionCall { override lateinit var parent: Node override val expensiveToInline - get() = arglist.any { it !is NumericLiteralValue } + get() = args.any { it !is NumericLiteralValue } override fun linkParents(parent: Node) { this.parent = parent target.linkParents(this) - arglist.forEach { it.linkParents(this) } + args.forEach { it.linkParents(this) } } override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this) diff --git a/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt index 5548ca1d5..a58f11428 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt @@ -356,14 +356,14 @@ internal class AsmGen(private val program: Program, private fun makeArrayFillDataUnsigned(decl: VarDecl): List { val array = (decl.value as ArrayLiteralValue).value - return when { - decl.datatype == DataType.ARRAY_UB -> + return when (decl.datatype) { + DataType.ARRAY_UB -> // byte array can never contain pointer-to types, so treat values as all integers array.map { val number = (it as NumericLiteralValue).number.toInt() "$"+number.toString(16).padStart(2, '0') } - decl.datatype== DataType.ARRAY_UW -> array.map { + DataType.ARRAY_UW -> array.map { if(it is NumericLiteralValue) { "$" + it.number.toInt().toString(16).padStart(4, '0') } else { diff --git a/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt index 6dc2416fd..3c51f3391 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt @@ -39,7 +39,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val when (functionName) { "msb" -> { - val arg = fcall.arglist.single() + val arg = fcall.args.single() if (arg.inferType(program).typeOrElse(DataType.STRUCT) !in WordDatatypes) throw AssemblyError("msb required word argument") if (arg is NumericLiteralValue) @@ -53,12 +53,12 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } } "mkword" -> { - translateFunctionArguments(fcall.arglist, func) + translateFunctionArguments(fcall.args, func) asmgen.out(" inx | lda $ESTACK_LO_HEX,x | sta $ESTACK_HI_PLUS1_HEX,x") } "abs" -> { - translateFunctionArguments(fcall.arglist, func) - val dt = fcall.arglist.single().inferType(program) + translateFunctionArguments(fcall.args, func) + val dt = fcall.args.single().inferType(program) when (dt.typeOrElse(DataType.STRUCT)) { in ByteDatatypes -> asmgen.out(" jsr prog8_lib.abs_b") in WordDatatypes -> asmgen.out(" jsr prog8_lib.abs_w") @@ -67,8 +67,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } } "swap" -> { - val first = fcall.arglist[0] - val second = fcall.arglist[1] + val first = fcall.args[0] + val second = fcall.args[1] asmgen.translateExpression(first) asmgen.translateExpression(second) // pop in reverse order @@ -78,12 +78,12 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val asmgen.assignFromEvalResult(secondTarget) } "strlen" -> { - outputPushAddressOfIdentifier(fcall.arglist[0]) + outputPushAddressOfIdentifier(fcall.args[0]) asmgen.out(" jsr prog8_lib.func_strlen") } "min", "max", "sum" -> { - outputPushAddressAndLenghtOfArray(fcall.arglist[0]) - val dt = fcall.arglist.single().inferType(program) + outputPushAddressAndLenghtOfArray(fcall.args[0]) + val dt = fcall.args.single().inferType(program) when (dt.typeOrElse(DataType.STRUCT)) { DataType.ARRAY_UB, DataType.STR -> asmgen.out(" jsr prog8_lib.func_${functionName}_ub") DataType.ARRAY_B -> asmgen.out(" jsr prog8_lib.func_${functionName}_b") @@ -94,8 +94,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } } "any", "all" -> { - outputPushAddressAndLenghtOfArray(fcall.arglist[0]) - val dt = fcall.arglist.single().inferType(program) + outputPushAddressAndLenghtOfArray(fcall.args[0]) + val dt = fcall.args.single().inferType(program) when (dt.typeOrElse(DataType.STRUCT)) { DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out(" jsr prog8_lib.func_${functionName}_b") DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out(" jsr prog8_lib.func_${functionName}_w") @@ -104,8 +104,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } } "sgn" -> { - translateFunctionArguments(fcall.arglist, func) - val dt = fcall.arglist.single().inferType(program) + translateFunctionArguments(fcall.args, func) + val dt = fcall.args.single().inferType(program) when(dt.typeOrElse(DataType.STRUCT)) { DataType.UBYTE -> asmgen.out(" jsr math.sign_ub") DataType.BYTE -> asmgen.out(" jsr math.sign_b") @@ -119,12 +119,12 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val "ln", "log2", "sqrt", "rad", "deg", "round", "floor", "ceil", "rdnf" -> { - translateFunctionArguments(fcall.arglist, func) + translateFunctionArguments(fcall.args, func) asmgen.out(" jsr c64flt.func_$functionName") } "lsl" -> { // in-place - val what = fcall.arglist.single() + val what = fcall.args.single() val dt = what.inferType(program) when (dt.typeOrElse(DataType.STRUCT)) { in ByteDatatypes -> { @@ -180,7 +180,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } "lsr" -> { // in-place - val what = fcall.arglist.single() + val what = fcall.args.single() val dt = what.inferType(program) when (dt.typeOrElse(DataType.STRUCT)) { DataType.UBYTE -> { @@ -264,7 +264,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } "rol" -> { // in-place - val what = fcall.arglist.single() + val what = fcall.args.single() val dt = what.inferType(program) when (dt.typeOrElse(DataType.STRUCT)) { DataType.UBYTE -> { @@ -323,7 +323,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } "rol2" -> { // in-place - val what = fcall.arglist.single() + val what = fcall.args.single() val dt = what.inferType(program) when (dt.typeOrElse(DataType.STRUCT)) { DataType.UBYTE -> { @@ -375,7 +375,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } "ror" -> { // in-place - val what = fcall.arglist.single() + val what = fcall.args.single() val dt = what.inferType(program) when (dt.typeOrElse(DataType.STRUCT)) { DataType.UBYTE -> { @@ -433,7 +433,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } "ror2" -> { // in-place - val what = fcall.arglist.single() + val what = fcall.args.single() val dt = what.inferType(program) when (dt.typeOrElse(DataType.STRUCT)) { DataType.UBYTE -> { @@ -484,7 +484,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val } } "sort" -> { - val variable = fcall.arglist.single() + val variable = fcall.args.single() if(variable is IdentifierReference) { val decl = variable.targetVarDecl(program.namespace)!! val varName = asmgen.asmIdentifierName(variable) @@ -520,7 +520,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val throw AssemblyError("weird type") } "reverse" -> { - val variable = fcall.arglist.single() + val variable = fcall.args.single() if (variable is IdentifierReference) { val decl = variable.targetVarDecl(program.namespace)!! val varName = asmgen.asmIdentifierName(variable) @@ -561,7 +561,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val asmgen.out(" pla | tay | pla | tax | pla | plp") } else -> { - translateFunctionArguments(fcall.arglist, func) + translateFunctionArguments(fcall.args, func) asmgen.out(" jsr prog8_lib.func_$functionName") } } diff --git a/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt index d065cb78d..4d9dac6ec 100644 --- a/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt @@ -23,8 +23,8 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg asmgen.out(" stx c64.SCRATCH_ZPREGX") // we only save X for now (required! is the eval stack pointer), screw A and Y... val subName = asmgen.asmIdentifierName(stmt.target) - if(stmt.arglist.isNotEmpty()) { - for(arg in sub.parameters.withIndex().zip(stmt.arglist)) { + if(stmt.args.isNotEmpty()) { + for(arg in sub.parameters.withIndex().zip(stmt.args)) { translateFuncArguments(arg.first, arg.second, sub) } } diff --git a/compiler/src/prog8/optimizer/ConstExprEvaluator.kt b/compiler/src/prog8/optimizer/ConstExprEvaluator.kt index 8e62eb2b4..42de42e13 100644 --- a/compiler/src/prog8/optimizer/ConstExprEvaluator.kt +++ b/compiler/src/prog8/optimizer/ConstExprEvaluator.kt @@ -54,15 +54,15 @@ class ConstExprEvaluator { private fun logicalxor(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue { val error = "cannot compute $left locical-bitxor $right" - return when { - left.type in IntegerDatatypes -> when { - right.type in IntegerDatatypes -> NumericLiteralValue.fromBoolean((left.number.toInt() != 0) xor (right.number.toInt() != 0), left.position) - right.type == DataType.FLOAT -> NumericLiteralValue.fromBoolean((left.number.toInt() != 0) xor (right.number.toDouble() != 0.0), left.position) + return when (left.type) { + in IntegerDatatypes -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue.fromBoolean((left.number.toInt() != 0) xor (right.number.toInt() != 0), left.position) + DataType.FLOAT -> NumericLiteralValue.fromBoolean((left.number.toInt() != 0) xor (right.number.toDouble() != 0.0), left.position) else -> throw ExpressionError(error, left.position) } - left.type == DataType.FLOAT -> when { - right.type in IntegerDatatypes -> NumericLiteralValue.fromBoolean((left.number.toDouble() != 0.0) xor (right.number.toInt() != 0), left.position) - right.type == DataType.FLOAT -> NumericLiteralValue.fromBoolean((left.number.toDouble() != 0.0) xor (right.number.toDouble() != 0.0), left.position) + DataType.FLOAT -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue.fromBoolean((left.number.toDouble() != 0.0) xor (right.number.toInt() != 0), left.position) + DataType.FLOAT -> NumericLiteralValue.fromBoolean((left.number.toDouble() != 0.0) xor (right.number.toDouble() != 0.0), left.position) else -> throw ExpressionError(error, left.position) } else -> throw ExpressionError(error, left.position) @@ -71,15 +71,15 @@ class ConstExprEvaluator { private fun logicalor(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue { val error = "cannot compute $left locical-or $right" - return when { - left.type in IntegerDatatypes -> when { - right.type in IntegerDatatypes -> NumericLiteralValue.fromBoolean(left.number.toInt() != 0 || right.number.toInt() != 0, left.position) - right.type == DataType.FLOAT -> NumericLiteralValue.fromBoolean(left.number.toInt() != 0 || right.number.toDouble() != 0.0, left.position) + return when (left.type) { + in IntegerDatatypes -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue.fromBoolean(left.number.toInt() != 0 || right.number.toInt() != 0, left.position) + DataType.FLOAT -> NumericLiteralValue.fromBoolean(left.number.toInt() != 0 || right.number.toDouble() != 0.0, left.position) else -> throw ExpressionError(error, left.position) } - left.type == DataType.FLOAT -> when { - right.type in IntegerDatatypes -> NumericLiteralValue.fromBoolean(left.number.toDouble() != 0.0 || right.number.toInt() != 0, left.position) - right.type == DataType.FLOAT -> NumericLiteralValue.fromBoolean(left.number.toDouble() != 0.0 || right.number.toDouble() != 0.0, left.position) + DataType.FLOAT -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue.fromBoolean(left.number.toDouble() != 0.0 || right.number.toInt() != 0, left.position) + DataType.FLOAT -> NumericLiteralValue.fromBoolean(left.number.toDouble() != 0.0 || right.number.toDouble() != 0.0, left.position) else -> throw ExpressionError(error, left.position) } else -> throw ExpressionError(error, left.position) @@ -88,15 +88,15 @@ class ConstExprEvaluator { private fun logicaland(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue { val error = "cannot compute $left locical-and $right" - return when { - left.type in IntegerDatatypes -> when { - right.type in IntegerDatatypes -> NumericLiteralValue.fromBoolean(left.number.toInt() != 0 && right.number.toInt() != 0, left.position) - right.type == DataType.FLOAT -> NumericLiteralValue.fromBoolean(left.number.toInt() != 0 && right.number.toDouble() != 0.0, left.position) + return when (left.type) { + in IntegerDatatypes -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue.fromBoolean(left.number.toInt() != 0 && right.number.toInt() != 0, left.position) + DataType.FLOAT -> NumericLiteralValue.fromBoolean(left.number.toInt() != 0 && right.number.toDouble() != 0.0, left.position) else -> throw ExpressionError(error, left.position) } - left.type == DataType.FLOAT -> when { - right.type in IntegerDatatypes -> NumericLiteralValue.fromBoolean(left.number.toDouble() != 0.0 && right.number.toInt() != 0, left.position) - right.type == DataType.FLOAT -> NumericLiteralValue.fromBoolean(left.number.toDouble() != 0.0 && right.number.toDouble() != 0.0, left.position) + DataType.FLOAT -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue.fromBoolean(left.number.toDouble() != 0.0 && right.number.toInt() != 0, left.position) + DataType.FLOAT -> NumericLiteralValue.fromBoolean(left.number.toDouble() != 0.0 && right.number.toDouble() != 0.0, left.position) else -> throw ExpressionError(error, left.position) } else -> throw ExpressionError(error, left.position) @@ -144,15 +144,15 @@ class ConstExprEvaluator { private fun power(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue { val error = "cannot calculate $left ** $right" - return when { - left.type in IntegerDatatypes -> when { - right.type in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt().toDouble().pow(right.number.toInt()), left.position) - right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt().toDouble().pow(right.number.toDouble()), left.position) + return when (left.type) { + in IntegerDatatypes -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt().toDouble().pow(right.number.toInt()), left.position) + DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt().toDouble().pow(right.number.toDouble()), left.position) else -> throw ExpressionError(error, left.position) } - left.type == DataType.FLOAT -> when { - right.type in IntegerDatatypes -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble().pow(right.number.toInt()), left.position) - right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble().pow(right.number.toDouble()), left.position) + DataType.FLOAT -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble().pow(right.number.toInt()), left.position) + DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble().pow(right.number.toDouble()), left.position) else -> throw ExpressionError(error, left.position) } else -> throw ExpressionError(error, left.position) @@ -161,15 +161,15 @@ class ConstExprEvaluator { private fun plus(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue { val error = "cannot add $left and $right" - return when { - left.type in IntegerDatatypes -> when { - right.type in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt() + right.number.toInt(), left.position) - right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt() + right.number.toDouble(), left.position) + return when (left.type) { + in IntegerDatatypes -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt() + right.number.toInt(), left.position) + DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt() + right.number.toDouble(), left.position) else -> throw ExpressionError(error, left.position) } - left.type == DataType.FLOAT -> when { - right.type in IntegerDatatypes -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() + right.number.toInt(), left.position) - right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() + right.number.toDouble(), left.position) + DataType.FLOAT -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() + right.number.toInt(), left.position) + DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() + right.number.toDouble(), left.position) else -> throw ExpressionError(error, left.position) } else -> throw ExpressionError(error, left.position) @@ -178,15 +178,15 @@ class ConstExprEvaluator { private fun minus(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue { val error = "cannot subtract $left and $right" - return when { - left.type in IntegerDatatypes -> when { - right.type in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt() - right.number.toInt(), left.position) - right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt() - right.number.toDouble(), left.position) + return when (left.type) { + in IntegerDatatypes -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt() - right.number.toInt(), left.position) + DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt() - right.number.toDouble(), left.position) else -> throw ExpressionError(error, left.position) } - left.type == DataType.FLOAT -> when { - right.type in IntegerDatatypes -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() - right.number.toInt(), left.position) - right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() - right.number.toDouble(), left.position) + DataType.FLOAT -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() - right.number.toInt(), left.position) + DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() - right.number.toDouble(), left.position) else -> throw ExpressionError(error, left.position) } else -> throw ExpressionError(error, left.position) @@ -195,15 +195,15 @@ class ConstExprEvaluator { private fun multiply(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue { val error = "cannot multiply ${left.type} and ${right.type}" - return when { - left.type in IntegerDatatypes -> when { - right.type in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt() * right.number.toInt(), left.position) - right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt() * right.number.toDouble(), left.position) + return when (left.type) { + in IntegerDatatypes -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue.optimalNumeric(left.number.toInt() * right.number.toInt(), left.position) + DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toInt() * right.number.toDouble(), left.position) else -> throw ExpressionError(error, left.position) } - left.type == DataType.FLOAT -> when { - right.type in IntegerDatatypes -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() * right.number.toInt(), left.position) - right.type == DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() * right.number.toDouble(), left.position) + DataType.FLOAT -> when (right.type) { + in IntegerDatatypes -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() * right.number.toInt(), left.position) + DataType.FLOAT -> NumericLiteralValue(DataType.FLOAT, left.number.toDouble() * right.number.toDouble(), left.position) else -> throw ExpressionError(error, left.position) } else -> throw ExpressionError(error, left.position) @@ -215,25 +215,25 @@ class ConstExprEvaluator { private fun divide(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue { val error = "cannot divide $left by $right" - return when { - left.type in IntegerDatatypes -> when { - right.type in IntegerDatatypes -> { + return when (left.type) { + in IntegerDatatypes -> when (right.type) { + in IntegerDatatypes -> { if(right.number.toInt()==0) divideByZeroError(right.position) val result: Int = left.number.toInt() / right.number.toInt() NumericLiteralValue.optimalNumeric(result, left.position) } - right.type == DataType.FLOAT -> { + DataType.FLOAT -> { if(right.number.toDouble()==0.0) divideByZeroError(right.position) NumericLiteralValue(DataType.FLOAT, left.number.toInt() / right.number.toDouble(), left.position) } else -> throw ExpressionError(error, left.position) } - left.type == DataType.FLOAT -> when { - right.type in IntegerDatatypes -> { + DataType.FLOAT -> when (right.type) { + in IntegerDatatypes -> { if(right.number.toInt()==0) divideByZeroError(right.position) NumericLiteralValue(DataType.FLOAT, left.number.toDouble() / right.number.toInt(), left.position) } - right.type == DataType.FLOAT -> { + DataType.FLOAT -> { if(right.number.toDouble()==0.0) divideByZeroError(right.position) NumericLiteralValue(DataType.FLOAT, left.number.toDouble() / right.number.toDouble(), left.position) } @@ -245,24 +245,24 @@ class ConstExprEvaluator { private fun remainder(left: NumericLiteralValue, right: NumericLiteralValue): NumericLiteralValue { val error = "cannot compute remainder of $left by $right" - return when { - left.type in IntegerDatatypes -> when { - right.type in IntegerDatatypes -> { + return when (left.type) { + in IntegerDatatypes -> when (right.type) { + in IntegerDatatypes -> { if(right.number.toInt()==0) divideByZeroError(right.position) NumericLiteralValue.optimalNumeric(left.number.toInt().toDouble() % right.number.toInt().toDouble(), left.position) } - right.type == DataType.FLOAT -> { + DataType.FLOAT -> { if(right.number.toDouble()==0.0) divideByZeroError(right.position) NumericLiteralValue(DataType.FLOAT, left.number.toInt() % right.number.toDouble(), left.position) } else -> throw ExpressionError(error, left.position) } - left.type == DataType.FLOAT -> when { - right.type in IntegerDatatypes -> { + DataType.FLOAT -> when (right.type) { + in IntegerDatatypes -> { if(right.number.toInt()==0) divideByZeroError(right.position) NumericLiteralValue(DataType.FLOAT, left.number.toDouble() % right.number.toInt(), left.position) } - right.type == DataType.FLOAT -> { + DataType.FLOAT -> { if(right.number.toDouble()==0.0) divideByZeroError(right.position) NumericLiteralValue(DataType.FLOAT, left.number.toDouble() % right.number.toDouble(), left.position) } diff --git a/compiler/src/prog8/optimizer/ConstantFolding.kt b/compiler/src/prog8/optimizer/ConstantFolding.kt index 110e767b8..e991bee42 100644 --- a/compiler/src/prog8/optimizer/ConstantFolding.kt +++ b/compiler/src/prog8/optimizer/ConstantFolding.kt @@ -171,13 +171,13 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor { return try { val cval = identifier.constValue(program) ?: return identifier - return when { - cval.type in NumericDatatypes -> { + return when (cval.type) { + in NumericDatatypes -> { val copy = NumericLiteralValue(cval.type, cval.number, identifier.position) copy.parent = identifier.parent copy } - cval.type in PassByReferenceDatatypes -> throw FatalAstException("pass-by-reference type should not be considered a constant") + in PassByReferenceDatatypes -> throw FatalAstException("pass-by-reference type should not be considered a constant") else -> identifier } } catch (ax: AstException) { @@ -208,12 +208,12 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor { val builtinFunction = BuiltinFunctions[functionCall.target.nameInSource.single()] if(builtinFunction!=null) { // match the arguments of a builtin function signature. - for(arg in functionCall.arglist.withIndex().zip(builtinFunction.parameters)) { + for(arg in functionCall.args.withIndex().zip(builtinFunction.parameters)) { val possibleDts = arg.second.possibleDatatypes val argConst = arg.first.value.constValue(program) if(argConst!=null && argConst.type !in possibleDts) { val convertedValue = argConst.cast(possibleDts.first()) - functionCall.arglist[arg.first.index] = convertedValue + functionCall.args[arg.first.index] = convertedValue optimizationsDone++ } } @@ -224,12 +224,12 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor { val subroutine = functionCall.target.targetSubroutine(program.namespace) if(subroutine!=null) { // if types differ, try to typecast constant arguments to the function call to the desired data type of the parameter - for(arg in functionCall.arglist.withIndex().zip(subroutine.parameters)) { + for(arg in functionCall.args.withIndex().zip(subroutine.parameters)) { val expectedDt = arg.second.type val argConst = arg.first.value.constValue(program) if(argConst!=null && argConst.type!=expectedDt) { val convertedValue = argConst.cast(expectedDt) - functionCall.arglist[arg.first.index] = convertedValue + functionCall.args[arg.first.index] = convertedValue optimizationsDone++ } } @@ -258,27 +258,27 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor { val subexpr = prefixExpr.expression if (subexpr is NumericLiteralValue) { // accept prefixed literal values (such as -3, not true) - return when { - prefixExpr.operator == "+" -> subexpr - prefixExpr.operator == "-" -> when { - subexpr.type in IntegerDatatypes -> { + return when (prefixExpr.operator) { + "+" -> subexpr + "-" -> when (subexpr.type) { + in IntegerDatatypes -> { optimizationsDone++ NumericLiteralValue.optimalNumeric(-subexpr.number.toInt(), subexpr.position) } - subexpr.type == DataType.FLOAT -> { + DataType.FLOAT -> { optimizationsDone++ NumericLiteralValue(DataType.FLOAT, -subexpr.number.toDouble(), subexpr.position) } else -> throw ExpressionError("can only take negative of int or float", subexpr.position) } - prefixExpr.operator == "~" -> when { - subexpr.type in IntegerDatatypes -> { + "~" -> when (subexpr.type) { + in IntegerDatatypes -> { optimizationsDone++ NumericLiteralValue.optimalNumeric(subexpr.number.toInt().inv(), subexpr.position) } else -> throw ExpressionError("can only take bitwise inversion of int", subexpr.position) } - prefixExpr.operator == "not" -> { + "not" -> { optimizationsDone++ NumericLiteralValue.fromBoolean(subexpr.number.toDouble() == 0.0, subexpr.position) } diff --git a/compiler/src/prog8/optimizer/StatementOptimizer.kt b/compiler/src/prog8/optimizer/StatementOptimizer.kt index 0ee7cf6ea..3b9f1c6eb 100644 --- a/compiler/src/prog8/optimizer/StatementOptimizer.kt +++ b/compiler/src/prog8/optimizer/StatementOptimizer.kt @@ -169,7 +169,7 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV if(functionCallStatement.target.nameInSource==listOf("c64scr", "print") || functionCallStatement.target.nameInSource==listOf("c64scr", "print_p")) { // printing a literal string of just 2 or 1 characters is replaced by directly outputting those characters - val arg = functionCallStatement.arglist.single() + val arg = functionCallStatement.args.single() val stringVar: IdentifierReference? stringVar = if(arg is AddressOf) { arg.identifier @@ -181,8 +181,8 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV val string = vardecl.value!! as StringLiteralValue if(string.value.length==1) { val firstCharEncoded = CompilationTarget.encodeString(string.value)[0] - functionCallStatement.arglist.clear() - functionCallStatement.arglist.add(NumericLiteralValue.optimalInteger(firstCharEncoded.toInt(), functionCallStatement.position)) + functionCallStatement.args.clear() + functionCallStatement.args.add(NumericLiteralValue.optimalInteger(firstCharEncoded.toInt(), functionCallStatement.position)) functionCallStatement.target = IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position) vardeclsToRemove.add(vardecl) optimizationsDone++ @@ -209,7 +209,7 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull() if(first is Jump && first.identifier!=null) { optimizationsDone++ - return FunctionCallStatement(first.identifier, functionCallStatement.arglist, functionCallStatement.position) + return FunctionCallStatement(first.identifier, functionCallStatement.args, functionCallStatement.position) } if(first is ReturnFromIrq || first is Return) { optimizationsDone++ @@ -229,7 +229,7 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull() if(first is Jump && first.identifier!=null) { optimizationsDone++ - return FunctionCall(first.identifier, functionCall.arglist, functionCall.position) + return FunctionCall(first.identifier, functionCall.args, functionCall.position) } if(first is Return && first.value!=null) { val constval = first.value?.constValue(program) diff --git a/compiler/src/prog8/vm/astvm/AstVm.kt b/compiler/src/prog8/vm/astvm/AstVm.kt index 3e010e3b6..24a19dc45 100644 --- a/compiler/src/prog8/vm/astvm/AstVm.kt +++ b/compiler/src/prog8/vm/astvm/AstVm.kt @@ -339,10 +339,9 @@ class AstVm(val program: Program, compilationTarget: String) { // should have been defined already when the program started } is FunctionCallStatement -> { - val target = stmt.target.targetStatement(program.namespace) - when (target) { + when (val target = stmt.target.targetStatement(program.namespace)) { is Subroutine -> { - val args = evaluate(stmt.arglist).map { it as RuntimeValueNumeric } + val args = evaluate(stmt.args).map { it as RuntimeValueNumeric } if (target.isAsmSubroutine) { performSyscall(target, args) } else { @@ -355,7 +354,7 @@ class AstVm(val program: Program, compilationTarget: String) { // swap cannot be implemented as a function, so inline it here executeSwap(stmt) } else { - val args = evaluate(stmt.arglist) + val args = evaluate(stmt.args) performBuiltinFunction(target.name, args, statusflags) } } @@ -388,18 +387,18 @@ class AstVm(val program: Program, compilationTarget: String) { when(ident.type){ VarDeclType.VAR -> { var value = runtimeVariables.get(identScope, ident.name) as RuntimeValueNumeric - value = when { - stmt.operator == "++" -> value.add(RuntimeValueNumeric(value.type, 1)) - stmt.operator == "--" -> value.sub(RuntimeValueNumeric(value.type, 1)) + value = when (stmt.operator) { + "++" -> value.add(RuntimeValueNumeric(value.type, 1)) + "--" -> value.sub(RuntimeValueNumeric(value.type, 1)) else -> throw VmExecutionException("strange postincdec operator $stmt") } runtimeVariables.set(identScope, ident.name, value) } VarDeclType.MEMORY -> { val addr=ident.value!!.constValue(program)!!.number.toInt() - val newval = when { - stmt.operator == "++" -> mem.getUByte(addr)+1 and 255 - stmt.operator == "--" -> mem.getUByte(addr)-1 and 255 + val newval = when (stmt.operator) { + "++" -> mem.getUByte(addr)+1 and 255 + "--" -> mem.getUByte(addr)-1 and 255 else -> throw VmExecutionException("strange postincdec operator $stmt") } mem.setUByte(addr,newval.toShort()) @@ -409,9 +408,9 @@ class AstVm(val program: Program, compilationTarget: String) { } stmt.target.memoryAddress != null -> { val addr = (evaluate(stmt.target.memoryAddress!!.addressExpression, evalCtx) as RuntimeValueNumeric).integerValue() - val newval = when { - stmt.operator == "++" -> mem.getUByte(addr)+1 and 255 - stmt.operator == "--" -> mem.getUByte(addr)-1 and 255 + val newval = when (stmt.operator) { + "++" -> mem.getUByte(addr)+1 and 255 + "--" -> mem.getUByte(addr)-1 and 255 else -> throw VmExecutionException("strange postincdec operator $stmt") } mem.setUByte(addr,newval.toShort()) @@ -424,18 +423,18 @@ class AstVm(val program: Program, compilationTarget: String) { if(!elementType.isKnown) throw VmExecutionException("unknown/void elt type") var value = RuntimeValueNumeric(elementType.typeOrElse(DataType.BYTE), arrayvalue.array[index].toInt()) - value = when { - stmt.operator == "++" -> value.inc() - stmt.operator == "--" -> value.dec() + value = when (stmt.operator) { + "++" -> value.inc() + "--" -> value.dec() else -> throw VmExecutionException("strange postincdec operator $stmt") } arrayvalue.array[index] = value.numericValue() } stmt.target.register != null -> { var value = runtimeVariables.get(program.namespace, stmt.target.register!!.name) as RuntimeValueNumeric - value = when { - stmt.operator == "++" -> value.add(RuntimeValueNumeric(value.type, 1)) - stmt.operator == "--" -> value.sub(RuntimeValueNumeric(value.type, 1)) + value = when (stmt.operator) { + "++" -> value.add(RuntimeValueNumeric(value.type, 1)) + "--" -> value.sub(RuntimeValueNumeric(value.type, 1)) else -> throw VmExecutionException("strange postincdec operator $stmt") } runtimeVariables.set(program.namespace, stmt.target.register!!.name, value) @@ -551,8 +550,8 @@ class AstVm(val program: Program, compilationTarget: String) { } private fun executeSwap(swap: FunctionCallStatement) { - val v1 = swap.arglist[0] - val v2 = swap.arglist[1] + val v1 = swap.args[0] + val v2 = swap.args[1] val value1 = evaluate(v1, evalCtx) val value2 = evaluate(v2, evalCtx) val target1 = AssignTarget.fromExpr(v1) @@ -773,7 +772,7 @@ class AstVm(val program: Program, compilationTarget: String) { "c64utils.str2uword" -> { val heapId = args[0].wordval!! val argString = getAsciiStringFromRuntimeVars(heapId) - val numericpart = argString.takeWhile { it.toChar().isDigit() }.toString() + val numericpart = argString.takeWhile { it.isDigit() } result = RuntimeValueNumeric(DataType.UWORD, numericpart.toInt() and 65535) } else -> TODO("syscall ${sub.scopedname} $sub") diff --git a/compiler/src/prog8/vm/astvm/Expressions.kt b/compiler/src/prog8/vm/astvm/Expressions.kt index 762b4ef63..923bebd62 100644 --- a/compiler/src/prog8/vm/astvm/Expressions.kt +++ b/compiler/src/prog8/vm/astvm/Expressions.kt @@ -134,7 +134,7 @@ fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValueBase { } is FunctionCall -> { val sub = expr.target.targetStatement(ctx.program.namespace) - val args = expr.arglist.map { evaluate(it, ctx) as RuntimeValueNumeric } + val args = expr.args.map { evaluate(it, ctx) as RuntimeValueNumeric } return when(sub) { is Subroutine -> { val result = ctx.executeSubroutine(sub, args, null)