fix IR containment check

codeGenIntermediate/src/prog8/codegen/intermediate/BuiltinFuncGen.kt

@@ -580,6 +580,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         val arr = (arg as? PtArrayIndexer)
         val index = arr?.index?.asConstInteger()
         if(arr!=null && index!=null) {
+            if(arr.splitWords)  TODO("IR rol/ror on split words array")
             val variable = arr.variable.name
             val itemsize = codeGen.program.memsizer.memorySize(arr.type)
             addInstr(result, IRInstruction(opcodeMemAndReg.first, vmDt, labelSymbol = variable, symbolOffset = index*itemsize), null)

codeGenIntermediate/src/prog8/codegen/intermediate/ExpressionGen.kt

@@ -177,6 +177,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 val iterableTr = translateExpression(check.iterable)
                 addToResult(result, iterableTr, iterableTr.resultReg, -1)
                 result += codeGen.makeSyscall(IMSyscall.STRING_CONTAINS, listOf(IRDataType.BYTE to elementTr.resultReg, IRDataType.WORD to iterableTr.resultReg), IRDataType.BYTE to elementTr.resultReg)
+                addInstr(result, IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=elementTr.resultReg, immediate = 0), null)
                 return ExpressionCodeResult(result, IRDataType.BYTE, elementTr.resultReg, -1)
             }
             DataType.ARRAY_UB, DataType.ARRAY_B -> {
@@ -189,6 +190,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 val iterableLength = codeGen.symbolTable.getLength(check.iterable.name)
                 addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=lengthReg, immediate = iterableLength!!), null)
                 result += codeGen.makeSyscall(IMSyscall.BYTEARRAY_CONTAINS, listOf(IRDataType.BYTE to elementTr.resultReg, IRDataType.WORD to iterableTr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to elementTr.resultReg)
+                addInstr(result, IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=elementTr.resultReg, immediate = 0), null)
                 return ExpressionCodeResult(result, IRDataType.BYTE, elementTr.resultReg, -1)
             }
             DataType.ARRAY_UW, DataType.ARRAY_W -> {
@@ -201,6 +203,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 val iterableLength = codeGen.symbolTable.getLength(check.iterable.name)
                 addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=lengthReg, immediate = iterableLength!!), null)
                 result += codeGen.makeSyscall(IMSyscall.WORDARRAY_CONTAINS, listOf(IRDataType.WORD to elementTr.resultReg, IRDataType.WORD to iterableTr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to elementTr.resultReg)
+                addInstr(result, IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=elementTr.resultReg, immediate = 0), null)
                 return ExpressionCodeResult(result, IRDataType.BYTE, elementTr.resultReg, -1)
             }
             DataType.ARRAY_F -> {
@@ -214,6 +217,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 val iterableLength = codeGen.symbolTable.getLength(check.iterable.name)
                 addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=lengthReg, immediate = iterableLength!!), null)
                 result += codeGen.makeSyscall(IMSyscall.FLOATARRAY_CONTAINS, listOf(IRDataType.FLOAT to elementTr.resultFpReg, IRDataType.WORD to iterableTr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to resultReg)
+                addInstr(result, IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=resultReg, immediate = 0), null)
                 return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
             }
             else -> throw AssemblyError("weird iterable dt ${check.iterable.type} for ${check.iterable.name}")

docs/source/todo.rst

@@ -1,6 +1,9 @@
 TODO
 ====
 
+Main branch: possible optimization for:  if x < 2/ x<1  ->  if x==0 or x==1   likewise for > 253/ >254
+
+
 Improve register load order in subroutine call args assignments:
 in certain situations, the "wrong" order of evaluation of function call arguments is done which results
 in overwriting registers that already got their value, which requires a lot of stack juggling (especially on plain 6502 cpu!)

examples/test.p8

@@ -1,10 +1,40 @@
 %import textio
-
 %zeropage basicsafe
 %option no_sysinit
 
 main {
     sub start() {
-        txt.print_bool(cx16.mouse_present())
+        ubyte @shared x
+        uword @shared w
+
+        x=2
+        if x==2 or cx16.r0L==42
+            txt.print("yep0\n")
+
+        if x==1 or x==2
+            txt.print("yep1\n")
+
+        x = 9
+        if x==1 or x==2
+            txt.print("yep2-shouldn't-see-this\n")      ; TODO fix this in IR/VM
+
+        if x in 1 to 4
+            txt.print("yep3-shouldn't-see-this\n")
+        if x in 4 to 10
+            txt.print("yep4\n")
+
+
+        w=2222
+        if w==1111 or w==2222
+            txt.print("w-yep1\n")
+
+        w = 4999
+        if w==1111 or w==2222
+            txt.print("w-yep2-shouldn't-see-this\n")      ; TODO fix this in IR/VM
+
+        if w in 1111 to 4444
+            txt.print("w-yep3-shouldn't-see-this\n")
+        if w in 4444 to 5555
+            txt.print("w-yep4\n")
     }
 }