Ooops
November 30, 2020, 01:39:55 AM

Author Topic: [bb] In game scripting B3d Bplus by Leon Drake [ 1+ years ago ]  (Read 574 times)

Offline BlitzBot

  • Jr. Member
  • **
  • Posts: 1
Title : In game scripting B3d Bplus
Author : Leon Drake
Posted : 1+ years ago

Description : well i didnt have too hard of a time converting it over to bb.
works the same though. however print is really the only blitz command available. adding your own isnt too hard. i'll post a tutorial soon on how to do it.

Added a few more features to this source code. Made it so
you can run multiple scripts and you can import
variables as well as functions from other active script
files. Just copy the following code to its appropriate
places and run it.



So make sure to cut and paste the following to txt files
commands.txt
Code: [Select]
0 U&U%%U&U
1 var
2 int
3 string
4 float
5 if
6 and
7 or
8 then
9 else
10 endif
11 end
12 function
13 endfunction
14 print
15 select
16 case
17 default
18 endselect
19 exit
20 return
21 for
22 to
23 next
24 callfunction
25 callvariable


script.txt
Code: [Select]
var string myvar
var int myvar2
var int myvar3
var int forlooper
var function curse
var function test


myvar3 = 100
myvar = 'mwhahahaha you bastage'

myvar2 = 1 + 1

if myvar2 + 1 = 3 and 10 > myvar2 then

curse
curse




select myvar3

case 100
print 'ok this one found 100'

case 200

print 'ok this one found 200'

default
print 'ok this one found what the other cases didnt'

endselect

else
print 'if on the groovy then'
endif

function test
print 'poop'
for forlooper = 0 to 10
print forlooper
next
endfunction


function curse
test
myvar3 = myvar3 + 100

print myvar3

endfunction


script2.txt
Code: [Select]
var string myvar



myvar = callvariable myscript QWERTYUIOP myvar


print myvar
callfunction myscript QWERTYUIOP curse


