Sorry your browser is not supported!

rem TtlBreaks is the counter for the first arrays elements.
	for i=0 to TtlBreaks
	for t=0 to array count (removeWord$())
	if myarray$(i) = removeWord$(t)
	array delete element myarray$(i)
		endif
	next t
	next i

rem TtlBreaks is the counter for the first arrays elements.
	for i=0 to TtlBreaks
	for t=0 to array count (removeWord$())
	if myarray$(i) = removeWord$(t)
	array delete element myarray$(i),i
		endif
	next t
	next i

   DIM array1$(10)
   DIM array2$(10)
`Generate two arrays filled with randoms strings containing numeric values
   FOR i = 1 TO 10
         array1$(i) = STR$(RND(2))
         array2$(i) = STR$(RND(2))
   NEXT i
`Print header with array values
   CLS
   PRINT "============== Data In Arrays ========= Array Index ====="
   PRINT "Array1$()                 Array2$()"
   FOR i = 1 TO 10
         PRINT array1$(i) + "             -             " + array2$(i) + "              (" + STR$(i) + ")"
   NEXT i
`Set counter "count" to 0
   count = 0
`Begin FOR-llop check of array1$() against array2$()
   FOR i = 1 TO ARRAY COUNT (array1$())
         IF array1$(i) = array2$(i)
               INC count               `If there's a match, increase counter
               DIM list(count)         `DIM/REDIM list()
               list(count) = i         `Add index number that matched to list
         ENDIF
   NEXT i
`Print out the list of matches
   PRINT "============== List of Mtaches ==========================="
   FOR i = 1 TO ARRAY COUNT(list())
         PRINT "Array2$(" + STR$(list(i)) + ")"
   NEXT i
`Go through the list() array
   FOR i = 1 TO ARRAY COUNT(list())
      `Delete each element in listed in list() from array2$()
      `I subtract 1 each iteration because each time an element
      `from array2$() is deleted, the array shrinks, displacing all
      `remaining elements
      ARRAY DELETE ELEMENT array2$(0), list(i) - (i - 1)
   NEXT i
`Print out data in array2$() after removal
   PRINT "======== Data in Array2$() After Purge ==================="
   FOR i = 1 TO ARRAY COUNT(array2$())
         PRINT array2$(i) + "                   Array2$(" + STR$(i) + ")"
   NEXT i

   WAIT KEY

remstart
**************************************
this is my text parser
i have commented it as well as I can.
**************************************
remend
rem dim some arrays for word lists.

dim removeWord$(9)
removeWord$(0)="and"
removeWord$(1)="if"
removeWord$(2)="then"
removeWord$(3)="a"
removeWord$(4)="is"
removeword$(5)="the"
removeword$(6)="it"
removeword$(7)="its"
removeword$(8)="in"

rem set the screen up
set display mode 1024,800,32
set window on
maximize window

rem get some input
set cursor 10,c
input "type a command: ",input$
createArray(input$)
wait key
end
function createArray(input$)
	cls
	print "Thankyou, counting words..."
	print ""
	Counter=0
	TtlBreaks=0
	remstart
	count the spaces in the string then +1 the total
	to get the number of words the string contains
	remend
	REPEAT
	   INC Counter
	   IF Mid$(input$,Counter)=" "
       INC TtlBreaks
	   ENDIF
	UNTIL Counter=LEN(input$)
	inc TtlBreaks
	rem dimension an array with the number of words.
	dim myarray$(TtlBreaks)
	print "the string contains ";
	print TtlBreaks; " words"
	print 
	print "splitting the string into chunks and the seperate words to the array"
	print "then printing them from the array :)"
	rem add the words to the array
	b$=first token$(input$," ")
	Ttlbreaks=0
	repeat
		myarray$(TtlBreaks)=b$
		print myarray$(TtlBreaks)
        b$=next token$(" ")
        inc TtlBreaks
	until b$=""
	rem save the array and print the array contents to the screen
	save array "input.arr",myarray$(TtlBreaks)
	print "printing again from array"
	for i=0 to TtlBreaks
	print myarray$(i)
	next i
	rem delete the array to ensure it is loaded again correctly
	empty array myarray$()
	
	compareArray(TtlBreaks)
	
endfunction

