removed lsl() and lsr() functions just use <<=1 and >>=1

compiler/res/prog8lib/prog8lib.asm

@@ -1839,120 +1839,6 @@ rol2_mem_ub	.proc
 		rts
 		.pend
 
-lsl_array_b	.proc
-		; -- lsl a (u)byte in an array (index and array address on stack)
-		inx
-		ldy  c64.ESTACK_LO,x
-		inx
-		lda  c64.ESTACK_LO,x
-		sta  c64.SCRATCH_ZPWORD1
-		lda  c64.ESTACK_HI,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		lda  (c64.SCRATCH_ZPWORD1),y
-		asl  a
-		sta  (c64.SCRATCH_ZPWORD1),y
-		rts
-		.pend
-
-lsr_array_ub	.proc
-		; -- lsr a ubyte in an array (index and array address on stack)
-		inx
-		ldy  c64.ESTACK_LO,x
-		inx
-		lda  c64.ESTACK_LO,x
-		sta  c64.SCRATCH_ZPWORD1
-		lda  c64.ESTACK_HI,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		lda  (c64.SCRATCH_ZPWORD1),y
-		lsr  a
-		sta  (c64.SCRATCH_ZPWORD1),y
-		rts
-		.pend
-
-lsr_array_b	.proc
-		; -- lsr a byte in an array (index and array address on stack)
-		inx
-		ldy  c64.ESTACK_LO,x
-		inx
-		lda  c64.ESTACK_LO,x
-		sta  c64.SCRATCH_ZPWORD1
-		lda  c64.ESTACK_HI,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		lda  (c64.SCRATCH_ZPWORD1),y
-		asl  a
-		lda  (c64.SCRATCH_ZPWORD1),y
-		ror  a
-		sta  (c64.SCRATCH_ZPWORD1),y
-		rts
-		.pend
-
-lsl_array_w	.proc
-		; -- lsl a (u)word in an array (index and array address on stack)
-		inx
-		lda  c64.ESTACK_LO,x
-		asl  a
-		tay
-		inx
-		lda  c64.ESTACK_LO,x
-		sta  c64.SCRATCH_ZPWORD1
-		lda  c64.ESTACK_HI,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		lda  (c64.SCRATCH_ZPWORD1),y
-		asl  a
-		sta  (c64.SCRATCH_ZPWORD1),y
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		rol  a
-		sta  (c64.SCRATCH_ZPWORD1),y
-		rts
-		.pend
-
-lsr_array_uw	.proc
-		; -- lsr a uword in an array (index and array address on stack)
-		inx
-		lda  c64.ESTACK_LO,x
-		asl  a
-		tay
-		inx
-		lda  c64.ESTACK_LO,x
-		sta  c64.SCRATCH_ZPWORD1
-		lda  c64.ESTACK_HI,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		lsr  a
-		sta  (c64.SCRATCH_ZPWORD1),y
-		dey
-		lda  (c64.SCRATCH_ZPWORD1),y
-		ror  a
-		sta  (c64.SCRATCH_ZPWORD1),y
-		rts
-		.pend
-
-lsr_array_w	.proc
-		; -- lsr a uword in an array (index and array address on stack)
-		inx
-		lda  c64.ESTACK_LO,x
-		asl  a
-		tay
-		inx
-		lda  c64.ESTACK_LO,x
-		sta  c64.SCRATCH_ZPWORD1
-		lda  c64.ESTACK_HI,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		asl  a
-		lda  (c64.SCRATCH_ZPWORD1),y
-		ror  a
-		sta  (c64.SCRATCH_ZPWORD1),y
-		dey
-		lda  (c64.SCRATCH_ZPWORD1),y
-		ror  a
-		sta  (c64.SCRATCH_ZPWORD1),y
-		rts
-		.pend
-
 rol_array_ub	.proc
 		; -- rol a ubyte in an array (index and array address on stack)
 		inx

compiler/src/prog8/ast/processing/AstChecker.kt

@@ -863,7 +863,7 @@ internal class AstChecker(private val program: Program,
             }
         }
 
