Seed parameter in the new _INSTRREV() statement.

[SMcNeill]

Start moves from left to right, so let's look at an example:

"alphabet"

PRINT _INSTR(3,"alphabet","a")

start in this case is 3.  So basically think of it as:

PRINT _INSTR(LEFT$("alphabet",3), "a").

We'd start at the first letter ("a") and then count to the third letter ("p"), and then see where "a" appears in the "alp" which we're using.


So, to answer your question: start moves from left to right, though we search from right to left.

[codeguy]

another tactic is string reversal, which lends itself quite nicely to the standard use of INSTR().

Code: QB64: [Select]

1. my$ = "tom jane fred lois dog cat mouse tom jerry mouse"
2.  
3. t& = LEN(my$)
4. DO
5.     t& = InStringReverse&(t&, my$, "tom")
6.     PRINT t&
7.     IF t& > 0 THEN
8.         t& = t& - LEN("tom")
9.     ELSE
10.         EXIT DO
11.     END IF
12. LOOP WHILE t& > 0
13.  
14. d$ = StringReverse$(my$, 1, LEN(my$))
15. r$ = StringReverse$("tom", 1, LEN("tom"))
16. s& = 1
17. WHILE INSTR(s&, d$, r$) > 0
18.     i& = INSTR(s&, d$, r$)
19.     PRINT i&; LEN(d$) - i& - 1
20.     s& = i& + LEN(r$)
21. WEND
22.  
23. FUNCTION InStringReverse& (start&, x$, f$)
24.     ps& = start& - LEN(f$) + 1
25.     DO
26.         IF ps& > 0 THEN
27.             IF MID$(x$, ps&, LEN(f$)) = f$ THEN
28.                 EXIT DO
29.             ELSE
30.                 ps& = ps& - 1
31.             END IF
32.         ELSE
33.             EXIT DO
34.         END IF
35.     LOOP
36.     InStringReverse& = ps&
37. END FUNCTION
38.  
39. FUNCTION StringReverse$ (b$, start&, finish&)
40.     x$ = b$
41.     a& = start&
42.     b& = finish&
43.     DO WHILE a& < b&
44.         asca% = ASC(x$, a&)
45.         ascb% = ASC(x$, b&)
46.         IF asca% <> ascb% THEN
47.             ASC(x$, a&) = ascb%
48.             ASC(x$, b&) = asca%
49.         END IF
50.         a& = a& + 1
51.         b& = b& - 1
52.     LOOP
53.     StringReverse$ = x$
54.     x$ = ""
55. END FUNCTION
56.  

[Pete]

Well figuring out how to "adjust my expectations" on this one is difficult. I think it could follow in the lines of QB INSTR() and be a much better keyword. All it needs is that annoying repeating loop eliminated. INSTR() doesn't loop, period. The reverse shouldn't either. As for not being a mirror in regard to the seeding, I have worked all that out. I'm fine with the seed parameter left to right, just like INSTR(), but that repeating crap bears repeating... it's crap!

Anyway, here is what I had to work with to consider how I may or may not want to use this new keyword, along with an alternative function I put together, to do the same as reverse instr(). Notice the difference in the way the standard INSTR() escapes vs what is I needed to add to get _instrrev() to escape properly. If there is a simpler way. I'm all ears, but this it what I came up with for now...

Code: QB64: [Select]