function compareArray(TtlBreaks)
rem this function is supposed to load the array. 
	print "loading array...."
	rem redim the arrray
	dim myarray$(TtlBreaks)
	rem reload the array
	load array "input.arr",myarray$(TtlBreaks)
	print array count(myarray$())
	print "printing again from array"
	
	for i=0 to array count (myarray$())
	print myarray$(i)
	next i
	
	print "Comparing array now and removing words from the list"

	rem TtlBreaks is the counter for the first arrays elements.
	for i=0 to array count (myarray$())
	for t=0 to array count (removeWord$())
	print "checking "; myarray$(i); " and " ; removeWord$(t)
	if myarray$(i) = removeWord$(t)
	
	print "found a match?"
	print myarray$(i)
	print removeWord$(t)
	array delete element myarray$(i),i
	wait key
	t=0
	else
		endif
	next t
	next i
	
	print "printing the remainder of the array"
	for i=0 to array count (myarray$())
	print myarray$(i)
	next i
	print array count (myarray$())
endfunction

Begin FOR-llop check of array1$() against array2$()
   FOR i = 1 TO ARRAY COUNT (array1$())
         IF array1$(i) = array2$(i)
               INC count               `If there's a match, increase counter
               DIM list(count)         `DIM/REDIM list()
               list(count) = i         `Add index number that matched to list
         ENDIF
   NEXT i

FOR i = 1 TO ARRAY COUNT(list())
      `Delete each element in listed in list() from array2$()
      `I subtract 1 each iteration because each time an element
      `from array2$() is deleted, the array shrinks, displacing all
      `remaining elements
      ARRAY DELETE ELEMENT array2$(0), list(i) - (i - 1)
   NEXT i

remstart
**************************************
this is my text parser
i have commented it as well as I can.
It's not finished and deeds certain things making neater.
**************************************
remend
rem dim some arrays for word lists.

dim removeWord$(14)
removeWord$(0)="and"
removeWord$(1)="if"
removeWord$(2)="then"
removeWord$(3)="a"
removeWord$(4)="is"
removeword$(5)="the"
removeword$(6)="it"
removeword$(7)="its"
removeword$(8)="in"
removeWord$(9)="of"
removeWord$(10)="out"
removeWord$(11)="into"
removeWord$(12)="would"
removeWord$(13)="this"

dim movementHandler$(8)
movementHandler$(0)="north"
movementHandler$(1)="south"
movementHandler$(2)="east"
movementHandler$(3)="west"
movementHandler$(4)="up"
movementHandler$(5)="down"
movementHandler$(6)="hide"
movementHandler$(7)="unhide"

dim action$(17)
action$(0)="look"
action$(1)="examine"
action$(2)="take"
action$(3)="get"
action$(4)="grab"
action$(5)="drop"
action$(6)="dump"
action$(7)="use"
action$(8)="operate"
action$(9)="push"
action$(10)="press"
action$(11)="pull"
action$(12)="tug"
action$(13)="throw"
action$(14)="chuck"
action$(15)="sling"
action$(15)="toss"
action$(16)="move"

rem set the screen up
set display mode 1024,800,32
set window on
maximize window

rem get some input
set cursor 10,c
input "type a command: ",input$
createArray(input$)
wait key
end
function createArray(input$)
	cls
	
	rem remove punctuaion.
	rem this doesn't work correctly YET. it finds full stops in string but thats about it. :)
	for t=1 to len(input$)
	if mid$(input$,t)="."
	print "found a ."
	endif
		next t
		
	print "Thankyou, counting words..."
	print ""
	Counter=0
	TtlBreaks=0
	remstart
	count the spaces in the string then +1 the total
	to get the number of words the string contains
	remend
	REPEAT
	   INC Counter
	   IF Mid$(input$,Counter)=" "
       INC TtlBreaks
	   ENDIF
	UNTIL Counter=LEN(input$)
	inc TtlBreaks
	rem dimension an array with the number of words.
	dim myarray$(TtlBreaks)
	print "the string contains ";
	print TtlBreaks; " words"
	print 
	print "splitting the string into chunks and the seperate words to the array"
	
	rem add the words to the array
	b$=first token$(input$," ")
	Ttlbreaks=0
	repeat
		myarray$(TtlBreaks)=b$
		
        b$=next token$(" ")
        inc TtlBreaks
	until b$=""
	rem save the array and print the array contents to the screen
	print "saving the array"
	save array "input.arr",myarray$(TtlBreaks)
	print "array saved"
	
	for i=0 to TtlBreaks
	
	next i
	rem delete the array to ensure it is loaded again correctly
	empty array myarray$()
	
	compareArray(TtlBreaks)
	
endfunction


rem the function to compare the arrays.
function compareArray(TtlBreaks)
rem this function is supposed to load the array. 
rem it is only included here for my learning.
rem I could dim the array globally and not bother
rem saving and loading it.
	print "loading saved array array...."
	rem redim the arrray
	dim myarray$(TtlBreaks)
	rem reload the array
	load array "input.arr",myarray$(TtlBreaks)
	print array count(myarray$())
			
	print "Comparing array now and removing words from the list"

print "MyArray$ has "; array count (myarray$()); " elements"
print "removeWord$ has " ; array count (removeWord$()); " elements"
dim temp$(array count (myarray$())) rem <---very sloppy. will end up with empty unused elements almost
									rem Every time this runs.
count=0
		rem this bit of the code compares each element of array 1 ito each 
		rem element of array 2
	for i=0 to array count (myarray$()) -1 rem I had to add -1 to both arrays
	for t=0 to array count (removeWord$()) -1 rem to get rid of the empty field
	if myarray$(i) = removeWord$(t)
	inc i
	t=0
	else
		endif
	next t
	rem print the remaining words in the array.
	temp$(count)=myarray$(i)
	inc count
	next i
	print "printing the results of the comparison after any high frequency words have been removed"
	print ""
	for i = 0 to array count (temp$())
	print temp$(i); " ";
	next i
	
endfunction

`Probably better practice:
   DIM MyArray(1)
   FOR i = 1 TO 10
         ARRAY INSERT AT BOTTOM MyArray()
         MyArray(i) = i
   NEXT i
