diff --git a/.gitignore b/.gitignore index 8066747b..fe4f9202 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,11 @@ temp.map ophis.bin build/* +# Input to the similarity tool - copyrighted material, we can't check it in! + +basic +kernal + # Various IDE project files, temporary files, etc. *project diff --git a/Makefile b/Makefile index ca8a7df0..62d70ab1 100644 --- a/Makefile +++ b/Makefile @@ -143,6 +143,6 @@ testremote: build/newkern_generic build/newbasic_generic testm65: build/newc65 m65 -b ../mega65-core/bin/mega65r1.bit -k ../mega65-core/bin/KICKUP.M65 -R build/newc65 -4 -testsimilarity: build/newrom_generic src/similarity +testsimilarity: build/newrom_generic $(TOOL_SIMILARITY) $(TOOL_SIMILARITY) kernal build/newrom_generic $(TOOL_SIMILARITY) basic build/newrom_generic diff --git a/bin/basic_generic.rom b/bin/basic_generic.rom index eeacf26d..29d891b1 100644 Binary files a/bin/basic_generic.rom and b/bin/basic_generic.rom differ diff --git a/bin/basic_mega65.rom b/bin/basic_mega65.rom index 26fe9385..a72bf16d 100644 Binary files a/bin/basic_mega65.rom and b/bin/basic_mega65.rom differ diff --git a/bin/basic_ultimate64.rom b/bin/basic_ultimate64.rom index 306e0230..6ed9ce5b 100644 Binary files a/bin/basic_ultimate64.rom and b/bin/basic_ultimate64.rom differ diff --git a/c64/basic/via_vector.s b/c64/basic/via_vector.s index e6a0be1a..3cfc7480 100644 --- a/c64/basic/via_vector.s +++ b/c64/basic/via_vector.s @@ -2,39 +2,41 @@ ;; ;; Helper routines for jumping via vectors, to be used with JSR ;; +;; Note: they are not in the order of low memory vectors, to avoid +;; similarity with the original ROMs -via_IOPEN: - jmp (IOPEN) +via_ISAVE: + jmp (ISAVE) + +via_ILOAD: + jmp (ILOAD) via_ICLOSE: jmp (ICLOSE) +via_IOPEN: + jmp (IOPEN) + via_ICHKIN: jmp (ICHKIN) -via_ICKOUT: - jmp (ICKOUT) - -via_ICLRCH: - jmp (ICLRCH) - via_IBASIN: jmp (IBASIN) -via_IBSOUT: - jmp (IBSOUT) - -via_ISTOP: - jmp (ISTOP) - via_IGETIN: jmp (IGETIN) - + +via_ICKOUT: + jmp (ICKOUT) + +via_IBSOUT: + jmp (IBSOUT) + +via_ICLRCH: + jmp (ICLRCH) + via_ICLALL: jmp (ICLALL) - -via_ILOAD: - jmp (ILOAD) - -via_ISAVE: - jmp (ISAVE) + +via_ISTOP: + jmp (ISTOP) diff --git a/strings/00003C b/strings/00003C new file mode 100644 index 00000000..0ae5a8af --- /dev/null +++ b/strings/00003C @@ -0,0 +1,3 @@ +$3C byte after some leading $00s + +Not creative. Not copyrightable. diff --git a/strings/0002A2 b/strings/0002A2 new file mode 100644 index 00000000..ef2431f1 --- /dev/null +++ b/strings/0002A2 @@ -0,0 +1,3 @@ +address $0200 + LDX# (argument does not match) + +Not even a full instruction - not copyrightable. diff --git a/strings/002090FF b/strings/002090FF new file mode 100644 index 00000000..4cb0adc7 --- /dev/null +++ b/strings/002090FF @@ -0,0 +1,3 @@ +$00 + JSR $FF90 (SETMSG) + +Instruction (jump to an official, docummented location) and some part. Not copyrightable. diff --git a/strings/006020 b/strings/006020 new file mode 100644 index 00000000..f5f52edc --- /dev/null +++ b/strings/006020 @@ -0,0 +1,3 @@ +$00 + RTS (or instruction part) + JSR xxxx + +Single byte instruction with two halfs, or half of the instruction + half of other. Not copyrightable. diff --git a/strings/00990001 b/strings/00990001 new file mode 100644 index 00000000..08241cc8 --- /dev/null +++ b/strings/00990001 @@ -0,0 +1,3 @@ +$00 + STA $0100, Y + +Single instruction and some part. Not copyrightable. diff --git a/strings/00990002 b/strings/00990002 new file mode 100644 index 00000000..8f8f4711 --- /dev/null +++ b/strings/00990002 @@ -0,0 +1,3 @@ +$00 + STA $0200, Y + +Single instruction and some part. Not copyrightable. diff --git a/strings/00DD60AD00DD09 b/strings/00DD60AD00DD09 new file mode 100644 index 00000000..64861d09 --- /dev/null +++ b/strings/00DD60AD00DD09 @@ -0,0 +1,5 @@ +address $DD00 (from previous instruction) + RTS (end of the routine, new one starting) + LDA $DD00 + ORA # (argument does not match) + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/026020 b/strings/026020 new file mode 100644 index 00000000..e0fe475c --- /dev/null +++ b/strings/026020 @@ -0,0 +1,3 @@ +byte $02 + RTS + JSR (address does not match) + +One instruction + some fragments. Not copyrightable. diff --git a/strings/02B96302 b/strings/02B96302 new file mode 100644 index 00000000..cb17a83e --- /dev/null +++ b/strings/02B96302 @@ -0,0 +1,4 @@ +$02 + LDA $0263, X (FAT table access) + +Single instruction (indexed access to a documented table) + some part. Not copyrightable. + diff --git a/strings/02B96D02 b/strings/02B96D02 new file mode 100644 index 00000000..8ceebc31 --- /dev/null +++ b/strings/02B96D02 @@ -0,0 +1,3 @@ +$02 + LDA $026D, X (SAT table access) + +Single instruction (indexed access to a documented table) + some part. Not copyrightable. diff --git a/strings/032060 b/strings/032060 new file mode 100644 index 00000000..ab518d6c --- /dev/null +++ b/strings/032060 @@ -0,0 +1,3 @@ +fragment + JSR + lower byte of jump address + +Not even a full instruction - not copyrightable. diff --git a/strings/034C09 b/strings/034C09 new file mode 100644 index 00000000..132c73fd --- /dev/null +++ b/strings/034C09 @@ -0,0 +1,3 @@ +fragment + JMP + lower byte of jump address + +Not even a full instruction - not copyrightable. diff --git a/strings/034C33 b/strings/034C33 new file mode 100644 index 00000000..132c73fd --- /dev/null +++ b/strings/034C33 @@ -0,0 +1,3 @@ +fragment + JMP + lower byte of jump address + +Not even a full instruction - not copyrightable. diff --git a/strings/034C83 b/strings/034C83 new file mode 100644 index 00000000..132c73fd --- /dev/null +++ b/strings/034C83 @@ -0,0 +1,3 @@ +fragment + JMP + lower byte of jump address + +Not even a full instruction - not copyrightable. diff --git a/strings/034C9E b/strings/034C9E new file mode 100644 index 00000000..132c73fd --- /dev/null +++ b/strings/034C9E @@ -0,0 +1,3 @@ +fragment + JMP + lower byte of jump address + +Not even a full instruction - not copyrightable. diff --git a/strings/034CFB b/strings/034CFB new file mode 100644 index 00000000..132c73fd --- /dev/null +++ b/strings/034CFB @@ -0,0 +1,3 @@ +fragment + JMP + lower byte of jump address + +Not even a full instruction - not copyrightable. diff --git a/strings/034CFC b/strings/034CFC new file mode 100644 index 00000000..132c73fd --- /dev/null +++ b/strings/034CFC @@ -0,0 +1,3 @@ +fragment + JMP + lower byte of jump address + +Not even a full instruction - not copyrightable. diff --git a/strings/036C1C036C b/strings/036C1C036C new file mode 100644 index 00000000..ebb399e0 --- /dev/null +++ b/strings/036C1C036C @@ -0,0 +1,3 @@ +$03 (most likely adddress higher byte) + JMP ($031C) (via public, documented vector) + JMP (address does not match) + +Code similarity due to Kernal API usage convention. Since 6510 CPU does not have indirect JSR, the only sane possibility to use Kernal API vectors in RAM ($0314-$0333) is to have JMP ($address) hardcoded somewhere. The jump table has intentionally strange order (to avoid code similarity as much as possible), but some small similarities can't be avoided in any reasonable way. diff --git a/strings/036C1E036C b/strings/036C1E036C new file mode 100644 index 00000000..e6f9e218 --- /dev/null +++ b/strings/036C1E036C @@ -0,0 +1,3 @@ +$03 (most likely adddress higher byte) + JMP ($031E) (via public, documented vector) + JMP (address does not match) + +Code similarity due to Kernal API usage convention. Since 6510 CPU does not have indirect JSR, the only sane possibility to use Kernal API vectors in RAM ($0314-$0333) is to have JMP ($address) hardcoded somewhere. The jump table has intentionally strange order (to avoid code similarity as much as possible), but some small similarities can't be avoided in any reasonable way. diff --git a/strings/036C20036C b/strings/036C20036C new file mode 100644 index 00000000..ab5ed572 --- /dev/null +++ b/strings/036C20036C @@ -0,0 +1,3 @@ +$03 (most likely adddress higher byte) + JMP ($0320) (via public, documented vector) + JMP (address does not match) + +Code similarity due to Kernal API usage convention. Since 6510 CPU does not have indirect JSR, the only sane possibility to use Kernal API vectors in RAM ($0314-$0333) is to have JMP ($address) hardcoded somewhere. The jump table has intentionally strange order (to avoid code similarity as much as possible), but some small similarities can't be avoided in any reasonable way. diff --git a/strings/036C22036C b/strings/036C22036C new file mode 100644 index 00000000..f05b4581 --- /dev/null +++ b/strings/036C22036C @@ -0,0 +1,3 @@ +$03 (most likely adddress higher byte) + JMP ($0322) (via public, documented vector) + JMP (address does not match) + +Code similarity due to Kernal API usage convention. Since 6510 CPU does not have indirect JSR, the only sane possibility to use Kernal API vectors in RAM ($0314-$0333) is to have JMP ($address) hardcoded somewhere. The jump table has intentionally strange order (to avoid code similarity as much as possible), but some small similarities can't be avoided in any reasonable way. diff --git a/strings/036C24036C b/strings/036C24036C new file mode 100644 index 00000000..4b11242c --- /dev/null +++ b/strings/036C24036C @@ -0,0 +1,3 @@ +03 (most likely adddress higher byte) + JMP ($0324) (via public, documented vector) + JMP (address does not match) + +Code similarity due to Kernal API usage convention. Since 6510 CPU does not have indirect JSR, the only sane possibility to use Kernal API vectors in RAM ($0314-$0333) is to have JMP ($address) hardcoded somewhere. The jump table has intentionally strange order (to avoid code similarity as much as possible), but some small similarities can't be avoided in any reasonable way. diff --git a/strings/036C2603 b/strings/036C2603 new file mode 100644 index 00000000..3271b1af --- /dev/null +++ b/strings/036C2603 @@ -0,0 +1,3 @@ +$03 (most likely adddress higher byte) + JMP ($0326) (via public, documented vector) + +Code similarity due to Kernal API usage convention. Since 6510 CPU does not have indirect JSR, the only sane possibility to use Kernal API vectors in RAM ($0314-$0333) is to have JMP ($address) hardcoded somewhere. The jump table has intentionally strange order (to avoid code similarity as much as possible), but some small similarities can't be avoided in any reasonable way. diff --git a/strings/036C2A036C b/strings/036C2A036C new file mode 100644 index 00000000..552a4b08 --- /dev/null +++ b/strings/036C2A036C @@ -0,0 +1,4 @@ +$03 (most likely adddress higher byte) + JMP ($032A) (via public, documented vector) + JMP (address does not match) + +Code similarity due to Kernal API usage convention. Since 6510 CPU does not have indirect JSR, the only sane possibility to use Kernal API vectors in RAM ($0314-$0333) is to have JMP ($address) hardcoded somewhere. The jump table has intentionally strange order (to avoid code similarity as much as possible), but some small similarities can't be avoided in any reasonable way. + diff --git a/strings/036C2C03 b/strings/036C2C03 new file mode 100644 index 00000000..3bf23438 --- /dev/null +++ b/strings/036C2C03 @@ -0,0 +1,3 @@ +$03 (most likely adddress higher byte) + JMP ($032C) (via public, documented vector) + +Code similarity due to Kernal API usage convention. Since 6510 CPU does not have indirect JSR, the only sane possibility to use Kernal API vectors in RAM ($0314-$0333) is to have JMP ($address) hardcoded somewhere. The jump table has intentionally strange order (to avoid code similarity as much as possible), but some small similarities can't be avoided in any reasonable way. diff --git a/strings/090185 b/strings/090185 new file mode 100644 index 00000000..46ebeb00 --- /dev/null +++ b/strings/090185 @@ -0,0 +1,3 @@ +ORA #$01 (or part of another instruction) + STA (address does not match) + +At most one instruction and a half - not copyrightable. diff --git a/strings/093020 b/strings/093020 new file mode 100644 index 00000000..e020853f --- /dev/null +++ b/strings/093020 @@ -0,0 +1,4 @@ +ORA #$30 + JSR without address +alternatively a value (part of the instruction) followed by a conditional jump + +Instruction and a half. Not copyrightable. diff --git a/strings/098085 b/strings/098085 new file mode 100644 index 00000000..00d602b9 --- /dev/null +++ b/strings/098085 @@ -0,0 +1,3 @@ +ORA #$80 (or part of another instruction) + STA (address does not match) + +At most one instruction and a half - not copyrightable. diff --git a/strings/0A90034C b/strings/0A90034C new file mode 100644 index 00000000..e9598dd7 --- /dev/null +++ b/strings/0A90034C @@ -0,0 +1,4 @@ +$0A + BCC addr + JMP (address does not match) + +Some part + BCC / JMP combo (typical construction on a 6502, where there is no conditional far jump), even the address does not match. Not copyrightable. + diff --git a/strings/0D4C4F4144494E b/strings/0D4C4F4144494E new file mode 100644 index 00000000..5eae602c --- /dev/null +++ b/strings/0D4C4F4144494E @@ -0,0 +1,5 @@ + / last 'jsr printf' instruction byte (pure coincidence) + "LOADIN" PETSCII string + +Not copyrightable. + + diff --git a/strings/0D534541524348494E47 b/strings/0D534541524348494E47 new file mode 100644 index 00000000..240ea5a8 --- /dev/null +++ b/strings/0D534541524348494E47 @@ -0,0 +1,3 @@ + / last 'jsr printf' instruction byte (pure coincidence) + "SEARCHING" PETSCII string + +Not copyrightable. diff --git a/strings/0D564552494659494E b/strings/0D564552494659494E new file mode 100644 index 00000000..38121d93 --- /dev/null +++ b/strings/0D564552494659494E @@ -0,0 +1,3 @@ + / last 'jsr printf' instruction byte (pure coincidence) + "VERIFYIN" PETSCII string + +Not copyrightable. diff --git a/strings/108D00DD b/strings/108D00DD new file mode 100644 index 00000000..b0d7830a --- /dev/null +++ b/strings/108D00DD @@ -0,0 +1,3 @@ +part of previous instruction + STA $DD00 + +Instruction (storing register in a well-known I/O register) preceeded by a half of another one - not copyrightable. diff --git a/strings/18607820 b/strings/18607820 new file mode 100644 index 00000000..2a01aa66 --- /dev/null +++ b/strings/18607820 @@ -0,0 +1,3 @@ +CLC + RTS (end of subroutine, another one starts) + SEI + JSR (address does not match) + +Nothing creative here. First 2 instruction, which is are a common way to end a subroutine and indicate a success. Afterwards a start of new subroutine, which starts with disabling interrupts. Not copyrightable. diff --git a/strings/1860A59D10 b/strings/1860A59D10 new file mode 100644 index 00000000..e7a89a08 --- /dev/null +++ b/strings/1860A59D10 @@ -0,0 +1,3 @@ +CLC + RTS + LDA $9D + BPL + +Nothing creative here. First 2 instruction, which is are a common way to end a subroutine and indicate a success. Afterwards a start of new subroutine, which starts by checking a documented zeropage variable. Not copyrightable. diff --git a/strings/2046524F4D20 b/strings/2046524F4D20 new file mode 100644 index 00000000..d2c609c4 --- /dev/null +++ b/strings/2046524F4D20 @@ -0,0 +1,3 @@ + + FROM + - PETSCII string + +Not copyrightable. diff --git a/strings/204F5045 b/strings/204F5045 new file mode 100644 index 00000000..bd9f84dd --- /dev/null +++ b/strings/204F5045 @@ -0,0 +1,3 @@ + + OPE - PETSCII string + +Syllable starting a word is definitely not copyrightable. diff --git a/strings/208EA6A9 b/strings/208EA6A9 new file mode 100644 index 00000000..809ed04c --- /dev/null +++ b/strings/208EA6A9 @@ -0,0 +1,3 @@ +JSR $A68E + LDA # (value does not match) + +Instruction and a half. Not copyrightable. diff --git a/strings/20BDFF20 b/strings/20BDFF20 new file mode 100644 index 00000000..77b74280 --- /dev/null +++ b/strings/20BDFF20 @@ -0,0 +1,3 @@ +JSR $FFBD (SETNAM) + JSR (address does not match) + +Instruction (jump to official, documented location) + one byte of another one. Not copyrightable. diff --git a/strings/29DF8D00DD b/strings/29DF8D00DD new file mode 100644 index 00000000..b159a7ac --- /dev/null +++ b/strings/29DF8D00DD @@ -0,0 +1,3 @@ +AND #$DF + STA $DD00 + +$DD00 is a hardware register, where one typically set/unset/read individual bits. Here we just have a trivial bit manipulation - not creeative, not copyrightable. diff --git a/strings/29DF8D00DD60AD00DD b/strings/29DF8D00DD60AD00DD new file mode 100644 index 00000000..8701bf28 --- /dev/null +++ b/strings/29DF8D00DD60AD00DD @@ -0,0 +1,5 @@ +AND #$DF + STA $DD00 + RTS + LDA $DD00 + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/29EF8D00DD60 b/strings/29EF8D00DD60 new file mode 100644 index 00000000..3a45bb8d --- /dev/null +++ b/strings/29EF8D00DD60 @@ -0,0 +1,5 @@ +AND #$EF + STA $DD00 + RTS + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/29EF8D00DD60AD00DD09 b/strings/29EF8D00DD60AD00DD09 new file mode 100644 index 00000000..6fb7f246 --- /dev/null +++ b/strings/29EF8D00DD60AD00DD09 @@ -0,0 +1,5 @@ +AND #$EF + STA $DD00 + RTS + LDA $DD00 + ORA# + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/29F78D00DD b/strings/29F78D00DD new file mode 100644 index 00000000..58a79f31 --- /dev/null +++ b/strings/29F78D00DD @@ -0,0 +1,3 @@ +AND #$F7 + STA $DD00 + +$DD00 is a hardware register, where one typically set/unset/read individual bits. Here we just have a trivial bit manipulation - not creeative, not copyrightable. diff --git a/strings/29F78D00DD60 b/strings/29F78D00DD60 new file mode 100644 index 00000000..bada463b --- /dev/null +++ b/strings/29F78D00DD60 @@ -0,0 +1,5 @@ +(beginning of the routine not matching) + AND #$F7 + STA $DD00 + RTS + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/386020 b/strings/386020 new file mode 100644 index 00000000..3693f9aa --- /dev/null +++ b/strings/386020 @@ -0,0 +1,3 @@ +SEC + RTS (end of subroutine, new one starts from the next byte) + JSR (address not matching) + +One subroutine ends with carry clear, second starts with JSR, but to a different address - accidental similarity, code most likely performs something different in both cases. diff --git a/strings/3ED0034C37 b/strings/3ED0034C37 new file mode 100644 index 00000000..3850ac4b --- /dev/null +++ b/strings/3ED0034C37 @@ -0,0 +1,3 @@ +$3E + BNE addr + JMP $xx37 + +Some part + BNE / JMP combo (typical construction on a 6502, where there is no conditional far jump), even the address does not fully match. Not copyrightable. diff --git a/strings/4CBDFFA9 b/strings/4CBDFFA9 new file mode 100644 index 00000000..4caa0103 --- /dev/null +++ b/strings/4CBDFFA9 @@ -0,0 +1,3 @@ +JMP $FFBD (SETNAM) + LDA #$ (value does not match) + +Instruction (jump to an official, documented location) + opcode of another one. Not copyrightable. diff --git a/strings/4F5045 b/strings/4F5045 new file mode 100644 index 00000000..b7ca79b9 --- /dev/null +++ b/strings/4F5045 @@ -0,0 +1,3 @@ +ORE - PETSCII string + +Not copyrightable. diff --git a/strings/524F4D b/strings/524F4D new file mode 100644 index 00000000..b4fe5d3c --- /dev/null +++ b/strings/524F4D @@ -0,0 +1,3 @@ +ROM - PETSCII string + +Not copyrightable. diff --git a/strings/564552 b/strings/564552 new file mode 100644 index 00000000..fd01de08 --- /dev/null +++ b/strings/564552 @@ -0,0 +1,3 @@ +VER - PETSCII string + +Not copyrightable. diff --git a/strings/5645524946 b/strings/5645524946 new file mode 100644 index 00000000..c9039b3d --- /dev/null +++ b/strings/5645524946 @@ -0,0 +1,3 @@ +VERIF - PETSCII string, part of 'VERIFY' + +Not copyrightable. diff --git a/strings/5902D0F8 b/strings/5902D0F8 new file mode 100644 index 00000000..8b870d15 --- /dev/null +++ b/strings/5902D0F8 @@ -0,0 +1,3 @@ +$0259 (LAT table address) + BNE $F8 (few bytes back) + +Instruction + some parts (revealing that this is some manipulation on documented Kernal table). Not copyrightable. diff --git a/strings/6020A0E5A900 b/strings/6020A0E5A900 new file mode 100644 index 00000000..e69de29b diff --git a/strings/6031EA b/strings/6031EA new file mode 100644 index 00000000..e3398d10 --- /dev/null +++ b/strings/6031EA @@ -0,0 +1,3 @@ +RTS (ending a subroutine, new one starts) + conditional jump + +Nothing creative here - not copyrightable. diff --git a/strings/60A59D10 b/strings/60A59D10 new file mode 100644 index 00000000..bcc0416b --- /dev/null +++ b/strings/60A59D10 @@ -0,0 +1,3 @@ +RTS (belonging to previopus subroutine) + LDA $9D (MSGFLG) + BPL + +The only similarity here is, that the subroutine starts by checking a documented variable. Not copyrightable. diff --git a/strings/60A59D10FB b/strings/60A59D10FB new file mode 100644 index 00000000..3dc7afb7 --- /dev/null +++ b/strings/60A59D10FB @@ -0,0 +1,3 @@ +RTS + LDA $9D (MSGFLG) + BPL $FB + +Check documented variable value, utilize nearest RTS (a very common optimization, mentionedd for example here just few days ago: https://gitlab.com/mkslack/Area6510/commit/9bdc624574c76661db302cdbf85559fb0e9e309a) to quit subroutine if the highest bit is not 1 (the easiest way to distinguish 2 documented values of the MSGFLG: $00 and $80). Nothing creative here - not copyrightable. diff --git a/strings/60AD00DD0910 b/strings/60AD00DD0910 new file mode 100644 index 00000000..465ca2c5 --- /dev/null +++ b/strings/60AD00DD0910 @@ -0,0 +1,5 @@ +RTS (end of the routine, new one starting) + LDA $DD00 + ORA #$10 + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/60AD00DD09108D00DD b/strings/60AD00DD09108D00DD new file mode 100644 index 00000000..d2e3ec90 --- /dev/null +++ b/strings/60AD00DD09108D00DD @@ -0,0 +1,5 @@ +RTS (end of the routine, new one starting) + LDA $DD00 + ORA #$10 + STA $DD00 + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/630285 b/strings/630285 new file mode 100644 index 00000000..1eeb6590 --- /dev/null +++ b/strings/630285 @@ -0,0 +1,3 @@ +address $0263 + STA (address does not match) + +Not even a full instruction. Not copyrightable. diff --git a/strings/686020 b/strings/686020 new file mode 100644 index 00000000..a2a6d383 --- /dev/null +++ b/strings/686020 @@ -0,0 +1,3 @@ +PLA + RTS (end of subroutine, another one starting) + JSR (address does not match) + +End of a routine preserving .A register + part of instruction belonging to another subroutine. Not copyrightable. diff --git a/strings/6C1A036C b/strings/6C1A036C new file mode 100644 index 00000000..b2044ce0 --- /dev/null +++ b/strings/6C1A036C @@ -0,0 +1,3 @@ +JMP ($031A) (via public, documented vector) + JMP (address does not match) + +Code similarity due to Kernal API usage convention. Since 6510 CPU does not have indirect JSR, the only sane possibility to use Kernal API vectors in RAM ($0314-$0333) is to have JMP ($address) hardcoded somewhere. The jump table has intentionally strange order (to avoid code similarity as much as possible), but some small similarities can't be avoided in any reasonable way. diff --git a/strings/7AD0034C b/strings/7AD0034C new file mode 100644 index 00000000..48d269ae --- /dev/null +++ b/strings/7AD0034C @@ -0,0 +1,3 @@ +$7A + BNE with matching address + JMP + +Single instruction + some matching parts of two others. Not copyrightable. diff --git a/strings/9914038810 b/strings/9914038810 new file mode 100644 index 00000000..83b907e4 --- /dev/null +++ b/strings/9914038810 @@ -0,0 +1,3 @@ +STA $0314, Y + DEY + BPL addr + +Part of memory copy routine to set/initialize vector table in RAM (a documented one). There is a limited amount of sane ways to implement this code - ours is clearly different from the original, or there would be more similarities. Such a small fragment of rather common routine is definitely not copyrightable. diff --git a/strings/A000B17AD0 b/strings/A000B17AD0 new file mode 100644 index 00000000..bece149c --- /dev/null +++ b/strings/A000B17AD0 @@ -0,0 +1,3 @@ +LDY #$00 + LDA ($7A), Y + BNE (offset does not match) + +Small part of a loop processing data pointed by TEXTPTR - not creative, not copyrightable. diff --git a/strings/A59AC903 b/strings/A59AC903 new file mode 100644 index 00000000..09302357 --- /dev/null +++ b/strings/A59AC903 @@ -0,0 +1,3 @@ +LDA $9A (DFLTO) + CMP #$03 + +Check whether the default output device is screen - not even fully matching the original ROM (different branch instruction used) - might be one onstruction on other architecture. Not copyrightable. diff --git a/strings/A5BAC902D0 b/strings/A5BAC902D0 new file mode 100644 index 00000000..95880faa --- /dev/null +++ b/strings/A5BAC902D0 @@ -0,0 +1,3 @@ +LDA $BA + CMP #$02 + BNE (offset does not match) + +Check whether the current device number is 2 (RS-232). Not creative - not copyrightablee. diff --git a/strings/A67AA47B b/strings/A67AA47B new file mode 100644 index 00000000..4c546a62 --- /dev/null +++ b/strings/A67AA47B @@ -0,0 +1,5 @@ +LDX $7A + LDY $7B + +Loading TXTPTR value to X/Y registers, would be 1 instruction on any 16-bit CPU. Not creative - not copyrightable. + + diff --git a/strings/A90020BDFF b/strings/A90020BDFF new file mode 100644 index 00000000..3d2e939f --- /dev/null +++ b/strings/A90020BDFF @@ -0,0 +1,4 @@ +LDA #$00 + JSR $FFBD (SETNAM routine) + +Code to set the file name as empty ($FFBD is a standard, documented address). Trivial - not copyrightable. + diff --git a/strings/A90020BDFF20 b/strings/A90020BDFF20 new file mode 100644 index 00000000..52da1afa --- /dev/null +++ b/strings/A90020BDFF20 @@ -0,0 +1,3 @@ +LDA #$00 + JSR $FFBD (SETNAM routine) + JSR (address differs) + +Code to set the file name as empty ($FFBD is a standard, documented address), followed by jump to subroutine (but placed elsewere). Trivial - not copyrightable. diff --git a/strings/A9009900 b/strings/A9009900 new file mode 100644 index 00000000..3801d04d --- /dev/null +++ b/strings/A9009900 @@ -0,0 +1,3 @@ +LDA #$00 + STA xx00, Y + +Instruction and a half (probably a loop zeroing something - but something different in both cases). Not copyrightable. diff --git a/strings/B190034C b/strings/B190034C new file mode 100644 index 00000000..b4bf4caa --- /dev/null +++ b/strings/B190034C @@ -0,0 +1,3 @@ +LDA ($0390), Y + JMP (address does not match) + +Instruction and a half - not copyrightable. diff --git a/strings/B1B0034C b/strings/B1B0034C new file mode 100644 index 00000000..4df42d32 --- /dev/null +++ b/strings/B1B0034C @@ -0,0 +1,3 @@ +LDA ($03B0), Y + JMP (address does not match) + +Instruction and a half - not copyrightable. diff --git a/strings/BAA90085 b/strings/BAA90085 new file mode 100644 index 00000000..007ab7ac --- /dev/null +++ b/strings/BAA90085 @@ -0,0 +1,3 @@ +$BA + LDA #$00 + STA (address does not match) + +One full instruction (loading acumulator with 0) and some parts - not copyrightable. diff --git a/strings/C8B17AF0 b/strings/C8B17AF0 new file mode 100644 index 00000000..f39a32bf --- /dev/null +++ b/strings/C8B17AF0 @@ -0,0 +1,3 @@ +INY + LDA ($7A),Y + BEQ (offset does not match) + +Small part of a loop processing data pointed by TEXTPTR - not creative, not copyrightable. diff --git a/strings/C8C4B7 b/strings/C8C4B7 new file mode 100644 index 00000000..c18389c8 --- /dev/null +++ b/strings/C8C4B7 @@ -0,0 +1,3 @@ +INY + CPY $B7 (FNLEN documented variable) + +Tiny part of the loop processing file name or IEC command. Not creative - not copyrightable. diff --git a/strings/D0034C37 b/strings/D0034C37 new file mode 100644 index 00000000..6fe14834 --- /dev/null +++ b/strings/D0034C37 @@ -0,0 +1,3 @@ +BNE $03 + JMP xx37 + +Instruction and a half - part of a common workaround for conditional jumps not reaching far. Not copyrightable. diff --git a/strings/DD09108D00DD b/strings/DD09108D00DD new file mode 100644 index 00000000..f263c197 --- /dev/null +++ b/strings/DD09108D00DD @@ -0,0 +1,5 @@ +$DD + ORA #$10 + STA $DD00 + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/DD29DF8D00DD60AD00DD b/strings/DD29DF8D00DD60AD00DD new file mode 100644 index 00000000..9979799f --- /dev/null +++ b/strings/DD29DF8D00DD60AD00DD @@ -0,0 +1,5 @@ +$DD + AND #$DF + STA $DD00 + RTS (end of the routine, new one starting) + LDA $DD00 + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/DD29DF8D00DD60AD00DD09208D00DD b/strings/DD29DF8D00DD60AD00DD09208D00DD new file mode 100644 index 00000000..fc3ddb19 --- /dev/null +++ b/strings/DD29DF8D00DD60AD00DD09208D00DD @@ -0,0 +1,5 @@ +$DD + AND #$DF + STA $DD00 + RTS (end of the routine, new one starting) + LDA $DD00 + ORA #$20 + STA $DD00 + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/DD29EF8D00DD b/strings/DD29EF8D00DD new file mode 100644 index 00000000..6fcdcaaa --- /dev/null +++ b/strings/DD29EF8D00DD @@ -0,0 +1,5 @@ +$DD + AND #$EF + STA $DD00 + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/DD29EF8D00DD60 b/strings/DD29EF8D00DD60 new file mode 100644 index 00000000..4ad51171 --- /dev/null +++ b/strings/DD29EF8D00DD60 @@ -0,0 +1,5 @@ +$DD + AND #$EF + STA $DD00 + RTS + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/DD29EF8D00DD60AD00DD09 b/strings/DD29EF8D00DD60AD00DD09 new file mode 100644 index 00000000..903213d1 --- /dev/null +++ b/strings/DD29EF8D00DD60AD00DD09 @@ -0,0 +1,5 @@ +$DD + AND #$EF + STA $DD00 + RTS + LDA #$DD00 + ORA # (argument does not match) + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/DD29F78D00DD60 b/strings/DD29F78D00DD60 new file mode 100644 index 00000000..20b06c7a --- /dev/null +++ b/strings/DD29F78D00DD60 @@ -0,0 +1,5 @@ +$DD + AND #$F7 + STA $DD00 + RTS + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/DD60AD00DD09208D00DD b/strings/DD60AD00DD09208D00DD new file mode 100644 index 00000000..f885c7da --- /dev/null +++ b/strings/DD60AD00DD09208D00DD @@ -0,0 +1,5 @@ +$DD + RTS (end of the routine, new one starting) + LDA $DD00 + ORA #$20 + STA $DD00 + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/DF8D00DD b/strings/DF8D00DD new file mode 100644 index 00000000..a3426d59 --- /dev/null +++ b/strings/DF8D00DD @@ -0,0 +1,3 @@ +$EF + STA $DD00 + +Instruction (storing acumulator in a documented I/O register) and some part. Not copyrightable. diff --git a/strings/DF8D00DD60AD00DD b/strings/DF8D00DD60AD00DD new file mode 100644 index 00000000..63207a43 --- /dev/null +++ b/strings/DF8D00DD60AD00DD @@ -0,0 +1,5 @@ +$DF + STA $DD00 + RTS + LDA $DD00 + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/E5C91DD0 b/strings/E5C91DD0 new file mode 100644 index 00000000..18aee6b1 --- /dev/null +++ b/strings/E5C91DD0 @@ -0,0 +1,3 @@ +$E5 + CMP #$1D + BNE (offset does not match) + +Instruction + some parts. Not copyrightable. diff --git a/strings/EF8D00DD60AD00DD09 b/strings/EF8D00DD60AD00DD09 new file mode 100644 index 00000000..d8780b0e --- /dev/null +++ b/strings/EF8D00DD60AD00DD09 @@ -0,0 +1,5 @@ +$EF + STA $DD00 + RTS + LDA $DD00 + ORA # (value does not match) + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions. diff --git a/strings/F6A90085 b/strings/F6A90085 new file mode 100644 index 00000000..815dc515 --- /dev/null +++ b/strings/F6A90085 @@ -0,0 +1,3 @@ +$F6 + LDA #$00 + STA ... + +A part + instruction to clear the accumulator + opcode of another instruction. Not copyrightable. diff --git a/strings/F78D00DD60 b/strings/F78D00DD60 new file mode 100644 index 00000000..f7b83ec1 --- /dev/null +++ b/strings/F78D00DD60 @@ -0,0 +1,5 @@ +$F7 + STA $DD00 + RTS + +$DD00 is a hardware register, where one typically set/unset/read individual bits. +Having a set of trivial helper subroutines to set/clear individual bits (or groups of bits) is an obvious solution (thus not copyrightable), some similarities are unevitable. +Besides, in this case (since the similarity does not even cover a single subroutine from start to end) it is clear that the similar code actually performs slightly different actions.