1. ''strng$ = ",dog,bill,cat,dog,dogfood,pete,steve,bill,cat,dog,dogfood,pete,steve,bill,cat,dog,dogfood,pete,steve,dog,"
2. ''srch$ = ",dog,"
3. strng$ = "1234"
4. LINE INPUT "Search: "; srch$
5. PRINT "INSTR - Forward!"
6. DO
7.     seed& = INSTR(seed&, strng$, srch$)
8.     IF seed& = 0 THEN EXIT DO
9.     x$ = MID$(strng$, seed&, LEN(srch$))
10.     PRINT x$, seed&
11.     seed& = seed& + LEN(srch$)
12. LOOP
13. PRINT "_INSTRREV - Reverse!"
14. DO
15.     seed& = _INSTRREV(seed&, strng$, srch$)
16.     ' 0 needed for if search term is start of string.
17.     IF seed& = 0 THEN PRINT "Exits because seed& = 0"
18.     IF srch$ = "" THEN PRINT "Exits because srch$ = " + CHR$(34) + CHR$(34)
19.     IF lastseed& - LEN(srch$) <= 0 AND lastseed& <> 0 THEN PRINT "Exits because lastseed& - LEN(srch$) <= 0 AND lastseed& <> 0", lastseed& - LEN(srch$)
20.     IF seed& = 0 OR srch$ = "" OR lastseed& - LEN(srch$) <= 0 AND lastseed& <> 0 THEN EXIT DO
21.     x$ = MID$(strng$, seed&, LEN(srch$))
22.     PRINT x$, seed&
23.     lastseed& = seed& ' Needed to escape looping if string begins with search term.
24.     seed& = seed& - LEN(srch$)
25. LOOP
26. PRINT "Pete's instrrev function with SMART escape...": seed& = 0
27. DO
28.     seed& = instrrev&(seed&, strng$, srch$)
29.     IF seed& <= 0 THEN EXIT DO
30.     x$ = MID$(strng$, seed&, LEN(srch$))
31.     PRINT x$, seed&
32.     seed& = LEN(strng$) - seed& + LEN(srch$)
33. LOOP
34. SLEEP ''
35. RUN
36. FUNCTION instrrev& (seed&, strng$, srch$)
37. FOR instrrev& = LEN(strng$) - seed& TO 1 STEP -1
38.     IF MID$(strng$, instrrev&, LEN(srch$)) = srch$ THEN EXIT FOR
39. NEXT
40. IF srch$ = "" THEN instrrev& = 0
41. END FUNCTION
42.  

The double "" can be removed, so the larger string can be tested with the search term: ",dog,"

If anyone can think of a search that would invalidate any of the three methods coded above, let me know.

Pete

[FellippeHeitor]

http://qb64.org/wiki/INSTRREV

Example 2: Searching for multiple instances of a substring inside a base string, going from the end to the start.

Code: QB64: [Select]

1. sentence$ = " This is a string full of spaces, including at start and end... "
2. PRINT sentence$
3. DO
4.     findPrevSpace% = _INSTRREV(findPrevSpace% - 1, sentence$, SPACE$(1))
5.     IF findPrevSpace% = 0 THEN LOCATE 4, 1: PRINT "No more spaces": EXIT DO
6.  
7.     LOCATE 2, findPrevSpace%
8.     PRINT "^"
9.     totalSpaces = totalSpaces + 1
10.  
11.     IF findPrevSpace% = 1 THEN LOCATE 4, 1: PRINT "Last space found at position 1": EXIT DO
12. LOOP
13. PRINT "Total spaces found: "; totalSpaces

[codeguy]

This method allows use of standard INSTR(). this is the second demo in the above code pared to only what is necessary.

Code: QB64: [Select]

1. my$ = "tom jane fred lois dog cat mouse tom jerry mouse"
2. d$ = StringReverse$(my$, 1, LEN(my$))
3. r$ = StringReverse$("tom", 1, LEN("tom"))
4. s& = 1
5. WHILE INSTR(s&, d$, r$) > 0
6.     i& = INSTR(s&, d$, r$)
7.     PRINT i&; LEN(d$) - i& - 1
8.     s& = i& + LEN(r$)
9. WEND
10.  
11. FUNCTION StringReverse$ (b$, start&, finish&)
12.     x$ = b$
13.     a& = start&
14.     b& = finish&
15.     DO WHILE a& < b&
16.         asca% = ASC(x$, a&)
17.         ascb% = ASC(x$, b&)
18.         IF asca% <> ascb% THEN
19.             ASC(x$, a&) = ascb%
20.             ASC(x$, b&) = asca%
21.         END IF
22.         a& = a& + 1
23.         b& = b& - 1
24.     LOOP
25.     StringReverse$ = x$
26.     x$ = ""
27. END FUNCTION
28.  