`What you can get away with in DBP:
   FOR x = 1 TO 10
         DIM MyOtherArray(x)
         MyOtherArray(x) = x
   NEXT x
`Differences:
   FOR d = 1 TO 10
         PRINT "MyArray(" + STR$(d) + "): " + STR$(MyArray(d)) + "           MyOtherArray(" + STR$(d) + "): " + STR$(MyOtherArray(d))
   NEXT d
   PRINT "-----------------------------"
   PRINT "Press any key to continue..."
   WAIT KEY

DIM a(10)
rem Elements:
1. a(0)
2. a(1)
3. a(2)
4. a(3)
5. a(4)
6. a(5)
7. a(6)
8. a(7)
9. a(8)
10. a(9)
11. a(10)

remstart
      Very crude beginings of a TAD engine. Sorta 1/2 a framework.
      Anyway, this is just one way of doing things. Code is structured
      in the most easy-to-read way I could manage using arrays.
      I'm not using arrays in my TAD engine (currently sorta on hiatus) so
      this approach was difficult work with. Hopefully it hasn't impaired
      my ability to make my code human-readable. Have tried to comment
      where I can. Just something to look at, even if you don't use 1% of
      it since it's a general example of memory-***ckery. Threw in some
      alternate ways of doing things in one function - using the hated GOTO.
      Functions are in alphabetical order.
      Any bugs? Sorry, it is only and example ;)
remend

`Here's the list of typical punctuation marks. I'll be using them as delimiters.
   DIM delim$(7)
   delim$(1) = " "
   delim$(2) = "."
   delim$(3) = ","
   delim$(4) = ":"
   delim$(5) = ";"
   delim$(6) = "!"
   delim$(7) = "?"
`Here's a word-removal list like the above
   DIM remword$(9)
   remword$(1) = "and"
   remword$(2) = "an"
   remword$(3) = "the"
   remword$(4) = "of"
   remword$(5) = "as"
   remword$(6) = "at"
   remword$(7) = "is"
   remword$(8) = "for"
   remword$(9) = "by"