Code :
Code: BlitzBasic
  1. ;Rem
  2. ;******************************************************************************************
  3. ;Ingame Scripting Lib v0120 Blitz+&3d edition
  4. ;Written by.Leon Drake aka Landon Ritchie
  5. ;
  6. ;Free For Commercial Use! Enjoy!!
  7. ;
  8. ;Few bugs i need To let you know about in the scripting side
  9. ;
  10. ;Currently Everything is Case sensitive so when writing scripts keep everything lowercase
  11. ;I;ll be fixing that soon Also make sure everything is spaced My tokenizer is still just
  12. ;a baby so If you put in var3=var1+var2 , it will think that whole block is a value so use
  13. ;val3 = val1 + val2
  14. ;
  15. ;you have To declare all variables And the types Example var Int var1
  16. ;you must do the same For any functions you wish To use var Function myfunc
  17. ;
  18. ;I havent added the ability To cast parameters To functions yet, so dont put a () After
  19. ;your Function when calling it use myfunc instead of myfunc()
  20. ;
  21. ;note on If statements I;m pretty sure i got it To run Right so far If tested it And it
  22. ;seems To Return If statements fine however curently you can only use math operators Before
  23. ;it compares the If For example
  24. ;
  25. ;If myval + myval2 = myval3 Then
  26. ;
  27. ;works, but\
  28. ;
  29. ;If myval = myval2 + myval3 Then
  30. ;
  31. ;doesn;t work at the moment probably best To assign that stuff Before you call an If, For
  32. ;now anyways You can use And & Or in your If statement And its Not limited on how complex
  33. ;that part may be you can also use Else in your If statement so far it works good
  34. ;
  35. ;
  36. ;
  37. ;I;ll try To keep updating this as often as i can , which should be often enough since i;m
  38. ;using this code For a 2d rpg engine
  39. ;
  40. ;
  41. ;Just added the ability To Write Select statements
  42. ;
  43. ;works pretty much the same as blitz
  44. ;
  45. ;usage
  46. ;
  47. ;Select myval3
  48. ;
  49. ;Case 100
  50. ;
  51. ;Case 200
  52. ;
  53. ;Default
  54. ;
  55. ;endselect
  56. ;
  57. ;you can also put Select statements inside other Select statements And it works fine
  58. ;
  59. ;Select myval3
  60. ;
  61. ;Case 100
  62. ;       Select myval4
  63. ;      
  64. ;               Case 20
  65. ;              
  66. ;       endselect
  67. ;
  68. ;Default
  69. ;
  70. ;endselect
  71. ;
  72. ;added For loops \yet To be upgraded its still very touchy it must be run with a variable
  73. ;like so.
  74. ;
  75. ;For myvar3 = 0 To 100;
  76. ;
  77. ;Next
  78. ;
  79. ;you can however Replace the 0 Or the 100 with variables doesnt have To start with 0 Or
  80. ;End with 100 i was merely using that as an example
  81. ;
  82. ;
  83. ;Added New Function
  84. ;callfunction scriptname functionname
  85. ;
  86. ;What this does is allows you To call a Function from a different active script meaning you
  87. ;have already used runscript on that script which makes the script active And its functions
  88. ;available Use call Function from another script To run a Function from a different script
  89. ;using the other scripts variables And what Not Also you dont have To worry about 2 scripts
  90. ;running using the same variable names i made sure it differentiates them
  91. ;
  92. ;Added New Function
  93. ;callvariable scriptname variablename
  94. ;
  95. ;Just like callfunction this allows you To access the contents of a variable in another
  96. ;active script So far its only usage is For variable assignment you cant use it in If
  97. ;statements Or anything Else like that so you;ll have To pre grab the variable contents
  98. ;Before hand like this.
  99. ;
  100. ;myvar = callvariable myscript varname
  101. ;
  102. ;you can also do this If you want To
  103. ;
  104. ;myvar = callvariable myscript varname + callvariable myscript varname2
  105. ;And that works with all the math operators i;ve added so far
  106. ;
  107. ;
  108. ;******************************************************************************************
  109. ;End Rem
  110. ;Import "binbtypemx"
  111. ;Import "binbvkeymx"
  112. ;Global declare.TList = New TList
  113. ;Global dtokens.TList = New TList
  114. ;Global commands.TList = New TList
  115. ;Global arguement.TList = New TList
  116. ;Global ifbool.TList = New TList
  117. ;Global ftokens.TList = New TList
  118. ;Global script.TList = New TList
  119.  
  120. ;token types
  121. Const OPERATORS$ = "*/+-=><"
  122.  
  123.  
  124. Type script
  125.  
  126.  
  127. Field scriptname$,scripthandle$
  128. End Type
  129.  
  130. Type ifbool
  131.  
  132.  
  133. Field bool,boolexp,parentscrpt.script
  134. End Type
  135.  
  136. Type arguement
  137.        
  138.  
  139. Field arguementtype$,argvalue$,argnextoperator$,expecting$,parentscrpt.script
  140. End Type
  141.  
  142. Type commands
  143.        
  144. Field commandname$,commandtype
  145. End Type
  146.  
  147. Type declare
  148.  
  149.  
  150. Field dtype$,ddata$,dataarray$[999],dname$,parentscript$,pscript,sindex,parentscrpt.script
  151. End Type
  152.  
  153. Type dtokens
  154.  
  155.  
  156.  
  157. Field dname$,parentscript$,pscript,index,lline,tokentype,parentfunction.declare,parentscrpt.script
  158. End Type
  159.  
  160.  
  161.  
  162. Type ftokens
  163.  
  164.  
  165. Field dname$,parentscript$,pscript,index,lline,tokentype,parentfunction.declare,parentscrpt.script
  166. End Type
  167.  
  168. loadcommands()
  169.  
  170. tokenizescript()
  171. tokenizescript("myscript2","ASDFGH","script2.txt")
  172. ;processtokens()
  173.  
  174. runscript()
  175. runscript("myscript2","ASDFGH")
  176.  
  177. Function runscript.script(scriptname$="myscript",scripthandle$="QWERTYUIOP")
  178. Local tok.dtokens,com.commands,scr.script
  179. scr = getscript.script(scriptname$,scripthandle$)
  180. If scr = Null Then
  181. DebugLog "invalid script name"
  182. Return Null
  183. EndIf
  184. tok = gettoken.dtokens(scr)
  185. Repeat
  186. ;For tok.dtokens = each dtokens
  187. DebugLog tokdname$+" object? "
  188.  
  189. If tok = Null Then Return Null
  190.  
  191. ;If tok2 <> Null And tok = tok2 Continue
  192. ;For com.commands = each commands
  193. com = checkcommands.commands(tok        okentype)
  194. If com <> Null Then
  195.  
  196. tok = processcommands(tok.dtokens,com.commands)
  197. ;Exit
  198. EndIf
  199.  
  200. If tok <> Null Then
  201. tok = After tok
  202.  
  203. EndIf
  204. If tok = Null Then Return Null
  205. Until tok = Null Or tokparentscrpt <> scr
  206.  
  207. ;Next
  208.  
  209.  
  210. End Function
  211.  
  212. Function getscript.script(scriptname$,scripthandle$)
  213. For scr.script = Each script
  214. If scrscriptname$ = scriptname$ And scrscripthandle$ = scripthandle$ Then
  215. Return scr
  216. EndIf
  217. Next
  218. Return Null
  219. End Function
  220.  
  221.  
  222.  
  223.  
  224. Function gettoken.dtokens(scr.script)
  225.  
  226.  
  227. For tok.dtokens = Each dtokens
  228. If tokparentscrpt = scr Then
  229. Return tok
  230. EndIf
  231. Next
  232. Return Null
  233. End Function
  234.  
  235.  
  236. Function getarguement.arguement(arg2.arguement)
  237. For arg.arguement = Each arguement
  238. If arg = arg2 Then
  239. Return arg
  240. EndIf
  241. Next
  242. Return Null
  243. End Function
  244.  
  245.  
  246. Function getifbool.ifbool(ifo2.ifbool)
  247. For ifo.ifbool = Each ifbool
  248. If ifo = ifo2 Then
  249. Return ifo
  250. EndIf
  251. Next
  252. Return Null
  253. End Function
  254.  
  255. Function processcommands.dtokens(tok.dtokens,com.commands)
  256.  
  257. Select comcommandtype
  258.  
  259. Case 0
  260. dtype$ = checktoken$(tok)
  261.         Select dtype$
  262.        
  263.         Case ""
  264.         DebugLog "I dunno what that is"
  265.         Return Null
  266.        
  267.         ;Case "function"
  268.         ;tok = runfunction(tok)
  269.         ;Return tok
  270.        
  271.         Default
  272.         DebugLog "Let;s assign a var"
  273.         tok = assignvar(tok)
  274.         Return tok
  275.        
  276.         End Select
  277.  
  278.  
  279. Case 1
  280. tok = declarevar(tok)
  281. Return tok
  282.  
  283.  
  284. Case 5
  285. tok = runifstate(tok)
  286. Return tok
  287.  
  288. Case 14
  289. tok = printfunc(tok)
  290. Return tok
  291.  
  292.  
  293. Case 15
  294. tok = runselectstate(tok)
  295. Return tok
  296.  
  297. Case 21
  298. tok = runforloop(tok)
  299. Return tok
  300.  
  301. Case 24
  302. tok = callfunction(tok)
  303. Return tok
  304.  
  305. End Select
  306.  
  307. End Function
  308.  
  309.  
  310. Function callvariable$(tok.dtokens)
  311. Local scr.script,oldtok.dtokens,tokdata$,dec.declare,dnameo$
  312. tok = After tok
  313. If tok = Null Then
  314. DebugLog "unexpected End of file"
  315. Return ""
  316. EndIf
  317. dnameo$ = tokdname$
  318. tok = After tok
  319. If tok = Null Then
  320. DebugLog "unexpected End of file"
  321. Return ""
  322. EndIf
  323.  
  324. scr = getscript.script(dnameo$,tokdname$)
  325. If scr = Null Then
  326. DebugLog "Source Script does not exist"
  327. Return
  328. EndIf
  329. tok = After tok
  330. If tok = Null Then
  331. DebugLog "unexpected End of file"
  332. Return
  333. EndIf
  334. oldtok = tok
  335. tok.dtokens = New dtokens
  336. tokdname$ = oldtokdname$
  337. tokindex = 0
  338. toklline = 0
  339. tokparentscrpt = scr
  340. dec = finddeclaration.declare(tok)
  341. If dec = Null Then
  342. DebugLog "Variable does not exist"
  343. Return ""
  344. EndIf
  345. Delete tok
  346.  
  347. tok = oldtok
  348. Return decddata$
  349. End Function
  350.  
  351.  
  352.  
  353.  
  354. Function callfunction.dtokens(tok.dtokens)
  355. Local scr.script,oldtok.dtokens,dnameo$
  356.  
  357. tok = After tok
  358. If tok = Null Then
  359. DebugLog "unexpected End of file"
  360. Return Null
  361. EndIf
  362. dnameo$ = tokdname$
  363. tok = After tok
  364. If tok = Null Then
  365. DebugLog "unexpected End of file"
  366. Return Null
  367. EndIf
  368.  
  369. scr = getscript.script(dnameo$,tokdname$)
  370. If scr = Null Then
  371. DebugLog "Source Script does not exist"
  372. Return Null
  373. EndIf
  374. tok = After tok
  375. If tok = Null Then
  376. DebugLog "unexpected End of file"
  377. Return Null
  378. EndIf
  379. DebugLog "CALLING FUNCTION "+tokdname$
  380. oldtok = tok
  381. tok.dtokens = New dtokens
  382. tokdname$ = oldtokdname$
  383. tokindex = 0
  384. toklline = 0
  385. tokparentscrpt = scr
  386.  
  387. tok = runfunction(tok)
  388. Delete tok
  389.  
  390. tok = oldtok
  391. Return tok
  392. End Function
  393.  
  394.  
  395. Function runforloop.dtokens(tok.dtokens)
  396.  
  397. Local com.commands,loopvar,valuebegin$,valueend$
  398. Local firstok.dtokens,lastok.dtokens
  399. Local dec.declare,dec2.declare,dec3.declare
  400. tok = After tok
  401. dec = finddeclaration.declare(tok)
  402. If dec = Null
  403. DebugLog "Must be variable in for loop"
  404. Return Null
  405. EndIf
  406. tok = After tok
  407. If tokdname$ <> "=" Then
  408. DebugLog "Expecting = after For (VAR)"
  409. Return Null
  410. EndIf
  411. tok = After tok
  412. dec2 = finddeclaration.declare(tok)
  413. If dec2 = Null Then
  414. DebugLog "not a variable must be a value"
  415. valuebegin$ = tokdname$
  416. Else
  417. valuebegin$ = dec2ddata$
  418. EndIf
  419. tok = After tok
  420. If tokdname$ <> "to" Then
  421. DebugLog "expecting to after (VAR)"
  422. Return Null
  423. EndIf
  424. tok = After tok
  425. dec3 = finddeclaration.declare(tok)
  426. If dec3 = Null Then
  427. DebugLog "not a variable must be a value"
  428. valueend$ = tokdname$
  429. Else
  430. valueend$ = dec3ddata$
  431. EndIf
  432. tok = After tok
  433. firstok = tok
  434. decddata$ = Int(valuebegin$)
  435. Repeat
  436.  
  437.                                         ;For tok.dtokens = each dtokens
  438.                                         DebugLog tokdname$+" object? "
  439.                                        
  440.                                         If tok = Null Then Return Null
  441.                                        
  442.                                         ;If tok2 <> Null And tok = tok2 Continue
  443.                                         ;For com.commands = each commands
  444.                                         com = checkcommands.commands(tok        okentype)
  445.                                         If com <> Null Then
  446.                                        
  447.                                         tok = processcommands(tok.dtokens,com.commands)
  448.                                         ;Exit
  449.                                         EndIf
  450.                                         If tok = Null Then Return Null
  451.                                         If tok <> Null Then
  452.                                         tok = After tok
  453.                                         EndIf
  454.                                         If tokdname$ = "next" And Int(decddata$) < Int(valueend$) Then
  455.                                         decddata$ = Int(decddata$) + 1
  456.                                         tok = firstok
  457.                                         EndIf
  458.  
  459.                                         Until tokdname$ = "next" And Int(decddata$) = Int(valueend$)
  460.                         Return tok             
  461. End Function
  462.  
  463. Function runselectstate.dtokens(tok.dtokens)
  464. Local valcompare$,valtype$,tempval$,deftok.dtokens,oldtok.dtokens
  465. Local com.commands,selectstates,hasdefaultstate,defaulted=True
  466. tok = After tok
  467. Local dec.declare = finddeclaration.declare(tok)
  468. If dec = Null
  469. DebugLog "Must be variable in select statement"
  470. Return Null
  471. EndIf
  472. valcompare$ = decddata$
  473. valtype$ = decdtype$
  474. tok = After tok
  475.  
  476.  
  477. Repeat
  478. DebugLog "select debug current token is. "+tokdname$
  479.         If tok = Null Then
  480.         DebugLog "unexpected end of file"
  481.         Return Null
  482.         EndIf
  483.         com = checkcommands(tok okentype)
  484.         If com = Null Then
  485.         DebugLog "expected case statement"
  486.         Return Null
  487.         EndIf
  488.         Select comcommandtype
  489.  
  490.         Case 16
  491.                 selectstates = 0
  492.                 tok = After tok
  493.                 dec.declare = finddeclaration.declare(tok)
  494.                
  495.         If dec = Null Then
  496.                 DebugLog "Must be just a value"
  497.                
  498.                 If Instr(tokdname$,";",1) <> 0 Then
  499.                 tempval$ = Replace(tokdname$,";","")
  500.                 Else
  501.                 tempval$ = tokdname$
  502.                 EndIf
  503.                
  504.                         If valcompare$ = tempval$ Then
  505.                                         defaulted = False
  506.                                         tok = After tok
  507.                                         Repeat
  508.                                         ;For tok.dtokens = each dtokens
  509.                                         DebugLog tokdname$+" object? "
  510.                                        
  511.                                         If tok = Null Then Return Null
  512.                                        
  513.                                         ;If tok2 <> Null And tok = tok2 Continue
  514.                                         ;For com.commands = each commands
  515.                                         com = checkcommands.commands(tok        okentype)
  516.                                         If com <> Null Then
  517.                                        
  518.                                         tok = processcommands(tok.dtokens,com.commands)
  519.                                         ;Exit
  520.                                         EndIf
  521.                                         If tok = Null Then Return Null
  522.                                         If tok <> Null Then
  523.                                         tok = After tok
  524.                                         EndIf
  525.                                         If tokdname$ = "select" Then selectstates = selectstates + 1
  526.                                         If tokdname$ = "endselect" Then
  527.                                         selectstates = selectstates - 1
  528.                                         If selectstates < 0 Then selectstates = 0
  529.                                         EndIf
  530.                                         DebugLog "INSIDE SELECT NEXT TOKEN IS ."+tokdname$
  531.                                         Until tokdname$ = "case" Or tokdname$ = "exit" Or tokdname$ = "Default" Or tokdname$ = "EndSelect" And selectstates = 0
  532.                                         ;If tokdname$ = "else" Then
  533.                                         ;tok = getendstatement(tok)
  534.                                         ;Return tok
  535.                                         If tokdname$ = "exit" Then
  536.                                         Repeat
  537.                                
  538.                                 tok = After tok
  539.                                
  540.                                 If tok = Null Then
  541.                                 DebugLog "expecting end select"
  542.                                 Return Null
  543.                                 EndIf
  544.                                 DebugLog "INSIDE DEFAULT NEXT TOKEN IS. "+tokdname$
  545.                                         If tokdname$ = "select" Then selectstates = selectstates + 1
  546.                                         If tokdname$ = "endselect" Then
  547.                                         selectstates = selectstates - 1
  548.                                         If selectstates < 0 Then selectstates = 0
  549.                                         EndIf
  550.                                
  551.                        
  552.                                 Until tokdname$ = "endselect" And selectstates = 0
  553.  
  554.                                        
  555.                                         EndIf
  556.  
  557.  
  558.                         Else
  559.                         ;defaulted = True
  560.                         selectstates = 0
  561.                                 Repeat
  562.                                
  563.                                 tok = After tok
  564.                                 If tok = Null Then
  565.                                 DebugLog "expecting end select"
  566.                                 Return Null
  567.                                 EndIf
  568.                                 If tokdname$ = "select" Then selectstates = selectstates + 1
  569.                                         If tokdname$ = "endselect" Then
  570.                                         selectstates = selectstates - 1
  571.                                         If selectstates < 0 Then selectstates = 0
  572.                                         EndIf
  573.                                
  574.                        
  575.                                 Until tokdname$ = "case" Or tokdname$ = "default" Or tokdname$ = "endselect" And selectstates = 0
  576.                         EndIf
  577.                
  578.                 Else
  579.                 DebugLog "found variable now compare case"
  580.                 tempval$ = tokdname$
  581.                         If valcompare$ = tempval$ Then
  582.                                         defaulted = False
  583.                                         tok = After tok
  584.                                         Repeat
  585.                                         ;For tok.dtokens = each dtokens
  586.                                         DebugLog tokdname$+" object? "
  587.                                        
  588.                                         If tok = Null Then Return Null
  589.                                        
  590.                                         ;If tok2 <> Null And tok = tok2 Continue
  591.                                         ;For com.commands = each commands
  592.                                         com = checkcommands.commands(tok        okentype)
  593.                                         If com <> Null Then
  594.                                        
  595.                                         tok = processcommands(tok.dtokens,com.commands)
  596.                                         ;Exit
  597.                                         EndIf
  598.                                         If tok = Null Then Return Null
  599.                                         If tok <> Null Then
  600.                                         tok = After tok
  601.                                         EndIf
  602.                                         If tokdname$ = "select" Then selectstates = selectstates + 1
  603.                                         If tokdname$ = "endselect" Then
  604.                                         selectstates = selectstates - 1
  605.                                         If selectstates < 0 Then selectstates = 0
  606.                                         EndIf
  607.                                                 DebugLog "INSIDE SELECT NEXT TOKEN IS ."+tokdname$
  608.                                
  609.                                         Until tokdname$ = "case" Or tokdname$ = "exit" Or tokdname$ = "default" Or tokdname$ = "endselect" And selectstates = 0
  610.                                         ;If tokdname$ = "else" Then
  611.                                         ;tok = getendstatement(tok)
  612.                                         ;Return tok
  613.                                         If tokdname$ = "exit" Then
  614.                                         Repeat
  615.                                
  616.                                 tok = After tok
  617.                                
  618.                                 If tok = Null Then
  619.                                 DebugLog "expecting end select"
  620.                                 Return Null
  621.                                 EndIf
  622.                                 DebugLog "INSIDE DEFAULT NEXT TOKEN IS. "+tokdname$
  623.                                         If tokdname$ = "select" Then selectstates = selectstates + 1
  624.                                         If tokdname$ = "endselect" Then
  625.                                         selectstates = selectstates - 1
  626.                                         If selectstates < 0 Then selectstates = 0
  627.                                         EndIf
  628.                                
  629.                        
  630.                                 Until tokdname$ = "endselect" And selectstates = 0
  631.  
  632.                                        
  633.                                         EndIf
  634.  
  635.                                        
  636.  
  637.                         Else
  638.                         ;defaulted = True
  639.                         selectstates = 0
  640.                                 Repeat
  641.                                
  642.                                 tok = After tok
  643.                                 If tok = Null Then
  644.                                 DebugLog "expecting end select"
  645.                                 Return Null
  646.                                 EndIf
  647.                                 If tokdname$ = "select" Then selectstates = selectstates + 1
  648.                                         If tokdname$ = "endselect" Then
  649.                                         selectstates = selectstates - 1
  650.                                         If selectstates < 0 Then selectstates = 0
  651.                                         EndIf
  652.                                
  653.                        
  654.                                 Until tokdname$ = "case" Or tokdname$ = "default" Or tokdname$ = "endselect" And selectstates = 0
  655.                         EndIf
  656.                
  657.                
  658.                 EndIf
  659.        
  660.         Case 17
  661.         DebugLog "found default"
  662.         hasdefaultstate = True
  663.         deftok = tok
  664.                                 selectstates = 0
  665.                                 Repeat
  666.                                
  667.                                 tok = After tok
  668.                                
  669.                                 If tok = Null Then
  670.                                 DebugLog "expecting end select"
  671.                                 Return Null
  672.                                 EndIf
  673.                                 DebugLog "INSIDE DEFAULT NEXT TOKEN IS. "+tokdname$
  674.                                         If tokdname$ = "select" Then selectstates = selectstates + 1
  675.                                         If tokdname$ = "endselect" Then
  676.                                         selectstates = selectstates - 1
  677.                                         If selectstates < 0 Then selectstates = 0
  678.                                         EndIf
  679.                                
  680.                        
  681.                                 Until tokdname$ = "case" Or tokdname$ = "default" Or tokdname$ = "endselect" And selectstates = 0
  682.                                
  683.         If tokdname$ = "default" Then
  684.         DebugLog "Select Cannot contain multiple Default Cases"
  685.         Return Null
  686.         EndIf
  687.  
  688.         Case 18
  689.         DebugLog "OK now im checking the default status here . "+defaulted
  690.         If hasdefaultstate = True And defaulted = True Then
  691.                 If deftok = Null Then
  692.                 DebugLog "unknown error occured in select statement"
  693.                 Return Null
  694.                 EndIf
  695.         oldtok = tok
  696.         tok = deftok
  697.         selectstates = 0
  698.  
  699.  
  700.  
  701.                                        
  702.                                         tok = After tok
  703.                                         Repeat
  704.                                         ;For tok.dtokens = each dtokens
  705.                                         DebugLog tokdname$+" object? "
  706.                                        
  707.                                         If tok = Null Then Return Null
  708.                                        
  709.                                         ;If tok2 <> Null And tok = tok2 Continue
  710.                                         ;For com.commands = each commands
  711.                                         com = checkcommands.commands(tok        okentype)
  712.                                         If com <> Null Then
  713.                                        
  714.                                         tok = processcommands(tok.dtokens,com.commands)
  715.                                         ;Exit
  716.                                         EndIf
  717.                                         If tok = Null Then Return Null
  718.                                         If tok <> Null Then
  719.                                         tok = After tok
  720.                                         EndIf
  721.                                         If tokdname$ = "select" Then selectstates = selectstates + 1
  722.                                         If tokdname$ = "endselect" Then
  723.                                         selectstates = selectstates - 1
  724.                                         If selectstates < 0 Then selectstates = 0
  725.                                         EndIf
  726.                                         Until tokdname$ = "case" Or tokdname$ = "exit" Or tokdname$ = "default" Or tokdname$ = "endselect" And selectstates = 0
  727.                                         ;If tokdname$ = "else" Then
  728.                                         ;tok = getendstatement(tok)
  729.                                         tok = oldtok
  730.                                         ;Return tok
  731.                                         If tokdname$ = "exit" Then
  732.                                         Repeat
  733.                                
  734.                                 tok = After tok
  735.                                
  736.                                 If tok = Null Then
  737.                                 DebugLog "expecting end select"
  738.                                 Return Null
  739.                                 EndIf
  740.                                 DebugLog "INSIDE DEFAULT NEXT TOKEN IS. "+tokdname$
  741.                                         If tokdname$ = "select" Then selectstates = selectstates + 1
  742.                                         If tokdname$ = "endselect" Then
  743.                                         selectstates = selectstates - 1
  744.                                         If selectstates < 0 Then selectstates = 0
  745.                                         EndIf
  746.                                
  747.                        
  748.                                 Until tokdname$ = "endselect" And selectstates = 0
  749.  
  750.                                        
  751.                                         EndIf
  752.        
  753.         Else
  754.         DebugLog "wasnt default returning "+tokdname$
  755.         Return tok
  756.        
  757.         EndIf
  758.         DebugLog "looks like it went through returning tok. "+tokdname$
  759.         Return tok
  760.        
  761.        
  762.         End Select
  763.        
  764. Until tok = Null
  765. DebugLog "unexpected end of file"
  766. Return Null
  767.  
  768.  
  769. End Function
  770.  
  771.  
  772.  
  773. Function printfunc.dtokens(tok.dtokens)
  774. tok = After tok
  775. Local dec.declare = finddeclaration.declare(tok)
  776. If dec = Null Then
  777. DebugLog "just debuglog value"
  778.  
  779. Print tokdname$
  780. ;tok = after tok
  781. Else
  782. Print decddata$
  783. EndIf
  784. Return tok
  785.  
  786. End Function
  787.  
  788.  
  789. Function runfunction.dtokens(tok.dtokens)
  790. ;tok = after tok
  791. DebugLog "and the magical function name is "+tokdname$
  792. Local dec.declare = finddeclaration.declare(tok)
  793. Local oldtok.dtokens,com.commands,scr.script
  794. oldtok = tok
  795. scr = tokparentscrpt
  796. If dec = Null Then
  797. DebugLog "Function does not exist"
  798. Return tok
  799. EndIf
  800. tok = invokefunctiontokens(dec)
  801. Repeat
  802. ;For tok.dtokens = each dtokens
  803. DebugLog tokdname$+" object? "
  804.  
  805. If tok = Null Then Return Null
  806.  
  807. ;If tok2 <> Null And tok = tok2 Continue
  808. ;For com.commands = each commands
  809. com = checkcommands.commands(tok        okentype)
  810. If tokdname$ = "return" Then
  811. tok = oldtok
  812. Return tok
  813. EndIf
  814. If com <> Null Then
  815.  
  816. tok = processcommands(tok,com)
  817. ;Exit
  818. EndIf
  819.  
  820. If tok <> Null Then
  821. tok = After tok
  822. If tok = Null Then
  823. tok = oldtok
  824. dismissfunctiontokens(dec)
  825. DebugLog "end function returning next token "+tokdname$
  826. Return tok
  827.  
  828. EndIf
  829. EndIf
  830. Until tok = Null Or tokparentscrpt <> scr
  831. tok = oldtok
  832. dismissfunctiontokens(dec)
  833. DebugLog "end function returning next token "+tokdname$
  834. Return tok
  835.  
  836. End Function
  837.  
  838. Function dismissfunctiontokens(dec.declare)
  839.  
  840. For tok.dtokens = Each dtokens
  841. If tokparentfunction = dec And tokparentscrpt = decparentscrpt Then
  842. Delete tok
  843.  
  844. EndIf
  845. Next
  846.  
  847. End Function
  848.  
  849. Function invokefunctiontokens.dtokens(dec.declare)
  850. Local firstok.dtokens,gotfirst=False
  851. For fok.ftokens = Each ftokens
  852. If fokparentfunction = dec And fokparentscrpt = decparentscrpt Then
  853. tok.dtokens = New dtokens
  854. tokdname$ = fokdname$
  855. DebugLog "adding function token "+tokdname$
  856. tokindex = fokindex
  857. toklline = foklline
  858. tok     okentype = fok  okentype
  859. tokparentfunction = fokparentfunction
  860. tokparentscrpt = decparentscrpt
  861. If gotfirst = False Then
  862. firstok = tok
  863. gotfirst = True
  864. EndIf
  865.  
  866. EndIf
  867. Next
  868.  
  869. Return firstok
  870. End Function
  871.  
  872. Function checktoken$(tok.dtokens)
  873. DebugLog "checking token "+tokdname$
  874. If tokparentscrpt = Null Then
  875. DebugLog "This token has no parent script"
  876. EndIf
  877. Local olddec.declare
  878. Local dec.declare = finddeclaration.declare(tok)
  879.  
  880. If dec = Null Then
  881. DebugLog "Expecting variable Assignment"
  882. Return ""
  883. Else
  884. DebugLog "found the variable of type "+decdtype$
  885. Return decdtype$
  886.  
  887. EndIf
  888.  
  889.  
  890.  
  891.  
  892. End Function
  893.  
  894.  
  895. Function checkcommands.commands(Data1)
  896. DebugLog "checking the commands"
  897. For com.commands = Each commands
  898. If Data1 = comcommandtype Then
  899. Return com
  900. EndIf
  901. Next
  902. Return Null
  903. End Function
  904.  
  905.  
  906. Function checkspecificcommands.commands(Data1$)
  907. DebugLog "checking the commands"
  908. For com.commands = Each commands
  909. If Data1$ = comcommandname$ Then
  910. Return com
  911. EndIf
  912. Next
  913. Return Null
  914. End Function
  915.  
  916.  
  917. Function runifstate.dtokens(tok.dtokens)
  918. Local olddec.declare,oldtok.dtokens,com.commands
  919. Local dec.declare,arg.arguement,foundcompare=False
  920. Local foundthen = False
  921. Repeat
  922. tok = After tok
  923. com = checkcommands(tok okentype)
  924. If com <> Null Then
  925. If comcommandtype = 0 Then com = Null
  926. EndIf
  927. If com = Null Then
  928. dec = finddeclaration.declare(tok)
  929.  
  930. If dec = Null Then
  931.  
  932.         DebugLog "Not a variable\ must be just an argument"
  933.         arg = checkarg(tokdname$)
  934.  
  935.        
  936. Else
  937.     DebugLog "found variable "+decdname$
  938.         arg.arguement = New arguement
  939.         argarguementtype$ = decdtype$
  940.         argargvalue$ = decddata$
  941.        
  942.  
  943.        
  944.  
  945. EndIf
  946.     DebugLog "lets find the operator"
  947.         tok = After tok
  948.         DebugLog "operator given is "+tokdname$
  949.         check = validateoperator(tokdname$)
  950.        
  951.                 If check <> 0 Then
  952.        
  953.                
  954.        
  955.                 argargnextoperator$ = tokdname$
  956.        
  957.                         If check = 2 And foundcompare = False Then
  958.                         foundcompare = True
  959.                         Else If check = 2 And foundcompare = True Then
  960.                         DebugLog "Expecting Command"
  961.                         Return Null
  962.                         EndIf
  963.                
  964.                
  965.                 Else
  966.                         com = checkcommands(tok okentype)
  967.                         If com <> Null Then
  968.                         If comcommandtype = 0 Then com = Null
  969.                         EndIf
  970.                         If com = Null Then
  971.                         DebugLog "Expected Operator"
  972.                         Return Null
  973.                         Else
  974.                         DebugLog "looks as though we hit a command lets back track one token"
  975.                         argargnextoperator$ = tokdname$
  976.                         tok = Before tok
  977.                         foundcompare = False
  978.                         EndIf
  979.                 EndIf
  980. Else
  981. Select comcommandtype
  982.  
  983.         Case 6
  984.         foundcompare = False
  985.        
  986.         Case 7
  987.         foundcompare = False
  988.        
  989.         Case 8
  990.         foundcompare = False
  991.         foundthen = True
  992.        
  993.         Default
  994.         DebugLog "invalid command"
  995.         Return Null
  996.        
  997. End Select
  998. EndIf
  999. Until foundthen = True
  1000. DebugLog "found then"
  1001.  
  1002. DebugLog "lets see if the if statement is true"
  1003.  
  1004. DebugLog "debuglog all arguements"
  1005. For arg.arguement = Each arguement
  1006. DebugLog "arguement. "+argarguementtype$+" value. "+argargvalue$+" next operator. "+argargnextoperator$
  1007. Next
  1008. processarguments()
  1009. ifboolean = processifbooleans()
  1010. DebugLog "if statement is "+ifboolean
  1011. killbools()
  1012. killargs()
  1013.  
  1014. Select ifboolean
  1015.  
  1016. Case False
  1017. oldtok = tok
  1018. tok = getelsestatement.dtokens(tok)
  1019. If tok = Null Then
  1020. tok = getendstatement(oldtok)
  1021. Return tok
  1022. Else
  1023. tok = After tok
  1024. Repeat
  1025. ;For tok.dtokens = each dtokens
  1026. DebugLog tokdname$+" object? "
  1027.  
  1028. If tok = Null Then Return Null
  1029.  
  1030. ;If tok2 <> Null And tok = tok2 Continue
  1031. ;For com.commands = each commands
  1032. com = checkcommands.commands(tok        okentype)
  1033. If com <> Null Then
  1034.  
  1035. tok = processcommands(tok.dtokens,com.commands)
  1036. ;Exit
  1037. EndIf
  1038.  
  1039. If tok <> Null Then
  1040. tok = After tok
  1041. EndIf
  1042. Until tokdname$ = "endif"
  1043. Return tok
  1044. EndIf
  1045.  
  1046.  
  1047. Case True
  1048. tok = After tok
  1049. Repeat
  1050. ;For tok.dtokens = each dtokens
  1051. DebugLog tokdname$+" object? "
  1052.  
  1053. If tok = Null Then Return Null
  1054.  
  1055. ;If tok2 <> Null And tok = tok2 Continue
  1056. ;For com.commands = each commands
  1057. com = checkcommands.commands(tok        okentype)
  1058. If com <> Null Then
  1059.  
  1060. tok = processcommands(tok.dtokens,com.commands)
  1061. ;Exit
  1062. EndIf
  1063. If tok = Null Then Return Null
  1064. If tok <> Null Then
  1065. tok = After tok
  1066. EndIf
  1067. Until tokdname$ = "endif" Or tokdname$ = "else"
  1068. If tokdname$ = "else" Then
  1069. DebugLog "found else going to endif"
  1070. tok = getendstatement(tok)
  1071. Return tok
  1072. EndIf
  1073.  
  1074. End Select
  1075.  
  1076. End Function
  1077.  
  1078.  
  1079. Function getelsestatement.dtokens(tok.dtokens)
  1080. Local statescount = 0
  1081. Repeat
  1082. tok = After tok
  1083.  
  1084. If tok = Null Then
  1085. DebugLog "unepected end of file"
  1086. Return Null
  1087. EndIf
  1088. If tokdname$ = "if" Then statescount = statescount + 1
  1089. If tokdname$ = "endif" And statescount > 0 Then statescount = statescount - 1
  1090. If tokdname$ = "endif" And statescount = 0 Then Return Null
  1091. Until tokdname$ = "else" And statescount = 0
  1092. End Function
  1093.  
  1094. Function getendstatement.dtokens(tok.dtokens)
  1095. Local statescount=0
  1096.  
  1097. Repeat
  1098.  
  1099. tok = After tok
  1100. If tok = Null Then
  1101. DebugLog "unepected end of file"
  1102. Return Null
  1103. EndIf
  1104.  
  1105. If tokdname$ = "if" Then statescount = statescount + 1
  1106. If tokdname$ = "endif" And statescount > 0 Then statescount = statescount - 1
  1107.  
  1108.  
  1109. Until tokdname$ = "endif" And statescount = 0
  1110. Return tok
  1111. End Function
  1112.  
  1113. Function processarguments()
  1114. Local arg.arguement,arg2.arguement,oldvalue$,oldvaluetype$,arguementbool=False
  1115. Local nextoperator$,com.commands,narg.arguement
  1116. arg2.arguement = First arguement
  1117. arg = getarguement(arg2)
  1118.  
  1119. If arg = Null Then
  1120. DebugLog "I dont know how the hell it happened but i lost my arguements"
  1121. Return False
  1122. EndIf
  1123. oldvalue$ = argargvalue$
  1124. oldvaluetype$ = argarguementtype$
  1125. nextoperator$ = argargnextoperator$
  1126. Repeat
  1127. nextoperator$ = argargnextoperator$
  1128. arg = After arg
  1129. operationtype = validateoperator(nextoperator$)
  1130.  
  1131.         Select operationtype
  1132.         Case 1
  1133.         DebugLog "old value "+oldvalue$
  1134.         oldvalue$ = mathoperation$(oldvalue$,argargvalue$,oldvaluetype$,argarguementtype$,nextoperator$)
  1135.         DebugLog "new value "+oldvalue$
  1136.        
  1137.         Case 2
  1138.         DebugLog "before bool argvalue is "+argargvalue$+" vs "+oldvalue$
  1139.         arguementbool = booloperation(oldvalue$,argargvalue$,oldvaluetype$,argarguementtype$,nextoperator$)
  1140.         DebugLog "bool "+arguementbool
  1141.        
  1142.         Default
  1143.         DebugLog "may be an operative command"
  1144.         com = checkspecificcommands(nextoperator$)
  1145.         If com = Null Then
  1146.         DebugLog "Somehow it got screwed up"
  1147.         Return False           
  1148.         EndIf
  1149.         DebugLog "Ok it is a command now to see which one"
  1150.        
  1151.                 Select comcommandtype
  1152.                
  1153.                         Case 6
  1154.                         DebugLog "found "+comcommandname$
  1155.                         ifo.ifbool = New ifbool
  1156.                         ifoool = arguementbool
  1157.                         ifooolexp = comcommandtype
  1158.                         ;arg = After arg
  1159.                        
  1160.                         oldvalue$ = argargvalue$
  1161.                         oldvaluetype$ = argarguementtype$
  1162.                         DebugLog "AFTER AND NEXT OPERATOR IS "+argargnextoperator$
  1163.                        
  1164.                         Case 7
  1165.                         DebugLog "found "+comcommandname$
  1166.                         ifo.ifbool = New ifbool
  1167.                         ifoool = arguementbool
  1168.                         ifooolexp = comcommandtype
  1169.                         ;arg = After arg
  1170.                         oldvalue$ = argargvalue$
  1171.                         oldvaluetype$ = argarguementtype$
  1172.                        
  1173.                         Case 8
  1174.                         DebugLog "found "+comcommandname$
  1175.                         ifo.ifbool = New ifbool
  1176.                         ifoool = arguementbool
  1177.                         ifooolexp = comcommandtype
  1178.                         arg = Null
  1179.                        
  1180.                        
  1181.                        
  1182.                         Default
  1183.                         DebugLog "invalid expression in if statement"
  1184.                         Return False
  1185.                         Exit
  1186.                 End Select
  1187.        
  1188.         End Select
  1189.  
  1190. Until arg = Null
  1191.  
  1192.  
  1193. End Function
  1194.  
  1195.  
  1196. Function killargs()
  1197. For arg.arguement = Each arguement
  1198. Delete arg
  1199.  
  1200. Next
  1201. End Function
  1202.  
  1203. Function killbools()
  1204. For ifo.ifbool = Each ifbool
  1205. Delete ifo
  1206. Next
  1207. End Function
  1208.  
  1209. Function processifbooleans()
  1210. Local ifo.ifbool,ifo2.ifbool,locbool=True
  1211. Local oldifo.ifbool
  1212. ifo2 = First ifbool
  1213. ifo = getifbool(ifo2)
  1214.  
  1215. If ifo = Null Then
  1216. DebugLog "Oh man this must be Stupid to lose the booleans"
  1217. Return False
  1218. EndIf
  1219. oldifo = ifo
  1220. If oldifoool = False Then locbool = False
  1221. Repeat
  1222.  
  1223. oldifo = ifo
  1224. ifo = After ifo
  1225.  
  1226. If ifo = Null Then Return locbool
  1227. If ifo <> Null Then
  1228. Select oldifooolexp
  1229.  
  1230. Case 6
  1231. If ifoool = False locbool = False
  1232.  
  1233. Case 7
  1234. If ifoool = True locbool = True
  1235.  
  1236. Case 8
  1237. Return locbool
  1238.  
  1239. Default
  1240. DebugLog "Expecting Expression"
  1241. Return False
  1242.  
  1243. End Select
  1244.  
  1245. EndIf
  1246.  
  1247. Until oldifooolexp = 8
  1248.  
  1249. Return locbool
  1250.  
  1251. End Function
  1252.  
  1253. Function booloperation(destvar$,sourcevar$,desttype$,sourcetype$,operator$)
  1254. Select operator$
  1255.  
  1256.  Case "="
  1257.         Select desttype$
  1258.        
  1259.         Case "string"
  1260.                 Select sourcetype$
  1261.                
  1262.                         Case "string"
  1263.                                 If destvar$ = sourcevar$ Then
  1264.                                 Return True
  1265.                                 Else
  1266.                                 Return False
  1267.                                 EndIf
  1268.                                
  1269.                         Case "int"
  1270.                                 If destvar$ = sourcevar$ Then
  1271.                                 Return True
  1272.                                 Else
  1273.                                 Return False
  1274.                                 EndIf                  
  1275.                        
  1276.                         Case "float"
  1277.                                 If destvar$ = sourcevar$ Then
  1278.                                 Return True
  1279.                                 Else
  1280.                                 Return False
  1281.                                 EndIf
  1282.                                                
  1283.                         Default
  1284.                         Return False
  1285.                
  1286.                 End Select
  1287.        
  1288.         Case "int"
  1289.                 Select sourcetype$
  1290.                
  1291.                         Case "string"
  1292.                                 If destvar$ = sourcevar$ Then
  1293.                                 Return True
  1294.                                 Else
  1295.                                 Return False
  1296.                                 EndIf
  1297.                                
  1298.                         Case "int"
  1299.                                 If Int(destvar$) = Int(sourcevar$) Then
  1300.                                 Return True
  1301.                                 Else
  1302.                                 Return False
  1303.                                 EndIf                  
  1304.                        
  1305.                         Case "float"
  1306.                                 If Float(destvar$) = Float(sourcevar$) Then
  1307.                                 Return True
  1308.                                 Else
  1309.                                 Return False
  1310.                                 EndIf
  1311.                                                
  1312.                         Default
  1313.                         Return False
  1314.                
  1315.                 End Select
  1316.        
  1317.         Case "float"
  1318.                 Select sourcetype$
  1319.                
  1320.                         Case "string"
  1321.                                 If destvar$ = sourcevar$ Then
  1322.                                 Return True
  1323.                                 Else
  1324.                                 Return False
  1325.                                 EndIf
  1326.                                
  1327.                         Case "int"
  1328.                                 If Float(destvar$) = Float(sourcevar$) Then
  1329.                                 Return True
  1330.                                 Else
  1331.                                 Return False
  1332.                                 EndIf                  
  1333.                        
  1334.                         Case "float"
  1335.                                 If Float(destvar$) = Float(sourcevar$) Then
  1336.                                 Return True
  1337.                                 Else
  1338.                                 Return False
  1339.                                 EndIf
  1340.                                                
  1341.                         Default
  1342.                         Return False
  1343.                
  1344.                 End Select     
  1345.         Default
  1346.         Return False
  1347.  
  1348.         End Select
  1349.  
  1350.  Case ">"
  1351.         Select desttype$
  1352.        
  1353.         Case "string"
  1354.                 Select sourcetype$
  1355.                
  1356.                         Case "string"
  1357.                                 If Len(destvar$) > Len(sourcevar$) Then
  1358.                                 Return True
  1359.                                 Else
  1360.                                 Return False
  1361.                                 EndIf
  1362.                                
  1363.                         Case "int"
  1364.                                 If Int(destvar$) > Int(sourcevar$) Then
  1365.                                 Return True
  1366.                                 Else
  1367.                                 Return False
  1368.                                 EndIf                  
  1369.                        
  1370.                         Case "float"
  1371.                                 If Float(destvar$) > Float(sourcevar$) Then
  1372.                                 Return True
  1373.                                 Else
  1374.                                 Return False
  1375.                                 EndIf
  1376.                                                
  1377.                         Default
  1378.                         Return False
  1379.                
  1380.                 End Select
  1381.        
  1382.         Case "int"
  1383.                 Select sourcetype$
  1384.                
  1385.                         Case "string"
  1386.                                 If Int(destvar$) > Int(sourcevar$) Then
  1387.                                 Return True
  1388.                                 Else
  1389.                                 Return False
  1390.                                 EndIf
  1391.                                
  1392.                         Case "int"
  1393.                                 If Int(destvar$) > Int(sourcevar$) Then
  1394.                                 Return True
  1395.                                 Else
  1396.                                 Return False
  1397.                                 EndIf                  
  1398.                        
  1399.                         Case "float"
  1400.                                 If Float(destvar$) > Float(sourcevar$) Then
  1401.                                 Return True
  1402.                                 Else
  1403.                                 Return False
  1404.                                 EndIf
  1405.                                                
  1406.                         Default
  1407.                         Return False
  1408.                
  1409.                 End Select
  1410.        
  1411.         Case "float"
  1412.                 Select sourcetype$
  1413.                
  1414.                         Case "string"
  1415.                                 If Int(destvar$) > Int(sourcevar$) Then
  1416.                                 Return True
  1417.                                 Else
  1418.                                 Return False
  1419.                                 EndIf
  1420.                                
  1421.                         Case "int"
  1422.                                 If Float(destvar$) > Float(sourcevar$) Then
  1423.                                 Return True
  1424.                                 Else
  1425.                                 Return False
  1426.                                 EndIf                  
  1427.                        
  1428.                         Case "float"
  1429.                                 If Float(destvar$) > Float(sourcevar$) Then
  1430.                                 Return True
  1431.                                 Else
  1432.                                 Return False
  1433.                                 EndIf
  1434.                                                
  1435.                         Default
  1436.                         Return False
  1437.                
  1438.                 End Select     
  1439.         Default
  1440.         Return False
  1441.  
  1442.         End Select
  1443.  
  1444.  Case ">="
  1445.         Select desttype$
  1446.        
  1447.         Case "string"
  1448.                 Select sourcetype$
  1449.                
  1450.                         Case "string"
  1451.                                 If Len(destvar$) >= Len(sourcevar$) Then
  1452.                                 Return True
  1453.                                 Else
  1454.                                 Return False
  1455.                                 EndIf
  1456.                                
  1457.                         Case "int"
  1458.                                 If Int(destvar$) >= Int(sourcevar$) Then
  1459.                                 Return True
  1460.                                 Else
  1461.                                 Return False
  1462.                                 EndIf                  
  1463.                        
  1464.                         Case "float"
  1465.                                 If Float(destvar$) >= Float(sourcevar$) Then
  1466.                                 Return True
  1467.                                 Else
  1468.                                 Return False
  1469.                                 EndIf
  1470.                                                
  1471.                         Default
  1472.                         Return False
  1473.                
  1474.                 End Select
  1475.        
  1476.         Case "int"
  1477.                 Select sourcetype$
  1478.                
  1479.                         Case "string"
  1480.                                 If Int(destvar$) >= Int(sourcevar$) Then
  1481.                                 Return True
  1482.                                 Else
  1483.                                 Return False
  1484.                                 EndIf
  1485.                                
  1486.                         Case "int"
  1487.                                 If Int(destvar$) >= Int(sourcevar$) Then
  1488.                                 Return True
  1489.                                 Else
  1490.                                 Return False
  1491.                                 EndIf                  
  1492.                        
  1493.                         Case "float"
  1494.                                 If Float(destvar$) >= Float(sourcevar$) Then
  1495.                                 Return True
  1496.                                 Else
  1497.                                 Return False
  1498.                                 EndIf
  1499.                                                
  1500.                         Default
  1501.                         Return False
  1502.                
  1503.                 End Select
  1504.        
  1505.         Case "float"
  1506.                 Select sourcetype$
  1507.                
  1508.                         Case "string"
  1509.                                 If Int(destvar$) >= Int(sourcevar$) Then
  1510.                                 Return True
  1511.                                 Else
  1512.                                 Return False
  1513.                                 EndIf
  1514.                                
  1515.                         Case "int"
  1516.                                 If Float(destvar$) >= Float(sourcevar$) Then
  1517.                                 Return True
  1518.                                 Else
  1519.                                 Return False
  1520.                                 EndIf                  
  1521.                        
  1522.                         Case "float"
  1523.                                 If Float(destvar$) >= Float(sourcevar$) Then
  1524.                                 Return True
  1525.                                 Else
  1526.                                 Return False
  1527.                                 EndIf
  1528.                                                
  1529.                         Default
  1530.                         Return False
  1531.                
  1532.                 End Select     
  1533.         Default
  1534.         Return False
  1535.  
  1536.         End Select
  1537.  
  1538.  Case "<"
  1539.         Select desttype$
  1540.        
  1541.         Case "string"
  1542.                 Select sourcetype$
  1543.                
  1544.                         Case "string"
  1545.                                 If Len(destvar$) < Len(sourcevar$) Then
  1546.                                 Return True
  1547.                                 Else
  1548.                                 Return False
  1549.                                 EndIf
  1550.                                
  1551.                         Case "int"
  1552.                                 If Int(destvar$) < Int(sourcevar$) Then
  1553.                                 Return True
  1554.                                 Else
  1555.                                 Return False
  1556.                                 EndIf                  
  1557.                        
  1558.                         Case "float"
  1559.                                 If Float(destvar$) < Float(sourcevar$) Then
  1560.                                 Return True
  1561.                                 Else
  1562.                                 Return False
  1563.                                 EndIf
  1564.                                                
  1565.                         Default
  1566.                         Return False
  1567.                
  1568.                 End Select
  1569.        
  1570.         Case "int"
  1571.                 Select sourcetype$
  1572.                
  1573.                         Case "string"
  1574.                                 If Int(destvar$) < Int(sourcevar$) Then
  1575.                                 Return True
  1576.                                 Else
  1577.                                 Return False
  1578.                                 EndIf
  1579.                                
  1580.                         Case "int"
  1581.                                 If Int(destvar$) < Int(sourcevar$) Then
  1582.                                 Return True
  1583.                                 Else
  1584.                                 Return False
  1585.                                 EndIf                  
  1586.                        
  1587.                         Case "float"
  1588.                                 If Float(destvar$) < Float(sourcevar$) Then
  1589.                                 Return True
  1590.                                 Else
  1591.                                 Return False
  1592.                                 EndIf
  1593.                                                
  1594.                         Default
  1595.                         Return False
  1596.                
  1597.                 End Select
  1598.        
  1599.         Case "float"
  1600.                 Select sourcetype$
  1601.                
  1602.                         Case "string"
  1603.                                 If Int(destvar$) < Int(sourcevar$) Then
  1604.                                 Return True
  1605.                                 Else
  1606.                                 Return False
  1607.                                 EndIf
  1608.                                
  1609.                         Case "int"
  1610.                                 If Float(destvar$) < Float(sourcevar$) Then
  1611.                                 Return True
  1612.                                 Else
  1613.                                 Return False
  1614.                                 EndIf                  
  1615.                        
  1616.                         Case "float"
  1617.                                 If Float(destvar$) < Float(sourcevar$) Then
  1618.                                 Return True
  1619.                                 Else
  1620.                                 Return False
  1621.                                 EndIf
  1622.                                                
  1623.                         Default
  1624.                         Return False
  1625.                
  1626.                 End Select     
  1627.         Default
  1628.         Return False
  1629.  
  1630.         End Select
  1631.  
  1632.  Case "<="
  1633.         Select desttype$
  1634.        
  1635.         Case "string"
  1636.                 Select sourcetype$
  1637.                
  1638.                         Case "string"
  1639.                                 If Len(destvar$) <= Len(sourcevar$) Then
  1640.                                 Return True
  1641.                                 Else
  1642.                                 Return False
  1643.                                 EndIf
  1644.                                
  1645.                         Case "int"
  1646.                                 If Int(destvar$) <= Int(sourcevar$) Then
  1647.                                 Return True
  1648.                                 Else
  1649.                                 Return False
  1650.                                 EndIf                  
  1651.                        
  1652.                         Case "float"
  1653.                                 If Float(destvar$) <= Float(sourcevar$) Then
  1654.                                 Return True
  1655.                                 Else
  1656.                                 Return False
  1657.                                 EndIf
  1658.                                                
  1659.                         Default
  1660.                         Return False
  1661.                
  1662.                 End Select
  1663.        
  1664.         Case "int"
  1665.                 Select sourcetype$
  1666.                
  1667.                         Case "string"
  1668.                                 If Int(destvar$) <= Int(sourcevar$) Then
  1669.                                 Return True
  1670.                                 Else
  1671.                                 Return False
  1672.                                 EndIf
  1673.                                
  1674.                         Case "int"
  1675.                                 If Int(destvar$) <= Int(sourcevar$) Then
  1676.                                 Return True
  1677.                                 Else
  1678.                                 Return False
  1679.                                 EndIf                  
  1680.                        
  1681.                         Case "float"
  1682.                                 If Float(destvar$) <= Float(sourcevar$) Then
  1683.                                 Return True
  1684.                                 Else
  1685.                                 Return False
  1686.                                 EndIf
  1687.                                                
  1688.                         Default
  1689.                         Return False
  1690.                
  1691.                 End Select
  1692.        
  1693.         Case "float"
  1694.                 Select sourcetype$
  1695.                
  1696.                         Case "string"
  1697.                                 If Int(destvar$) <= Int(sourcevar$) Then
  1698.                                 Return True
  1699.                                 Else
  1700.                                 Return False
  1701.                                 EndIf
  1702.                                
  1703.                         Case "int"
  1704.                                 If Float(destvar$) <= Float(sourcevar$) Then
  1705.                                 Return True
  1706.                                 Else
  1707.                                 Return False
  1708.                                 EndIf                  
  1709.                        
  1710.                         Case "float"
  1711.                                 If Float(destvar$) <= Float(sourcevar$) Then
  1712.                                 Return True
  1713.                                 Else
  1714.                                 Return False
  1715.                                 EndIf
  1716.                                                
  1717.                         Default
  1718.                         Return False
  1719.                
  1720.                 End Select     
  1721.         Default
  1722.         Return False
  1723.  
  1724.         End Select
  1725.  
  1726.  Case "<>"
  1727.         Select desttype$
  1728.        
  1729.         Case "string"
  1730.                 Select sourcetype$
  1731.                
  1732.                         Case "string"
  1733.                                 If Len(destvar$) <> Len(sourcevar$) Then
  1734.                                 Return True
  1735.                                 Else
  1736.                                 Return False
  1737.                                 EndIf
  1738.                                
  1739.                         Case "int"
  1740.                                 If Int(destvar$) <> Int(sourcevar$) Then
  1741.                                 Return True
  1742.                                 Else
  1743.                                 Return False
  1744.                                 EndIf                  
  1745.                        
  1746.                         Case "float"
  1747.                                 If Float(destvar$) <> Float(sourcevar$) Then
  1748.                                 Return True
  1749.                                 Else
  1750.                                 Return False
  1751.                                 EndIf
  1752.                                                
  1753.                         Default
  1754.                         Return False
  1755.                
  1756.                 End Select
  1757.        
  1758.         Case "int"
  1759.                 Select sourcetype$
  1760.                
  1761.                         Case "string"
  1762.                                 If Int(destvar$) <> Int(sourcevar$) Then
  1763.                                 Return True
  1764.                                 Else
  1765.                                 Return False
  1766.                                 EndIf
  1767.                                
  1768.                         Case "int"
  1769.                                 If Int(destvar$) <> Int(sourcevar$) Then
  1770.                                 Return True
  1771.                                 Else
  1772.                                 Return False
  1773.                                 EndIf                  
  1774.                        
  1775.                         Case "float"
  1776.                                 If Float(destvar$) <> Float(sourcevar$) Then
  1777.                                 Return True
  1778.                                 Else
  1779.                                 Return False
  1780.                                 EndIf
  1781.                                                
  1782.                         Default
  1783.                         Return False
  1784.                
  1785.                 End Select
  1786.        
  1787.         Case "float"
  1788.                 Select sourcetype$
  1789.                
  1790.                         Case "string"
  1791.                                 If Int(destvar$) <> Int(sourcevar$) Then
  1792.                                 Return True
  1793.                                 Else
  1794.                                 Return False
  1795.                                 EndIf
  1796.                                
  1797.                         Case "int"
  1798.                                 If Float(destvar$) <> Float(sourcevar$) Then
  1799.                                 Return True
  1800.                                 Else
  1801.                                 Return False
  1802.                                 EndIf                  
  1803.                        
  1804.                         Case "float"
  1805.                                 If Float(destvar$) <> Float(sourcevar$) Then
  1806.                                 Return True
  1807.                                 Else
  1808.                                 Return False
  1809.                                 EndIf
  1810.                                                
  1811.                         Default
  1812.                         Return False
  1813.                
  1814.                 End Select     
  1815.         Default
  1816.         Return False
  1817.  
  1818.         End Select
  1819.  
  1820.  Case "><"
  1821.         Select desttype$
  1822.        
  1823.         Case "string"
  1824.                 Select sourcetype$
  1825.                
  1826.                         Case "string"
  1827.                                 If Len(destvar$) <> Len(sourcevar$) Then
  1828.                                 Return True
  1829.                                 Else
  1830.                                 Return False
  1831.                                 EndIf
  1832.                                
  1833.                         Case "int"
  1834.                                 If Int(destvar$) <> Int(sourcevar$) Then
  1835.                                 Return True
  1836.                                 Else
  1837.                                 Return False
  1838.                                 EndIf                  
  1839.                        
  1840.                         Case "float"
  1841.                                 If Float(destvar$) <> Float(sourcevar$) Then
  1842.                                 Return True
  1843.                                 Else
  1844.                                 Return False
  1845.                                 EndIf
  1846.                                                
  1847.                         Default
  1848.                         Return False
  1849.                
  1850.                 End Select
  1851.        
  1852.         Case "int"
  1853.                 Select sourcetype$
  1854.                
  1855.                         Case "string"
  1856.                                 If Int(destvar$) <> Int(sourcevar$) Then
  1857.                                 Return True
  1858.                                 Else
  1859.                                 Return False
  1860.                                 EndIf
  1861.                                
  1862.                         Case "int"
  1863.                                 If Int(destvar$) <> Int(sourcevar$) Then
  1864.                                 Return True
  1865.                                 Else
  1866.                                 Return False
  1867.                                 EndIf                  
  1868.                        
  1869.                         Case "float"
  1870.                                 If Float(destvar$) <> Float(sourcevar$) Then
  1871.                                 Return True
  1872.                                 Else
  1873.                                 Return False
  1874.                                 EndIf
  1875.                                                
  1876.                         Default
  1877.                         Return False
  1878.                
  1879.                 End Select
  1880.        
  1881.         Case "float"
  1882.                 Select sourcetype$
  1883.                
  1884.                         Case "string"
  1885.                                 If Int(destvar$) <> Int(sourcevar$) Then
  1886.                                 Return True
  1887.                                 Else
  1888.                                 Return False
  1889.                                 EndIf
  1890.                                
  1891.                         Case "int"
  1892.                                 If Float(destvar$) <> Float(sourcevar$) Then
  1893.                                 Return True
  1894.                                 Else
  1895.                                 Return False
  1896.                                 EndIf                  
  1897.                        
  1898.                         Case "float"
  1899.                                 If Float(destvar$) <> Float(sourcevar$) Then
  1900.                                 Return True
  1901.                                 Else
  1902.                                 Return False
  1903.                                 EndIf
  1904.                                                
  1905.                         Default
  1906.                         Return False
  1907.                
  1908.                 End Select     
  1909.         Default
  1910.         Return False
  1911.  
  1912.         End Select
  1913.  
  1914.  
  1915.  Default
  1916.  Return False
  1917.  
  1918.  
  1919.  
  1920.  
  1921. End Select
  1922. End Function
  1923.  
  1924. Function mathoperation$(destvar$,sourcevar$,desttype$,sourcetype$,operator$)
  1925.  
  1926. Select operator$
  1927.  
  1928.         Case "+"
  1929.                 Select sourcetype$
  1930.                        
  1931.                         Case "string"
  1932.                                 Select desttype$
  1933.                                
  1934.                                         Case "string"
  1935.                                         destvar$ = destvar$ + sourcevar$
  1936.                                         Return destvar$
  1937.                                        
  1938.                                         Case "int"
  1939.                                         destvar$ = destvar$ + sourcevar$
  1940.                                         Return destvar$
  1941.                                        
  1942.                                         Case "float"
  1943.                                         destvar$ = destvar$ + sourcevar$
  1944.                                         Return destvar$
  1945.                                        
  1946.                                         Default
  1947.                                         Return ""
  1948.                                
  1949.                                 End Select
  1950.                        
  1951.                         Case "int"
  1952.                                 Select desttype$
  1953.                                
  1954.                                         Case "string"
  1955.                                         destvar$ = destvar$ + Int(sourcevar$)
  1956.                                         Return destvar$
  1957.                                        
  1958.                                         Case "int"
  1959.                                         destvar$ = Int(destvar$) + Int(sourcevar$)
  1960.                                         Return destvar$
  1961.                                        
  1962.                                         Case "float"
  1963.                                         destvar$ = Float(destvar$) + Int(sourcevar$)
  1964.                                         Return destvar$
  1965.                                        
  1966.                                         Default
  1967.                                         Return ""
  1968.                                
  1969.                                 End Select                     
  1970.                         Case "float"
  1971.                                 Select desttype$
  1972.                                
  1973.                                         Case "string"
  1974.                                         destvar$ = destvar$ + Float(sourcevar$)
  1975.                                         Return destvar$
  1976.                                        
  1977.                                         Case "int"
  1978.                                         destvar$ = Int(destvar$) + Float(sourcevar$)
  1979.                                         Return destvar$
  1980.                                        
  1981.                                         Case "float"
  1982.                                         destvar$ = Float(destvar$) + Float(sourcevar$)
  1983.                                         Return destvar$
  1984.                                        
  1985.                                         Default
  1986.                                         Return ""
  1987.                                
  1988.                                 End Select                     
  1989.                         Default
  1990.                         Return ""
  1991.                
  1992.                 End Select
  1993.        
  1994.        
  1995.         Case "-"
  1996.                 Select sourcetype$
  1997.                        
  1998.                         Case "string"
  1999.                                 Select desttype$
  2000.                                
  2001.                                         Case "string"
  2002.                                         destvar$ = Replace(destvar$,sourcevar$,1)
  2003.                                         Return destvar$
  2004.                                        
  2005.                                         Case "int"
  2006.                                         destvar$ = Replace(destvar$,sourcevar$,1)
  2007.                                         Return destvar$
  2008.                                        
  2009.                                         Case "float"
  2010.                                         destvar$ = Replace(destvar$,sourcevar$,1)
  2011.                                         Return destvar$
  2012.                                        
  2013.                                         Default
  2014.                                         Return ""
  2015.                                
  2016.                                 End Select
  2017.                        
  2018.                         Case "int"
  2019.                                 Select desttype$
  2020.                                
  2021.                                         Case "string"
  2022.                                         destvar$ = Replace(destvar$,sourcevar$,1)
  2023.                                         Return destvar$
  2024.                                        
  2025.                                         Case "int"
  2026.                                         destvar$ = Int(destvar$) - Int(sourcevar$)
  2027.                                         Return destvar$
  2028.                                        
  2029.                                         Case "float"
  2030.                                         destvar$ = Float(destvar$) - Int(sourcevar$)
  2031.                                         Return destvar$
  2032.                                        
  2033.                                         Default
  2034.                                         Return ""
  2035.                                
  2036.                                 End Select                     
  2037.                         Case "float"
  2038.                                 Select desttype$
  2039.                                
  2040.                                         Case "string"
  2041.                                         destvar$ = Replace(destvar$,sourcevar$,1)
  2042.                                         Return destvar$
  2043.                                        
  2044.                                         Case "int"
  2045.                                         destvar$ = Int(destvar$) - Float(sourcevar$)
  2046.                                         Return destvar$
  2047.                                        
  2048.                                         Case "float"
  2049.                                         destvar$ = Float(destvar$) - Float(sourcevar$)
  2050.                                         Return destvar$
  2051.                                        
  2052.                                         Default
  2053.                                         Return ""
  2054.                                
  2055.                                 End Select                     
  2056.                         Default
  2057.                         Return ""
  2058.                
  2059.                 End Select     
  2060.         Case "/"
  2061.                 Select sourcetype$
  2062.                        
  2063.                         Case "string"
  2064.                                 Select desttype$
  2065.                                
  2066.                                         Case "string"
  2067.                                         Return destvar$
  2068.                                        
  2069.                                         Case "int"
  2070.                                         Return destvar$
  2071.                                        
  2072.                                         Case "float"
  2073.                                         Return destvar$
  2074.                                        
  2075.                                         Default
  2076.                                         Return ""
  2077.                                
  2078.                                 End Select
  2079.                        
  2080.                         Case "int"
  2081.                                 Select desttype$
  2082.                                
  2083.                                         Case "string"
  2084.                                         Return destvar$
  2085.                                        
  2086.                                         Case "int"
  2087.                                         destvar$ = Int(destvar$) / Int(sourcevar$)
  2088.                                         Return destvar$
  2089.                                        
  2090.                                         Case "float"
  2091.                                         destvar$ = Float(destvar$) / Int(sourcevar$)
  2092.                                         Return destvar$
  2093.                                        
  2094.                                         Default
  2095.                                         Return ""
  2096.                                
  2097.                                 End Select                     
  2098.                         Case "float"
  2099.                                 Select desttype$
  2100.                                
  2101.                                         Case "string"
  2102.                                         Return destvar$
  2103.                                        
  2104.                                         Case "int"
  2105.                                         destvar$ = Int(destvar$) / Float(sourcevar$)
  2106.                                         Return destvar$
  2107.                                        
  2108.                                         Case "float"
  2109.                                         destvar$ = Float(destvar$) / Float(sourcevar$)
  2110.                                         Return destvar$
  2111.                                        
  2112.                                         Default
  2113.                                         Return ""
  2114.                                
  2115.                                 End Select                     
  2116.                         Default
  2117.                         Return ""
  2118.                
  2119.                 End Select
  2120.        
  2121.         Case "*"
  2122.                 Select sourcetype$
  2123.                        
  2124.                         Case "string"
  2125.                                 Select desttype$
  2126.                                
  2127.                                         Case "string"
  2128.                                         Return destvar$
  2129.                                        
  2130.                                         Case "int"
  2131.                                         Return destvar$
  2132.                                        
  2133.                                         Case "float"
  2134.                                         Return destvar$
  2135.                                        
  2136.                                         Default
  2137.                                         Return ""
  2138.                                
  2139.                                 End Select
  2140.                        
  2141.                         Case "int"
  2142.                                 Select desttype$
  2143.                                
  2144.                                         Case "string"
  2145.                                         Return destvar$
  2146.                                        
  2147.                                         Case "int"
  2148.                                         destvar$ = Int(destvar$) * Int(sourcevar$)
  2149.                                         Return destvar$
  2150.                                        
  2151.                                         Case "float"
  2152.                                         destvar$ = Float(destvar$) * Int(sourcevar$)
  2153.                                         Return destvar$
  2154.                                        
  2155.                                         Default
  2156.                                         Return ""
  2157.                                
  2158.                                 End Select                     
  2159.                         Case "float"
  2160.                                 Select desttype$
  2161.                                
  2162.                                         Case "string"
  2163.                                         Return destvar$
  2164.                                        
  2165.                                         Case "int"
  2166.                                         destvar$ = Int(destvar$) * Float(sourcevar$)
  2167.                                         Return destvar$
  2168.                                        
  2169.                                         Case "float"
  2170.                                         destvar$ = Float(destvar$) * Float(sourcevar$)
  2171.                                         Return destvar$
  2172.                                        
  2173.                                         Default
  2174.                                         Return ""
  2175.                                
  2176.                                 End Select                     
  2177.                         Default
  2178.                         Return ""
  2179.                
  2180.                 End Select
  2181.        
  2182.         Default
  2183.         Return ""
  2184.  
  2185. End Select
  2186.  
  2187. End Function
  2188.  
  2189.  
  2190. Function validateoperator(Data1$)
  2191. Local validated = False
  2192. Local expect = 0
  2193.  
  2194. If Instr(OPERATORS$,Data1$,1) <> 0 Then
  2195. Select Data1$
  2196.  Case "="
  2197.  Return 2
  2198.  
  2199.  Case ">"
  2200.  Return 2
  2201.  
  2202.  Case ">="
  2203.  Return 2
  2204.  
  2205.  Case "<"
  2206.  Return 2
  2207.  
  2208.  Case "<="
  2209.  Return 2
  2210.  
  2211.  Case "<>"
  2212.  Return 2
  2213.  
  2214.  Case "><"
  2215.  Return 2
  2216.  
  2217.  Default
  2218.  Return 1
  2219.  
  2220. End Select
  2221. Else
  2222. Return 0
  2223. EndIf
  2224.  
  2225. End Function
  2226.  
  2227.  
  2228. Function checkarg.arguement(Data1$)
  2229.  
  2230. If Instr(Data1$,";",1) <> 0 Then
  2231. arg.arguement = New arguement
  2232. argarguementtype$ = "string"
  2233. argargvalue$ = Replace(Data1$,";","")
  2234. Return arg
  2235. EndIf
  2236.  
  2237. If Instr(Data1$,"",1) <> 0 Then
  2238. arg.arguement = New arguement
  2239. argarguementtype$ = "float"
  2240. argargvalue$ = Data1$
  2241. Return arg
  2242. EndIf
  2243.  
  2244. arg.arguement = New arguement
  2245. argarguementtype$ = "int"
  2246. argargvalue$ = Data1$
  2247. Return arg
  2248.  
  2249.  
  2250.  
  2251.  
  2252. End Function
  2253.  
  2254. Function assignvar.dtokens(tok.dtokens)
  2255. Local olddec.declare,oldtok.dtokens,com.commands
  2256. Local dec.declare = finddeclaration.declare(tok)
  2257. oldtok = tok
  2258. DebugLog "assinging var data to "+tokdname$
  2259. tok = After tok
  2260.  
  2261. If tok = Null Then
  2262.         DebugLog "may possibly be just a function"
  2263.         If decdtype$ = "function" Then
  2264.         DebugLog "found function running script"
  2265.         tok = Before tok
  2266.         tok = runfunction(tok)
  2267.         Return tok
  2268.         Else
  2269.         DebugLog "Unexprected end of file"
  2270.         Return Null
  2271.         EndIf
  2272. EndIf
  2273.  
  2274. DebugLog oldtokdname$
  2275. DebugLog "next field after "+oldtokdname$+" is "+tokdname$
  2276. If tokdname$ = "=" Then
  2277. DebugLog "found ="
  2278. olddec = dec
  2279.  
  2280. Select olddecdtype$
  2281.  
  2282. Case "int"
  2283.  
  2284. Repeat
  2285.  
  2286. tok = After tok
  2287. If toklline = oldtoklline Then
  2288.  
  2289.                 DebugLog "found integer next "+tokdname$
  2290.                 Select tokdname$
  2291.                
  2292.                
  2293.                 Case "+"
  2294.                 tok = After tok
  2295.                 dec = finddeclaration.declare(tok)
  2296.                 If dec = Null Then
  2297.                 com = checkcommands(tok okentype)
  2298.                 If com <> Null Then
  2299.                
  2300.                 Select comcommandtype
  2301.                
  2302.                 Case 0
  2303.                 olddecddata$ = Int(olddecddata$)+Int(tokdname$)
  2304.                 DebugLog olddecdname$+" int = "+olddecddata$
  2305.                
  2306.                
  2307.                 Case 25
  2308.                 olddecddata$ = Int(olddecddata$) + Int(callvariable$(tok))
  2309.                 tok = After tok
  2310.                 tok = After tok
  2311.                
  2312.                 DebugLog olddecdname$+" int = "+olddecddata$
  2313.                
  2314.                 End Select
  2315.                
  2316.                 EndIf
  2317.                 Else
  2318.                 olddecddata$ = Int(olddecddata$)+Int(decddata$)
  2319.                 DebugLog olddecdname$+" int = "+olddecddata$
  2320.                 EndIf
  2321.                
  2322.                 Case "-"
  2323.                 tok = After tok
  2324.                 dec = finddeclaration.declare(tok)
  2325.                 If dec = Null Then
  2326.                 com = checkcommands(tok okentype)
  2327.                 If com <> Null Then
  2328.                
  2329.                 Select comcommandtype
  2330.                
  2331.                 Case 0
  2332.                 olddecddata$ = Int(olddecddata$)-Int(tokdname$)
  2333.                 DebugLog olddecdname$+" int = "+olddecddata$
  2334.                
  2335.                
  2336.                 Case 25
  2337.                 olddecddata$ = Int(olddecddata$) - Int(callvariable$(tok))
  2338.                 DebugLog olddecdname$+" int = "+olddecddata$
  2339.                 tok = After tok
  2340.                 tok = After tok
  2341.                
  2342.                 End Select
  2343.                 EndIf
  2344.                 Else
  2345.                 olddecddata$ = Int(olddecddata$)-Int(decddata$)
  2346.                 EndIf
  2347.                
  2348.                 Case "*"
  2349.                 tok = After tok
  2350.                 dec = finddeclaration.declare(tok)
  2351.                 If dec = Null Then
  2352.                                 com = checkcommands(tok okentype)
  2353.                 If com <> Null Then
  2354.                
  2355.                 Select comcommandtype
  2356.                
  2357.                 Case 0
  2358.                 olddecddata$ = Int(olddecddata$)*Int(tokdname$)
  2359.                 DebugLog olddecdname$+" int = "+olddecddata$
  2360.                
  2361.                
  2362.                 Case 25
  2363.                 olddecddata$ = Int(olddecddata$) * Int(callvariable$(tok))
  2364.                 DebugLog olddecdname$+" int = "+olddecddata$
  2365.                 tok = After tok
  2366.                 tok = After tok
  2367.                
  2368.                 End Select
  2369.                 EndIf
  2370.                 Else
  2371.                 olddecddata$ = Int(olddecddata$)*Int(decddata$)
  2372.                 EndIf
  2373.                
  2374.                 Case "/"
  2375.                 tok = After tok
  2376.                 dec = finddeclaration.declare(tok)
  2377.                 If dec = Null Then
  2378.                 com = checkcommands(tok okentype)
  2379.                 If com <> Null Then
  2380.                
  2381.                 Select comcommandtype
  2382.                
  2383.                 Case 0
  2384.                 olddecddata$ = Int(olddecddata$)/Int(tokdname$)
  2385.                 DebugLog olddecdname$+" int = "+olddecddata$
  2386.                
  2387.                
  2388.                 Case 25
  2389.                 olddecddata$ = Int(olddecddata$) / Int(callvariable$(tok))
  2390.                 DebugLog olddecdname$+" int = "+olddecddata$
  2391.                 tok = After tok
  2392.                 tok = After tok
  2393.                
  2394.                 End Select      
  2395.                 EndIf  
  2396.                 Else
  2397.                 olddecddata$ = Int(olddecddata$)/Int(decddata$)
  2398.                 EndIf
  2399.                
  2400.                 Default
  2401.                 DebugLog "found numerical expression of "+tokdname$
  2402.                 dec = finddeclaration.declare(tok)
  2403.                 If dec = Null Then
  2404.                 com = checkcommands(tok okentype)
  2405.                 If com <> Null Then
  2406.                
  2407.                 Select comcommandtype
  2408.                
  2409.                 Case 0
  2410.                 olddecddata$ = Int(tokdname$)
  2411.                 DebugLog olddecdname$+" int = "+olddecddata$
  2412.                
  2413.                
  2414.                 Case 25
  2415.                 olddecddata$ = Int(callvariable$(tok))
  2416.                 DebugLog olddecdname$+" int = "+olddecddata$
  2417.                 tok = After tok
  2418.                 tok = After tok
  2419.                
  2420.                 End Select             
  2421.                 EndIf          
  2422.                 DebugLog olddecdname$+" int = "+olddecddata$
  2423.                 Else
  2424.                 olddecddata$ = Int(decddata$)
  2425.                 DebugLog olddecdname$+" int = "+olddecddata$
  2426.                
  2427.                 EndIf
  2428.                
  2429.                 End Select
  2430. EndIf
  2431. Until toklline > oldtoklline
  2432.  
  2433.  
  2434. Case "float"
  2435. Repeat
  2436. tok = After tok
  2437. If toklline = oldtoklline Then
  2438.  
  2439.                 Select tokdname$
  2440.                
  2441.                
  2442.                 Case "+"
  2443.                 tok = After tok
  2444.                 dec = finddeclaration.declare(tok)
  2445.                 If dec = Null Then
  2446.                 com = checkcommands(tok okentype)
  2447.                 If com <> Null Then
  2448.                
  2449.                 Select comcommandtype
  2450.                
  2451.                 Case 0
  2452.                 olddecddata$ = Float(olddecddata$)+Float(tokdname$)
  2453.                 DebugLog olddecdname$+" int = "+olddecddata$
  2454.                
  2455.                
  2456.                 Case 25
  2457.                 olddecddata$ = Float(olddecddata$) + Float(callvariable$(tok))
  2458.                 DebugLog olddecdname$+" int = "+olddecddata$
  2459.                 tok = After tok
  2460.                 tok = After tok
  2461.                
  2462.                 End Select             
  2463.                 EndIf
  2464.                 Else
  2465.                 olddecddata$ = Float(olddecddata$)+Float(decddata$)
  2466.                 EndIf
  2467.                
  2468.                 Case "-"
  2469.                 tok = After tok
  2470.                 dec = finddeclaration.declare(tok)
  2471.                 If dec = Null Then
  2472.                 com = checkcommands(tok okentype)
  2473.                 If com <> Null Then
  2474.                
  2475.                 Select comcommandtype
  2476.                
  2477.                 Case 0
  2478.                 olddecddata$ = Float(olddecddata$)-Float(tokdname$)
  2479.                 DebugLog olddecdname$+" int = "+olddecddata$
  2480.                
  2481.                
  2482.                 Case 25
  2483.                 olddecddata$ = Float(olddecddata$) - Float(callvariable$(tok))
  2484.                 DebugLog olddecdname$+" int = "+olddecddata$
  2485.                 tok = After tok
  2486.                 tok = After tok
  2487.                
  2488.                 End Select             
  2489.                 EndIf
  2490.                 Else
  2491.                 olddecddata$ = Float(olddecddata$)-Float(decddata$)
  2492.                 EndIf
  2493.                
  2494.                 Case "*"
  2495.                 tok = After tok
  2496.                 dec = finddeclaration.declare(tok)
  2497.                 If dec = Null Then
  2498.                 com = checkcommands(tok okentype)
  2499.                 If com <> Null Then
  2500.                
  2501.                 Select comcommandtype
  2502.                
  2503.                 Case 0
  2504.                 olddecddata$ = Float(olddecddata$)*Float(tokdname$)
  2505.                 DebugLog olddecdname$+" int = "+olddecddata$
  2506.                
  2507.                
  2508.                 Case 25
  2509.                 olddecddata$ = Float(olddecddata$) * Float(callvariable$(tok))
  2510.                 DebugLog olddecdname$+" int = "+olddecddata$
  2511.                 tok = After tok
  2512.                 tok = After tok
  2513.                
  2514.                 End Select             
  2515.                 EndIf
  2516.                 Else
  2517.                 olddecddata$ = Float(olddecddata$)*Float(decddata$)
  2518.                 EndIf
  2519.                
  2520.                 Case "/"
  2521.                 tok = After tok
  2522.                 dec = finddeclaration.declare(tok)
  2523.                 If dec = Null Then
  2524.                 com = checkcommands(tok okentype)
  2525.                 If com <> Null Then
  2526.                
  2527.                 Select comcommandtype
  2528.                
  2529.                 Case 0
  2530.                 olddecddata$ = Float(olddecddata$)/Float(tokdname$)
  2531.                 DebugLog olddecdname$+" int = "+olddecddata$
  2532.                
  2533.                
  2534.                 Case 25
  2535.                 olddecddata$ = Float(olddecddata$) / Float(callvariable$(tok))
  2536.                 DebugLog olddecdname$+" int = "+olddecddata$
  2537.                 tok = After tok
  2538.                 tok = After tok
  2539.                
  2540.                 End Select             
  2541.                 EndIf
  2542.                 Else
  2543.                 olddecddata$ = Float(olddecddata$)/Float(decddata$)
  2544.                 EndIf
  2545.                
  2546.                 Default
  2547.                 dec = finddeclaration.declare(tok)
  2548.                 If dec = Null Then
  2549.                 com = checkcommands(tok okentype)
  2550.                 If com <> Null Then
  2551.                
  2552.                 Select comcommandtype
  2553.                
  2554.                 Case 0
  2555.                 olddecddata$ = Int(tokdname$)
  2556.                 DebugLog olddecdname$+" int = "+olddecddata$
  2557.                
  2558.                
  2559.                 Case 25
  2560.                 olddecddata$ = Int(callvariable$(tok))
  2561.                 DebugLog olddecdname$+" int = "+olddecddata$
  2562.                 tok = After tok
  2563.                 tok = After tok
  2564.                
  2565.                 End Select             
  2566.                 EndIf          
  2567.                 Else
  2568.                 olddecddata$ = Float(decddata$)
  2569.                 EndIf
  2570.                 End Select
  2571. EndIf
  2572. Until toklline > oldtoklline
  2573.  
  2574.  
  2575. Case "string"
  2576. DebugLog "assinging string data to "+olddecdname$
  2577. Repeat
  2578. tok = After tok
  2579. DebugLog tokdname$+" line is "+toklline+" "+oldtokdname$+" line is "+oldtoklline
  2580. If toklline = oldtoklline Then
  2581.                 Select tokdname$
  2582.                
  2583.                
  2584.                 Case "+"
  2585.                 tok = After tok
  2586.                 dec = finddeclaration.declare(tok)
  2587.                 If dec = Null Then
  2588.                 com = checkcommands(tok okentype)
  2589.                 If com <> Null Then
  2590.                
  2591.                 Select comcommandtype
  2592.                
  2593.                 Case 0
  2594.                 olddecddata$ = olddecddata$ + tokdname$
  2595.                 DebugLog olddecdname$+" int = "+olddecddata$
  2596.                
  2597.                
  2598.                 Case 25
  2599.                 olddecddata$ = olddecddata$ + callvariable$(tok)
  2600.                 DebugLog olddecdname$+" int = "+olddecddata$
  2601.                 tok = After tok
  2602.                 tok = After tok
  2603.                
  2604.                 End Select             
  2605.                 EndIf
  2606.                 Else
  2607.                 olddecddata$ = olddecddata$+decddata$
  2608.                 EndIf
  2609.                 olddecddata$ = Replace(olddecddata$,";","")
  2610.                
  2611.                 Default
  2612.                 dec = finddeclaration.declare(tok)
  2613.                 If dec = Null Then
  2614.                 com = checkcommands(tok okentype)
  2615.                 If com <> Null Then
  2616.                
  2617.                 Select comcommandtype
  2618.                
  2619.                 Case 0
  2620.                 olddecddata$ = tokdname$
  2621.                 DebugLog olddecdname$+" int = "+olddecddata$
  2622.                
  2623.                
  2624.                 Case 25
  2625.                 olddecddata$ = callvariable$(tok)
  2626.                 DebugLog olddecdname$+" int = "+olddecddata$
  2627.                 tok = After tok
  2628.                 tok = After tok
  2629.                
  2630.                 End Select             
  2631.                 EndIf
  2632.                 Else
  2633.                 olddecddata$ = decddata$
  2634.                 EndIf
  2635.                 olddecddata$ = Replace(olddecddata$,";","")
  2636.                 DebugLog olddecddata$
  2637.                 End Select
  2638. EndIf
  2639. Until toklline > oldtoklline
  2640.  
  2641.  
  2642. End Select
  2643. DebugLog "next item is "+tokdname$
  2644. Return Before tok
  2645. Else
  2646. If decdtype$ = "function" Then
  2647. DebugLog "found function running script"
  2648. tok = Before tok
  2649. tok = runfunction(tok)
  2650. Return tok
  2651. Else
  2652. DebugLog "expecting operator"
  2653. Return Null
  2654. EndIf
  2655. EndIf
  2656.  
  2657. End Function
  2658.  
  2659. Function declarevar.dtokens(tok.dtokens)
  2660. Local oldtok.dtokens
  2661. dec.declare = New declare
  2662. tok = After tok
  2663. If tok = Null Then
  2664. DebugLog "Expecting VAR type"
  2665. Return Null
  2666. EndIf
  2667. decdtype$ = tokdname$
  2668. decparentscrpt = tokparentscrpt
  2669. tok = After tok
  2670. If tok = Null Then
  2671. DebugLog "Expecting Var Name"
  2672. Return
  2673. EndIf
  2674. decdname$ = tokdname$
  2675.  
  2676. oldtok = tok
  2677. If decdtype$ = "function" Then
  2678. addfunctiontokens(dec,tok)
  2679. DebugLog "added new function "+decdname$
  2680. EndIf
  2681.  
  2682. DebugLog "Found Variable type "+decdtype$+" var name "+decdname$
  2683. Return tok
  2684. End Function
  2685.  
  2686.  
  2687. Function addfunctiontokens(dec.declare,tok.dtokens)
  2688. Local fok.ftokens
  2689. Local killtok.dtokens
  2690. tok = findfunction(dec,tok)
  2691.  
  2692. killtok = tok
  2693.  
  2694. tok = After tok
  2695. DebugLog "about to kill token "+killtokdname$
  2696. Delete killtok
  2697.  
  2698.  
  2699.  
  2700. Repeat
  2701.  
  2702. fok.ftokens = New ftokens
  2703. fokdname$ = tokdname$
  2704. fokindex = tokindex
  2705. foklline = toklline
  2706. fok     okentype = tok  okentype
  2707. fokparentfunction = dec
  2708. fokparentscrpt = tokparentscrpt
  2709. killtok = tok
  2710. tok = After tok
  2711. DebugLog "about to kill token "+killtokdname$
  2712. Delete killtok
  2713.  
  2714.  
  2715. If tok = Null Then
  2716. DebugLog "unexpected end of file"
  2717. Return
  2718. EndIf
  2719. Until tokdname$ = "endfunction"
  2720. Delete tok
  2721.  
  2722.  
  2723. End Function
  2724.  
  2725.  
  2726. Function findfunction.dtokens(dec.declare,tok.dtokens)
  2727. Local foundfunc = False
  2728. Local killtok.dtokens
  2729. Repeat
  2730. tok = After tok
  2731. If tokdname$ = "function" Then
  2732. tok = After tok
  2733. If tokdname$ = decdname$ Then
  2734. killtok = Before tok
  2735. Delete killtok
  2736.  
  2737. Return tok
  2738. EndIf
  2739. EndIf
  2740.  
  2741.  
  2742.  
  2743. Until tok = Null
  2744. Return Null
  2745. End Function
  2746.  
  2747.  
  2748. Function tokenizescript(scriptname$="myscript",shandle$="QWERTYUIOP",scriptfile$="script.txt")
  2749. Local templine$,toffset,temptoken$
  2750. Local Stream = OpenFile(scriptfile$)
  2751. Local index = 0,gotstring = False,gotendstring = False
  2752. Local Line = 0
  2753. scr.script = New script
  2754. scrscriptname$ = scriptname$
  2755. scrscripthandle$ = shandle$
  2756. While Not Eof(Stream)
  2757. templine$ = ReadLine(Stream)
  2758. Line = Line + 1
  2759. DebugLog "line. "+Line
  2760. ;debuglog "len. "+Len(templine$)
  2761. For tempfor = 1 To Len(templine$)
  2762. ;debuglog tempfor
  2763. If Mid$( templine$,tempfor,1 ) = ";" Then
  2764. If gotstring = False Then
  2765. gotstring = True
  2766. Else
  2767. gotstring = False
  2768. gotendstring = True
  2769. EndIf
  2770. EndIf
  2771. If gotstring = False
  2772. If Mid$( templine$,tempfor,1 ) <> " " And tempfor <> Len(templine$) And gotendstring = False Then
  2773. temptoken$ = temptoken$ + Mid$( templine$,tempfor,1 )
  2774. Else
  2775. temptoken$ = temptoken$ + Mid$( templine$,tempfor,1 )
  2776. tok.dtokens = New dtokens
  2777. tokdname$ = Trim(temptoken$)
  2778. tokindex = index
  2779. toklline = Line
  2780. tokparentscrpt = scr
  2781. If tokparentscrpt = Null Then
  2782. DebugLog "Uh oh this has no parent script"
  2783. End
  2784. EndIf
  2785. index = index + 1
  2786. For com.commands = Each commands
  2787. If Lower(tokdname$) = Lower(comcommandname$) Then
  2788. tok     okentype = comcommandtype
  2789.  
  2790.  
  2791. EndIf
  2792.  
  2793. Next
  2794.  
  2795. tokindex = index
  2796. index = index + 1
  2797. temptoken$ = ""
  2798. gotendstring = False
  2799. EndIf
  2800. Else
  2801. temptoken$ = temptoken$ + Mid$( templine$,tempfor,1 )
  2802. EndIf
  2803. Next
  2804.  
  2805. Wend
  2806. CloseFile(Stream)
  2807.  
  2808. For tok.dtokens = Each dtokens
  2809. DebugLog tokdname$
  2810. Next
  2811.  
  2812. End Function
  2813.  
  2814.  
  2815.  
  2816. Function loadcommands()
  2817. Local tempfor,templine$,temptoken$
  2818. Local Stream = OpenFile("commands.txt")
  2819. While Not Eof(Stream)
  2820. templine$ = ReadLine(Stream)
  2821. For tempfor = 1 To Len(templine$)
  2822. If Mid$( templine$,tempfor,1 ) <> " " Then
  2823. temptoken$ = temptoken$ + Mid$( templine$,tempfor,1 )
  2824. ;debuglog temptoken$
  2825. Else
  2826. ;temptoken$ = temptoken$ + Mid$( templine$,tempfor,1 )
  2827.  
  2828. com.commands = New commands
  2829. comcommandtype = Int(temptoken$)
  2830. comcommandname$ = Trim(Replace(templine$,temptoken$,""))
  2831. ;debuglog comcommandtype
  2832. DebugLog comcommandname$
  2833. temptoken$ = ""
  2834. Exit
  2835. EndIf
  2836.  
  2837. Next
  2838. Wend
  2839. CloseFile(Stream)
  2840.  
  2841.  
  2842. End Function
  2843.  
  2844.  
  2845.  
  2846.  
  2847.  
  2848. Function finddeclaration.declare(tok.dtokens)
  2849. Local foundit = False
  2850. For dec.declare = Each declare
  2851.         If decdname$ = tokdname$ And tokparentscrpt = decparentscrpt Then
  2852.         Return dec
  2853.         foundit = True
  2854.         EndIf
  2855.        
  2856.         Next
  2857.  
  2858. Return Null
  2859. End Function


Comments :


_33(Posted 1+ years ago)

 I think this is a fantastic effort of yours, and big thumbs up for all this!  What would be really neat of course would be fixing the space issues in the tokenizer (as you stated, which I don't think is a very big thing to figure out).  But also, something much more IMHO important for ingame scripting, is to be able to run *crunched code*.  Meaning that, instead of having text for your commands and syntax checking, you could do all this in advance and save your scripts as neat "exe" like files in a script folder in the games dir, and work with banks for coding all this!  That would really boost the execution speed of the scripts by a thousand folds.Cheers.


Leon Drake(Posted 1+ years ago)

 yea, actually this was my first try at making a scripting engine, if you turn off all the debug logs it runs pretty fast. not quite as fast as if i prescreened it. but for a first attempt at least it works. This was mostly for small event scripts.


Filax(Posted 1+ years ago)

 Up :) Any news about a new version ?


Leon Drake(Posted 1+ years ago)

 lol i know its been forever but i just got back into b3d for a different project, so i may end up expanding this soon ;)


 

SimplePortal 2.3.6 © 2008-2014, SimplePortal