[Pete]

I tried the double escape method, which Fell posted, some time ago, but I really wanted to get a single escape line. It works, but unfortunately it is complicated and therefore a bit difficult to remember. With 2 EXIT DO statements. I'd have to end up with something like this...

Code: QB64: [Select]

1. ' Example with two EXIT DO statements
2. strng$ = "1234"
3. LINE INPUT "Search: "; srch$
4. PRINT "_INSTRREV - Reverse!"
5. DO
6.     seed& = _INSTRREV(seed&, strng$, srch$)
7.     ' 0 needed for if search term is start of string.
8.     IF seed& = 0 THEN PRINT "Exits because seed& = 0"
9.     IF srch$ = "" THEN PRINT "Exits because srch$ = " + CHR$(34) + CHR$(34)
10.     IF seed& = 1 THEN PRINT "Exits after printing because seed& = 1"
11.     IF seed& = 0 OR srch$ = "" THEN EXIT DO
12.     x$ = MID$(strng$, seed&, LEN(srch$))
13.     PRINT x$, seed&
14.     IF seed& = 1 THEN EXIT DO
15.     seed& = seed& - LEN(srch$)
16. LOOP
17. RUN

Vs this...

Code: QB64: [Select]

1. ' Example with one EXIT DO statements
2. strng$ = "1234"
3. LINE INPUT "Search: "; srch$
4. PRINT "_INSTRREV - Reverse!"
5. DO
6.     seed& = _INSTRREV(seed&, strng$, srch$)
7.     ' 0 needed for if search term is start of string.
8.     IF seed& = 0 THEN PRINT "Exits because seed& = 0"
9.     IF srch$ = "" THEN PRINT "Exits because srch$ = " + CHR$(34) + CHR$(34)
10.     IF lastseed& - LEN(srch$) <= 0 AND lastseed& <> 0 THEN PRINT "Exits because lastseed& - LEN(srch$) <= 0 AND lastseed& <> 0", lastseed& - LEN(srch$)
11.     IF seed& = 0 OR srch$ = "" OR lastseed& - LEN(srch$) <= 0 AND lastseed& <> 0 THEN EXIT DO
12.     x$ = MID$(strng$, seed&, LEN(srch$))
13.     PRINT x$, seed&
14.     lastseed& = seed& ' Needed to escape looping if string begins with search term.
15.     seed& = seed& - LEN(srch$)
16. LOOP
17. RUN
18.  

So same number of lines, but one vs two exit do statements. I still lobby for make _INSTRREV() work more like my function, below...

Code: QB64: [Select]

1. strng$ = "1234"
2. LINE INPUT "Search: "; srch$
3. PRINT "Pete's instrrev function with SMART escape...": seed& = 0
4. DO
5.     seed& = instrrev&(seed&, strng$, srch$)
6.     IF seed& <= 0 THEN EXIT DO
7.     x$ = MID$(strng$, seed&, LEN(srch$))
8.     PRINT "Found: "; x$; " at position:"; seed&
9.     seed& = LEN(strng$) - seed& + LEN(srch$)
10. LOOP
11. RUN
12.  
13. FUNCTION instrrev& (seed&, strng$, srch$)
14. FOR instrrev& = LEN(strng$) - seed& TO 1 STEP -1
15.     IF MID$(strng$, instrrev&, LEN(srch$)) = srch$ THEN EXIT FOR
16. NEXT
17. IF srch$ = "" THEN instrrev& = 0
18. END FUNCTION
19.  

Pete

[codeguy]

