So are these all different appvars? If they are, why don't you throw them all into one big appvar?

Ok, I'm glad it was all in one appvar because that makes it way easier.


;##########################################
;search for a user
;input: de = ptr to start of appvar data, (including size bytes)
; hl = ptr to username
;ouput: de = ptr to start of user section
; carry set if not found

searchForUser:
ld a, 8
ld bc, 5

jr realSearch




;##########################################
;search for a coordinate
;input: de = ptr to start of appvar data, (including size bytes)
; hl = ptr to coordinate
;output: de = ptr to start of user section
; carry set if not found

searchForCoordinate:
ld a, 12
ld bc, 13
jr realSearch


;##########################################
;search for an ID
;input: de = ptr to start of appvar data, (including size bytes)
; hl = ptr to coordinate
;ouput: de = ptr to start of user section
; carry set if not found

searchForAnId:
ld a, 5
ld bc, 0


; jr realSearch
; fall through

;#######
realSearch:
push bc
push hl
ex de, hl
ld e, (hl)
inc hl
ld d, (hl)
inc hl
add hl, bc
push hl
ex de, hl
push af
ld a, 25
bcall(_divHLbyA)
pop bc
ld c, l
pop hl
pop de


actualFindLoop:
push bc
push de
push hl
checkMatchLoop:
ld a, (de)
cp (hl)
jr nz, isntMatch

inc hl
inc de
djnz checkMatchLoop

pop hl
pop af
pop af
pop de
or a
sbc hl, de
ex de, hl
ret


isntMatch:
pop hl
ld de, 25
add hl, de
pop de
pop bc
dec c
jr nz, actualFindLoop
pop af
scf
ret

These routines are pretty simple. Just give it the DE that bcall(_chkFindSym) gives you and it will search the appvar for the data you give it. If it runs out of entries, it will return with carry set. Make sure that you don't have an appvar with more than 255 entries though, or else it won't look very far. I tried to make them as small as possible and a few times I was tempted to use the shadow registers, but I didn't.

I also have no idea what you wanted for your third routine. I just made one that searches for a specific ID, you can add whatever you want to the output it gives.

And if you need to search for other stuff, my realSearch: function should work quite nicely.

I'm not sure what areas CALCnet uses, so I couldn't really tell you. There's nothing wrong moving it to static memory though. The only problem is that you might have to modify that routine a little because it relies on the two size bytes being out front.

Oh, yes. I forgot to change it when I was retyping it. But at least you understand it enough to realize that it was wrong

The header for real search would be:
;############################################
;input: a = field length
; bc = field offset from start of data
; de = start of appvar
; hl = ptr to field to match

So you can call it if you want. There are two ret's out of realSearch, the first one is the good one, where DE = the start of the data section, and the second is just an error ret.

Yes, bcall(_delMem) exists. I believe you should download this. I pull it out about every 1 out of 4 programming sessions.

And two byte subtract? sbc hl, rr. Where rr is bc or de. Just remember though that since this is sbc and not sub, you will have to make sure the carry flag is not set. So typically, you will see it used like this.
or a
sbc hl, de


As I said earlier on IRC, yes there is.

You can find a list of all BCalls here.

That list doesn't include ones not officially listed in ti83plus.inc. Check out BrandonW's list it has every one listed, and most of them named. (Unnamed ones are unknown as of now, so they wouldn't be useful anyways.)

And between TI's list (linked above) and WikiTi you can figure out the inputs for most of the useful bcalls.