`Get user input
   INK 0xFFFFFF, 0x000001
   INPUT "Enter a sentence or two >>", inp$
   CLS
   PRINT "Original sentence: ";
   INK 0xFFFF00, 0x000001
   PRINT inp$
   inp$ = LOWER$(inp$)                                                                                   `Convert to a standard, Lcase in this case (pun)
   CreateArray(inp$)                                                                                     `Pass to CreateArray()

`Print out the created array
   INK 0xFFFFFF, 0x000001
   PRINT " "
   PRINT "The following words were stored in the array"
   PRINT "after extraction from the sentence..."
   PRINT " "
   INK 0xFFFF00, 0x000001
   FOR j = 1 TO ARRAY COUNT(wordlist$())
         PRINT STR$(j) + ") " + wordlist$(j)
   NEXT j
   INK 0xFFFFFF, 0x000001
   PRINT " "

`Exit prompt
   PRINT "Push key, exit program, win prizes!"
   WAIT KEY
   UNDIM wordlist$()
   END


Function BadWord(wrd$)
`Checks for unwanted words
      ret = 0
      FOR i = 1 TO ARRAY COUNT(remword$())
            IF wrd$ = remword$(i): ret = 1: ENDIF
      NEXT i
EndFunction ret


Function CreateArray(txt$)
`Simplified version - Not the most elegant solution, but it makes life somewhat easier
`You can tailor this to be more sophisticated and from there optimise it for performance - if needed.
      count = 0                                                                                          `Count you know :)
      lastpos = 1                                                                                        `This tracks the start position of the last word
      IF RIGHT$(txt$, 1) <> ".": txt$ = txt$ + ".": ENDIF                                                `Standardize so all sentences processed and in a period.
      FOR i = 1 TO LEN(txt$)                                                                             `Start main FOR-loop
            IF WordBreak(MID$(txt$, i)) = 1                                                              `Check for punctuation delimiter
                  INC count                                                                              `On positive, increase count, (RE)DIM wordlist
                  DIM wordlist$(count)
                  FOR a = lastpos TO i                                                                   `Grab word
                        wordlist$(count) = wordlist$(count) + MID$(txt$, a)
                  NEXT a
                  wordlist$(count) = Purify(wordlist$(count))                                            `Process words to remove all non a-z characters.
                  IF wordlist$(count) = "": DEC count: DIM wordlist$(count): ENDIF                       `Kill empty arrays (created by double delims: ".."/"! ", etc.) by dimensioning the array smaller.
                  lastpos = i + 1                                                                        `Log start point +1 to skip delim
            ENDIF
      NEXT i
      RemoveWords()                                                                                      `Erase unwanted words
EndFunction


Function Purify(wrd$)
`Remove all things that don't belong in words
`GOTO and labels are frowned on in programming (by me too), but this gains a little speed.
`If you don't like GOTO, replace it with WHILE..ENDWHILE
   ProcessLeft:
         rpt = 0
         IF LEN(wrd$) = 0: EXITFUNCTION wrd$: ENDIF
         tmp = ASC(LEFT$(wrd$, 1))
         IF tmp < 97 OR tmp > 122
               rpt = 1
               wrd$ = RIGHT$(wrd$, LEN(wrd$) - 1)
         ENDIF
         IF rpt = 1: GOTO ProcessLeft: ENDIF
   ProcessRight:
         rpt = 0
         IF LEN(wrd$) = 0: EXITFUNCTION wrd$: ENDIF
         tmp = ASC(RIGHT$(wrd$, 1))
         IF tmp < 97 OR tmp > 122
               rpt = 1
               wrd$ = LEFT$(wrd$, LEN(wrd$) - 1)
         ENDIF
         IF rpt = 1: GOTO ProcessRight: ENDIF
EndFunction wrd$


Function RemoveWords()
      count = 0
      FOR i = 1 TO ARRAY COUNT(wordlist$())
            IF BadWord(wordlist$(i)) = 1
                  INC count                                                      `If there's a match, increase counter
                  DIM list(count)                                                `DIM/REDIM list()
                  list(count) = i                                                `Add index number that matched to list
            ENDIF
      NEXT i
   `Go through the list() array
      FOR i = 1 TO ARRAY COUNT(list())
            ARRAY DELETE ELEMENT wordlist$(0), list(i) - (i - 1)
      NEXT i
   `Remove list() from memory now
      UNDIM list()
EndFunction


Function WordBreak(char$)
`Check for delims
      ret = 0
      FOR i = 1 TO ARRAY COUNT(delim$())
            IF char$ = delim$(i): ret = 1: ENDIF
      NEXT i
EndFunction ret