-        if(functionCallStatement.target.nameInSource.last() in setOf("lsl", "lsr", "rol", "ror", "rol2", "ror2", "swap", "sort", "reverse")) {
+        if(functionCallStatement.target.nameInSource.last() in setOf("rol", "ror", "rol2", "ror2", "swap", "sort", "reverse")) {
             // in-place modification, can't be done on literals
             if(functionCallStatement.args.any { it !is IdentifierReference && it !is ArrayIndexedExpression && it !is DirectMemoryRead }) {
                 errors.err("invalid argument to a in-place modifying function", functionCallStatement.args.first().position)

compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt

@@ -47,8 +47,6 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
             "ln", "log2", "sqrt", "rad",
             "deg", "round", "floor", "ceil",
             "rdnf" -> funcVariousFloatFuncs(fcall, func, functionName)
-            "lsl" -> funcLsl(fcall)
-            "lsr" -> funcLsr(fcall)
             "rol" -> funcRol(fcall)
             "rol2" -> funcRol2(fcall)
             "ror" -> funcRor(fcall)
@@ -347,132 +345,6 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
         }
     }
 
-    private fun funcLsr(fcall: IFunctionCall) {
-        val what = fcall.args.single()
-        val dt = what.inferType(program)
-        when (dt.typeOrElse(DataType.STRUCT)) {
-            DataType.UBYTE -> {
-                when (what) {
-                    is IdentifierReference -> asmgen.out("  lsr  ${asmgen.asmIdentifierName(what)}")
-                    is DirectMemoryRead -> {
-                        if (what.addressExpression is NumericLiteralValue) {
-                            val number = (what.addressExpression as NumericLiteralValue).number
-                            asmgen.out("  lsr  ${number.toHex()}")
-                        } else {
-                            asmgen.translateExpression(what.addressExpression)
-                            asmgen.out("""
-                        inx
-                        lda  $ESTACK_LO_HEX,x
-                        sta  (+) + 1
-                        lda  $ESTACK_HI_HEX,x
-                        sta  (+) + 2
-    +                   lsr  ${'$'}ffff            ; modified                    
-                                        """)
-                        }
-                    }
-                    is ArrayIndexedExpression -> {
-                        asmgen.translateExpression(what.identifier)
-                        asmgen.translateExpression(what.arrayspec.index)
-                        asmgen.out("  jsr  prog8_lib.lsr_array_ub")
-                    }
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.BYTE -> {
-                when (what) {
-                    is ArrayIndexedExpression -> {
-                        asmgen.translateExpression(what.identifier)
-                        asmgen.translateExpression(what.arrayspec.index)
-                        asmgen.out("  jsr  prog8_lib.lsr_array_b")
-                    }
-                    is IdentifierReference -> {
-                        val variable = asmgen.asmIdentifierName(what)
-                        asmgen.out("  lda  $variable |  asl  a |  ror  $variable")
-                    }
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.UWORD -> {
-                when (what) {
-                    is ArrayIndexedExpression -> {
-                        asmgen.translateExpression(what.identifier)
-                        asmgen.translateExpression(what.arrayspec.index)
-                        asmgen.out("  jsr  prog8_lib.lsr_array_uw")
-                    }
-                    is IdentifierReference -> {
-                        val variable = asmgen.asmIdentifierName(what)
-                        asmgen.out(" lsr  $variable+1 |  ror  $variable")
-                    }
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.WORD -> {
-                when (what) {
-                    is ArrayIndexedExpression -> {
-                        asmgen.translateExpression(what.identifier)
-                        asmgen.translateExpression(what.arrayspec.index)
-                        asmgen.out("  jsr  prog8_lib.lsr_array_w")
-                    }
-                    is IdentifierReference -> {
-                        val variable = asmgen.asmIdentifierName(what)
-                        asmgen.out("  lda  $variable+1 |  asl a  |  ror  $variable+1 |  ror  $variable")
-                    }
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            else -> throw AssemblyError("weird type")
-        }
-    }
-
-    private fun funcLsl(fcall: IFunctionCall) {
-        val what = fcall.args.single()
-        val dt = what.inferType(program)
-        when (dt.typeOrElse(DataType.STRUCT)) {
-            in ByteDatatypes -> {
-                when (what) {
-                    is IdentifierReference -> asmgen.out("  asl  ${asmgen.asmIdentifierName(what)}")
-                    is DirectMemoryRead -> {
-                        if (what.addressExpression is NumericLiteralValue) {
-                            val number = (what.addressExpression as NumericLiteralValue).number
-                            asmgen.out("  asl  ${number.toHex()}")
-                        } else {
-                            asmgen.translateExpression(what.addressExpression)
-                            asmgen.out("""
-                        inx
-                        lda  $ESTACK_LO_HEX,x
-                        sta  (+) + 1
-                        lda  $ESTACK_HI_HEX,x
-                        sta  (+) + 2
-    +                   asl  ${'$'}ffff            ; modified                    
-                                        """)
-                        }
-                    }
-                    is ArrayIndexedExpression -> {
-                        asmgen.translateExpression(what.identifier)
-                        asmgen.translateExpression(what.arrayspec.index)
-                        asmgen.out("  jsr  prog8_lib.lsl_array_b")
-                    }
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            in WordDatatypes -> {
-                when (what) {
-                    is ArrayIndexedExpression -> {
-                        asmgen.translateExpression(what.identifier)
-                        asmgen.translateExpression(what.arrayspec.index)
-                        asmgen.out("  jsr  prog8_lib.lsl_array_w")
-                    }
-                    is IdentifierReference -> {
-                        val variable = asmgen.asmIdentifierName(what)
-                        asmgen.out(" asl  $variable |  rol  $variable+1")
-                    }
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            else -> throw AssemblyError("weird type")
-        }
-    }
-
     private fun funcVariousFloatFuncs(fcall: IFunctionCall, func: FSignature, functionName: String) {
         translateFunctionArguments(fcall.args, func)
         asmgen.out("  jsr  c64flt.func_$functionName")

compiler/src/prog8/functions/BuiltinFunctions.kt

@@ -27,8 +27,6 @@ val BuiltinFunctions = mapOf(
     "ror"         to FSignature(false, listOf(FParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
     "rol2"        to FSignature(false, listOf(FParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
     "ror2"        to FSignature(false, listOf(FParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
-    "lsl"         to FSignature(false, listOf(FParam("item", IntegerDatatypes)), null),
-    "lsr"         to FSignature(false, listOf(FParam("item", IntegerDatatypes)), null),
     "sort"        to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
     "reverse"     to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
         // these few have a return value depending on the argument(s):

compiler/src/prog8/optimizer/StatementOptimizer.kt

@@ -438,28 +438,10 @@ internal class StatementOptimizer(private val program: Program,
                     "<<" -> {
                         if (cv == 0.0)
                             return listOf(IAstModification.Remove(assignment, parent))
-                        // replace by in-place lsl(...) call
-                        val scope = AnonymousScope(mutableListOf(), assignment.position)
-                        var numshifts = cv.toInt()
-                        while (numshifts > 0) {
-                            scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsl"), assignment.position),
-                                    mutableListOf(bexpr.left), true, assignment.position))
-                            numshifts--
-                        }
-                        return listOf(IAstModification.ReplaceNode(assignment, scope, parent))
                     }
                     ">>" -> {
                         if (cv == 0.0)
                             return listOf(IAstModification.Remove(assignment, parent))
-                        // replace by in-place lsr(...) call
-                        val scope = AnonymousScope(mutableListOf(), assignment.position)
-                        var numshifts = cv.toInt()
-                        while (numshifts > 0) {
-                            scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsr"), assignment.position),
-                                    mutableListOf(bexpr.left), true, assignment.position))
-                            numshifts--
-                        }
-                        return listOf(IAstModification.ReplaceNode(assignment, scope, parent))
                     }
                 }
 

examples/wizzine.p8

@@ -55,7 +55,7 @@ irq {
             uword @zp x = sin8u(angle*2-spri*16) as uword + 50
             ubyte @zp y = cos8u(angle*3-spri*16) / 2 + 70
             c64.SPXYW[spri] = mkword(lsb(x), y)
-            lsl(c64.MSIGX)
+            c64.MSIGX <<= 1
             if msb(x) c64.MSIGX++
             c64.EXTCOL++
         }