Q:

Read in memory and inc (6502)

Sorry if the question seems to be 'too basic'.  I'm a 68K ASM coder but one friend ask me for a glance at a piece of 6502 code. 
We have a pointer to a string of data:
 my_ptr ds 2

This pointer is set with this code:
ldx sound_channel_busy
bne .abc_set_score1   ; at bottom of code
sta my_ptr   ; fill the pointer

Reading data is done with
lda (my_ptr),y    ; my_ptr + offset

But as I see in the 6502 doc, y is one byte.  So with that, it's not possible to use a data string of more than 255 bytes which is not enought (we want to read strings of 10.000 bytes or more. 
I suggest my friend to do that:
1) Set one pointer as "base" and a temporary one which we'll inc while reading
 my_ptr ds 2
 my_ptr_tmp ds 2

2) Init them with:
ldx sound_channel_busy
bne .abc_set_score1
sta my_ptr
sta my_ptr_tmp  ; Duplicate

3) Then read using:
  lda (my_ptr_tmp)   ; Read to acumulator
  inc my_ptr_tmp     ; One more on adress pointer

But it don't work and as my friend is a C dev, and we don't have debugger... not easy. 
In 68K this seems to be logical but in 6502? 
Thanks a lot for your help

A:

6502 is quite limited. 

All reads and writes to memory are 8 bit
All arithmetic is 8 bit
There are only two indirect modes: (zp),y and (zp,x) wherer zp is a zero page address.  The former calculates the address as 
contentOf(zp + (zp + 1) << 8) + y

and uses the byte at it as the operand.  The latter calculates the address as
contentOf( zp + x + (zp + x + 1) << 8)

The y form is used for accessing elements of arrays pointed to by the zero page pointer and the x form is used for accessing vector tables in zero page memory. 
To set up the pointer:
    lda #<pointer ; The low byte of the 16 bit address pointer is loaded into A
    sta my_ptr
    lda #>pointer ; the high byte of the pointer
    sta my_ptr+1
    ldy #0        ; zero the y register

To access the pointer
loopStart:
    lda (my_ptr),y

Assuming a C style string with a null terminator
    beq loopExit  ; previous LDA sets the S and Z flags. 

To increment the pointer
    iny           ; Increment y
    bne loopStart
    inc my_ptr+1
    jmp loopStart

You could also do it keeping Y as 0 and incrementing the low byte and the two zero page locations, but INC my_ptr is much slower than INY taking five cycles instead of two. 
Edit
If, instead of a null terminated string, you have a length, you'll need to modify this slightly.  One way is to count how many bytes you have done and compare with the length.  With the algorithm above, Y is the count, if the length < 256, so what we can do is store the high byte of the count in 
; first set up my_ptr, same as before. 
; 
    lda #<pointer ; The low byte of the 16 bit address pointer is loaded into A
    sta my_ptr
    lda #>pointer ; the high byte of the pointer
    sta my_ptr+1
;
;   Set up the counter
;
    ldx #0        ; set up x for the count
    ldy #0        ; Set up y for the count/loop
;
;   A common trick with compiling while loops is to put the test at the end of the loop and jump to it immediately.  
;  This means you don't have to reverse the logic of the loop condition. 
;
    jmp loopTest  ; Omit this if you definitely need to go round the loop at least once
loopStart:
    lda (my_ptr),y    ; Get the byte
;
;   Do what you need to do here
;
;   Increment the counter
;
    iny           ; Increment y
    bne loopTest
    inx
    inc my_ptr+1
loopTest:
    cpy length    ; Compare the low byte of length to the count
    bne loopStart
    cpx length+1  ; Compare the high byte of length to the count
    bne loopStart

