Apple-2-SW/prog8
1
0
Fork 0
mirror of https://github.com/irmen/prog8.git synced 2024-11-18 19:12:44 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into split-arrays

Browse Source 
# Conflicts:
#	examples/test.p8
This commit is contained in:
Irmen de Jong 2023-05-28 13:28:43 +02:00
commit 39eda67867
4 changed files with 39 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt
View File

@ -157,6 +157,12 @@ class UnusedCodeRemover(private val program: Program,
return noModifications return noModifications
} }
override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
if(assignment.target isSameAs assignment.value)
return listOf(IAstModification.Remove(assignment, parent as IStatementContainer))
return noModifications
}
private fun deduplicateAssignments(statements: List<Statement>, scope: IStatementContainer): List<IAstModification> { private fun deduplicateAssignments(statements: List<Statement>, scope: IStatementContainer): List<IAstModification> {
// removes 'duplicate' assignments that assign the same target directly after another, unless it is a function call // removes 'duplicate' assignments that assign the same target directly after another, unless it is a function call
val linesToRemove = mutableListOf<Assignment>() val linesToRemove = mutableListOf<Assignment>()

11
compiler/src/prog8/compiler/astprocessing/AstChecker.kt
View File

@ -481,7 +481,9 @@ internal class AstChecker(private val program: Program,
errors.err("target datatype is unknown", assignment.target.position) errors.err("target datatype is unknown", assignment.target.position)
// otherwise, another error about missing symbol is already reported. // otherwise, another error about missing symbol is already reported.
} else { } else {
errors.err("type of value $valueDt doesn't match target $targetDt", assignment.value.position) // allow bitwise operations on different types as long as the size is the same
if (!((assignment.value as? BinaryExpression)?.operator in BitwiseOperators && targetDt.isBytes && valueDt.isBytes || targetDt.isWords && valueDt.isWords))
errors.err("type of value $valueDt doesn't match target $targetDt", assignment.value.position)
} }
} }
} }
@ -1608,8 +1610,11 @@ internal class AstChecker(private val program: Program,
else if(sourceDatatype== DataType.FLOAT && targetDatatype in IntegerDatatypes) else if(sourceDatatype== DataType.FLOAT && targetDatatype in IntegerDatatypes)
errors.err("cannot assign float to ${targetDatatype.name.lowercase()}; possible loss of precision. Suggestion: round the value or revert to integer arithmetic", position) errors.err("cannot assign float to ${targetDatatype.name.lowercase()}; possible loss of precision. Suggestion: round the value or revert to integer arithmetic", position)
else { else {
if(targetDatatype!=DataType.UWORD && sourceDatatype !in PassByReferenceDatatypes) if(targetDatatype!=DataType.UWORD && sourceDatatype !in PassByReferenceDatatypes) {
errors.err("type of value $sourceDatatype doesn't match target $targetDatatype", position) // allow bitwise operations on different types as long as the size is the same
if (!((sourceValue as? BinaryExpression)?.operator in BitwiseOperators && targetDatatype.equalsSize(sourceDatatype)))
errors.err("type of value $sourceDatatype doesn't match target $targetDatatype", position)
}
} }
return false return false

5
compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt
View File

@ -93,6 +93,11 @@ internal class BeforeAsmAstChanger(val program: Program,
) )
} }
} else { } else {
if(binExpr.left isSameAs assignment.target)
return noModifications
val typeCast = binExpr.left as? TypecastExpression
if(typeCast!=null && typeCast.expression isSameAs assignment.target)
return noModifications
val sourceDt = binExpr.left.inferType(program).getOrElse { throw AssemblyError("unknown dt") } val sourceDt = binExpr.left.inferType(program).getOrElse { throw AssemblyError("unknown dt") }
val (_, left) = binExpr.left.typecastTo(assignment.target.inferType(program).getOrElse { throw AssemblyError( val (_, left) = binExpr.left.typecastTo(assignment.target.inferType(program).getOrElse { throw AssemblyError(
"unknown dt" "unknown dt"

26
compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt
View File

@ -133,9 +133,16 @@ class TypecastsAdder(val program: Program, val options: CompilationOptions, val
return listOf(IAstModification.ReplaceNode(expr.left, cast, expr)) return listOf(IAstModification.ReplaceNode(expr.left, cast, expr))
} }
if(leftDt istype DataType.WORD && rightDt.oneOf(DataType.UBYTE, DataType.UWORD)) { if(leftDt istype DataType.WORD && rightDt.oneOf(DataType.UBYTE, DataType.UWORD)) {
// cast left to unsigned // cast left to unsigned word. Cast right to unsigned word if it is ubyte
val cast = TypecastExpression(expr.left, rightDt.getOr(DataType.UNDEFINED), true, expr.left.position) val mods = mutableListOf<IAstModification>()
return listOf(IAstModification.ReplaceNode(expr.left, cast, expr)) val cast = TypecastExpression(expr.left, DataType.UWORD, true, expr.left.position)
mods += IAstModification.ReplaceNode(expr.left, cast, expr)
if(rightDt istype DataType.UBYTE) {
mods += IAstModification.ReplaceNode(expr.right,
TypecastExpression(expr.right, DataType.UWORD, true, expr.right.position),
expr)
}
return mods
} }
if(rightDt istype DataType.BYTE && leftDt.oneOf(DataType.UBYTE, DataType.UWORD)) { if(rightDt istype DataType.BYTE && leftDt.oneOf(DataType.UBYTE, DataType.UWORD)) {
// cast right to unsigned // cast right to unsigned
@ -143,9 +150,16 @@ class TypecastsAdder(val program: Program, val options: CompilationOptions, val
return listOf(IAstModification.ReplaceNode(expr.right, cast, expr)) return listOf(IAstModification.ReplaceNode(expr.right, cast, expr))
} }
if(rightDt istype DataType.WORD && leftDt.oneOf(DataType.UBYTE, DataType.UWORD)) { if(rightDt istype DataType.WORD && leftDt.oneOf(DataType.UBYTE, DataType.UWORD)) {
// cast right to unsigned // cast right to unsigned word. Cast left to unsigned word if it is ubyte
val cast = TypecastExpression(expr.right, leftDt.getOr(DataType.UNDEFINED), true, expr.right.position) val mods = mutableListOf<IAstModification>()
return listOf(IAstModification.ReplaceNode(expr.right, cast, expr)) val cast = TypecastExpression(expr.right, DataType.UWORD, true, expr.right.position)
mods += IAstModification.ReplaceNode(expr.right, cast, expr)
if(leftDt istype DataType.UBYTE) {
mods += IAstModification.ReplaceNode(expr.left,
TypecastExpression(expr.left, DataType.UWORD, true, expr.left.position),
expr)
}
return mods
} }
} }