I personally believe the original purpose was strictly as a coding challenge on a tutoring site. There are so many approaches that agreeing on one is probably going to be difficult if not impossible. I like the string reverse/INSTR() method because it allows using INSTR() entirely unchanged and doesn't require the same exit logic as _INSTRREV(). This can be done without the reversal too, although I haven't yet coded that one. It has something to do with LEN(Some$) - PositionScan& + !. Please pardon my French as my Win XP SP3 virtual machine does exactly as I type :).

[FellippeHeitor]

As much as I respect you, Pete, I'll tell you what I've told Steve all day: We have JUST released a new version of QB64 with a feature that's been added 10 months back, overtly talked about in this forum. This not the time to lobby for a change.

The way _INSTRREV works is the way it was designed to work 10 months back. Back then all sorts of discussion and concession would have been easier.

Right now what we have is a stable release being advertised everywhere I can and which works as indicated in the wiki, link in my previous post.

Code: QB64: [Select]

1. I still lobby for make _INSTRREV() work more like my function

Adjusting your expectations here means accepting that a function that *didn't exist before* now exists and works as it's been explained. And you now have written yourself a nice function for your own use that does exactly what you expect it to. Just like codeguy has been doing for a while now too in this thread.

People will read the wiki and learn how the new feature works. And they'll either use it or not. We have features galore and not everyone uses all of them.

Can we please celebrate a new release and cut back on the clippiness?

[SMcNeill]

If there is a simpler way. I'm all ears, but this it what I came up with for now...

Here's you a nice and simple way to fix things, Pete:

Code: QB64: [Select]

1. $CONSOLE:ONLY
2. 'we use console so we can see the output of any shell which is going on.
3. _TITLE "_INSTR Fix Runtime"
4. _DEST _CONSOLE
5.  
6. CHDIR "internal\c\"
7.  
8. OPEN "libqb.cpp" FOR INPUT AS #1
9. OPEN "libqb.tmp" FOR OUTPUT AS #2
10. DO
11.     LINE INPUT #1, temp$
12.     IF INSTR(temp$, "int32 func__instrrev(int32 start,qbs *str,qbs *substr,int32 passed)") THEN SetFlag = -1
13.     IF SetFlag THEN 'we're down at the proper function to change
14.         IF INSTR(temp$, "if (start<1){") THEN 'we found the line to change.
15.             PRINT #2, "    if (start<0){"
16.             PRINT "Fix applied."
17.             SetFlag = 0
18.             SetFlag2 = -1
19.         ELSE
20.             PRINT #2, temp$
21.         END IF
22.         IF INSTR(temp$, "void sub_mid") THEN SetFlag = 0 'make certain we don't change anything else, in case the file was previously altered.
23.     ELSE
24.         PRINT #2, temp$
25.     END IF
26. LOOP UNTIL EOF(1)
27. CLOSE
28.  
29. IF SetFlag2 THEN
30.  
31.     KILL "libqb.cpp"
32.     NAME "libqb.tmp" AS "libqb.cpp"
33.  
34.     SHELL "purge_libqb_only.bat"
35. ELSE
36.     KILL "libqb.tmp" 'delete the duplicate we made of the file, as it's basically an exact copy of libqb.cpp.
37.     PRINT "Changes not made.  You may have already ran the patch, or else the QB64 source has been fixed itself."
38. END IF

Run that patch from QB64 and it'll correct the issue once and for all for you.  It makes the very simple, 1 line change, which is needed to have QB64 behave as you'd expect it to with _INSTRREV.  There's no need to make your own function, or jump through hoops to have it work properly -- just run that little patch routine. 

Once you do, all you have to do is run a very simple little set of code like the following and watch it work properly:

Code: QB64: [Select]

1. DO
2.     seed = _INSTRREV(seed - 1, "1111", "1")
3.     PRINT seed
4.     SLEEP
5. LOOP UNTIL seed = 0

The above will print out:
4
3
2
1
0

And then, quit.

No endless loop, as 0 is no longer a magic number to make it automatically start searching from the end of the string.  It works as you'd expect..

[FellippeHeitor]

Then run that on everyone else's computer. Or don't ever share code.

[SMcNeill]

Then run that on everyone else's computer. Or don't ever share code.

Why?  How many times have you had to use that one particular command with QB64, in the last 10 months?  Would the patch make it so you couldn't *ever* share code?

If Pete patches his version of QB64, and shares code which doesn't work for anyone else, all that's needed is for him to either say:

1) Download a fresh version of QB64.  Install it in a separate folder, and run the patch for yourself, and have it run as expected.

OR

2) You'll need to modify it so that it works as intended on your system.

We see messages based on principle 2 all the time -- like with my Wallpaper Changer.  Folks have to change the directory to wherever their photos/screenshots are stored, and it won't work on Linux/Mac machines at all.  As long as Pete realizes that any code he shares which makes use of the patched _INSTRREV may not work on everybody else's machine, that's all he needs to disclose when sharing code elsewhere for others. 

Folks who *do* use the patch can freely make use of the code he shares which uses the _INSTRREV.  Those who don't use the patch are simply like users who run a Linux system and you share code which uses a declared Windows library.  All they'd say is, "Doesn't work for me and my system."

[FellippeHeitor]

Of course, nothing to stop anyone.

It's an open source project after all. It's not even mine.

That also gets me thinking, why didn't you patch the repo yet? What's stopping you if everyone is for the change of the new command?

[SMcNeill]

Of course, nothing to stop anyone.

It's an open source project after all. It's not even mine.

That also gets me thinking, why didn't you patch the repo yet? What's stopping you if everyone is for the change of the new command?

Because there's nothing to stop you from reverting the changes back out.  You're 100% against the change as "it's too late to speak up and alter anything now", and I ran through hoops with Clippy undoing changes everything I corrected something in the wiki.  If you're convinced it's working as it should, then there's no reason for me to "introduce a bug" into it and make it work any differently than the documentation in the wiki and help files now.

Those who think it's broken can run the patch provided, much like they can run the autobackup and autoreplace scripts which I wrote to alter the behavior of QB64.  Those who like it as it is, or who don't think it's worth the bother, they can simply leave alone and not bother with any alterations.

Hopefully, after you run the patch and test it out for yourself, you'll see that it's how QB64 should behave, and then you'll be happy with the alteration, without feeling a need to undo them, or thinking that ithe patch makes it a broken command.

[FellippeHeitor]

Code: QB64: [Select]

1. that it's how QB64 should behave

Just precious.

[Raven_Singularity]

I have never used _INSTR() or INSTREV() before, but if this is an issue of consistency, I would highly recommend going for consistency in the functions, even if it means some current programs will break as a result.

After a decade of using PHP, I can say by far the worst part of it for me is the entirely inconsistent functions!  Some function names have the modifier at the end, some at the start.  Functions that are mirrors of each other have parameters in the opposite order, etc.  It's a giant ugly mess, and makes it far harder to learn the programming language than it needs to be.  If you have "foo_on()" you should have "foo_off()" not "disable_foo()".  Programmers in general have a focus to details and consistency, as is needed to be good at programming.  Functions that don't operate as expected, or are not named as expected, are a burden.  It takes you out of programming logic, instead forcing you to focus on remembering the inconsistencies.


The descriptions read:

The INSTR function searches for the first occurence of a search STRING within a base string and returns the position it was found.

position% = INSTR([start%,] baseString$, searchString$)

 -and-

The _INSTRREV function searches for a substring inside another string, but unlike INSTR it searches from right to left.

position% = _INSTRREV([start%,] baseString$, subString$)

These don't behave the same?

Because their descriptions say they do, and the function name with REV at the end indicates it is the same but reversed.