imports $system = system
imports $io = system.io

global $tokens = 
			{
				LeftPara=1,
				RightPara=2,
				Star=3,
				Plus=4,
				Min=5,
				Number=6,
				Div=7,
				Var=8
			}
			
;creates context for scanner
function scanner_create($expr)
	if $system.string.isnullorempty($expr) 
		throw '$expr should not be null or empty'
	endif
	
	$scanner_create = {
			PeekToken=nothing,
			Reader = $io.StringReader($expr)
		   }
endfunction

;converts object to character
function ToChar($c)
	$ToChar = $System.Convert.ToChar($c)
endfunction

;reads token from scanner state
function scanner_read($state)
	dim $c = 0
	dim $builder = $System.Text.StringBuilder()
	dim $length = 0
	
	if $state.PeekToken <> nothing
		dim $ret = $state.PeekToken
		$state.PeekToken = nothing
		$scanner_read = $ret
		exit 0
	endif
	
	$c = $state.Reader.Read

	while $c > 0
		dim $char = ToChar($c)
		
		select
			case $System.Char.IsWhitespace($char)
				$c = $state.Reader.Read
				continue
			case $System.Char.IsNumber($char)
				$length = $builder.Append($char)
				$c = $state.Reader.Peek
				
				while $c > 0
					$char = ToChar($c)
					if $System.Char.IsNumber($char) Or $char = "."
						$length = $builder.Append($char)
						$length = $state.Reader.Read
						$c = $state.Reader.Peek
					else
						break
					endif
				loop
				
				$scanner_read = {
									Token = $tokens.Number,
									Value = $builder.ToString
								}
			case $System.Char.IsLetter($char)
				$scanner_read = {
									Token = $tokens.Var,
									Value = $char
								}
			case $char = "+"
				$scanner_read = {
									Token = $tokens.Plus,
									Value = $char
								}
			case $char = "-"
				$scanner_read = {
									Token = $tokens.Min,
									Value = $char
								}
			case $char = "*"
				$scanner_read = {
									Token = $tokens.Star,
									Value = $char
								}
			case $char = "/"
				$scanner_read = {
									Token = $tokens.Div,
									Value = $char
								}
			case $char = "("
				$scanner_read = {
									Token = $tokens.LeftPara,
									Value = $char
								}			
			case $char = ")"
				$scanner_read = {
									Token = $tokens.RightPara,
									Value = $char
								}			
		endselect		
	
		if $scanner_read = nothing
			throw 'Unsupported token'
		endif
		
		break
	loop
endfunction

;peeks token from scanner context
function scanner_peek($state)
	if $state.PeekToken = nothing
		$state.PeekToken = scanner_read($state)
	endif
	
	$scanner_peek = $state.PeekToken
endfunction

;parses expression
function parser_parseExpression($scanner)
	$parser_parseExpression = parser_parseMinPlus($scanner)
endfunction

;parses final expression (atom/variable/parenthesis)
function parser_parseFinal($scanner)
	dim $token = scanner_peek($scanner)
	dim $swallow
	
	select
		case $token.token = $tokens.Number Or $token.token = $tokens.Var
			$parser_parseFinal = {
									Token = $token,
									Left=nothing,
									Right=nothing
								}
			$swallow = scanner_read($scanner)
		case $token.token = $tokens.LeftPara
			$swallow = scanner_read($scanner)
			
			$parser_parseFinal = parser_parseExpression($scanner)
			
			$swallow = scanner_read($scanner)
	endselect
endfunction

;parses multiplication and division
function parser_parseMulDiv($scanner)
	dim $left = parser_parseFinal($scanner)
	dim $swallow
	dim $token = scanner_peek($scanner)
	
	while $token <> nothing and 
				( $token.token = $tokens.Star or $token.token = $tokens.Div )
	
		$swallow = scanner_read($scanner)
		
		dim $expr = {
						Token = $token,
						Left = $left,
						Right = parser_parseFinal($scanner)
					}
					
		$left = $expr
		
		$token = scanner_peek($scanner)	
	loop
	
	$parser_parseMulDiv = $left
endfunction

;parses addition or subtraction
function parser_parseMinPlus($scanner)
	dim $left = parser_parseMulDiv($scanner)
	dim $swallow
	
	dim $token = scanner_peek($scanner)
	
	while $token <> nothing and 
				( $token.token = $tokens.Plus or $token.token = $tokens.Min )
		
		$swallow = scanner_read($scanner)
		
		dim $expr = {
						Token = $token,
						Left = $left,
						Right = parser_parseMulDiv($scanner)
					}
					
		$left = $expr
		
		$token = scanner_peek($scanner)				
	loop
	
	$parser_parseMinPlus = $left
endfunction

;prints expression tree
function parser_print($expr, $ident)
	for $i = 1 to $ident
		" "
	next 
	
	$expr.token.value ?
	
	if $expr.left <> nothing
		parser_print($expr.left, $ident+1)
	endif
	
	if $expr.right <> nothing
		parser_print($expr.right, $ident+1)
	endif	
endfunction

;evaluate expression tree
function evaluator_eval($expr, optional $variables)
	dim $left, $right
	
	select
		case $expr.token.token = $tokens.Plus
			$left = evaluator_eval($expr.left, $variables)
			$right = evaluator_eval($expr.right, $variables)
			$evaluator_eval = $left + $right
		case $expr.token.token = $tokens.Min
			$left = evaluator_eval($expr.left, $variables)
			$right = evaluator_eval($expr.right, $variables)
			$evaluator_eval = $left - $right
		case $expr.token.token = $tokens.Star
			$left = evaluator_eval($expr.left, $variables)
			$right = evaluator_eval($expr.right, $variables)
			$evaluator_eval = $left * $right
		case $expr.token.token = $tokens.Div
			$left = evaluator_eval($expr.left, $variables)
			$right = evaluator_eval($expr.right, $variables)
			$evaluator_eval = $left / $right
		case $expr.token.token = $tokens.number
			$evaluator_eval = $System.Convert.ToDouble($expr.token.value, $System.Globalization.NumberFormatInfo() With { NumberDecimalSeparator = "." })
		case $expr.token.token = $tokens.var
			if not $variables
				throw 'Variable referenced but not defined'
			endif
			$evaluator_eval = $System.Convert.ToDouble($variables[$expr.token.value])
	endselect
	
endfunction

;"1+10 * (1+2)"

"Enter an expression. Only multiplication, addition, subtraction and division is supported. Parenthesis can be used." ?
"Example: 1+10 * (1+2)" ?
"Type exit to quit" ?

dim $input

gets $input

while $input <> "exit"
	dim $scannerState = scanner_create($input)
	dim $expr = parser_parseExpression($scannerState)
	"Result: " evaluator_eval($expr, nothing) ?
	"Tree: " ? 
	parser_print($expr, 0)
	gets $input
loop

Macro DATE
Dim $dtn,$rc
Imports $dtn = System.DateTime.Now

Try
   $rc = $dtn.ToString("yyy/MM/dd")
EndTry
Catch
   $e
EndCatch

If $e
   $DATE = $e.ToString()
Else
   $DATE = $rc
EndIf
EndMacro

2009/10/06

DelKey('HKEY_CURRENT_USER\Test\New\some\Folder\Task')
?@SERROR

The system cannot find the file specified.

? DelKey('HKEY_CURRENT_USER\Test\New\some\Folder\Task')

Cannot delete a subkey tree because the subkey does not exist.

;SteelKix Function: DelKey()
;
;Author:		Boforce
;
;Contributors:	None
;
;Action:		Deletes the specified subkey from the registry
;
;Syntax:		DelKey("key")
;
;Version:		1.0
;
;Date:		2009-09-25
;
;Date Revised:	2009-09-25
;
;Parameters	Key
;		Required.	A string that specifies the name of the subkey you want to delete
;
;Remarks:		None
;
;Returns:		Returns nothing if the key is deleted else an error message
;
;Dependencies:
; SteelKix version: 0.2
; Tested with Dot Net 3.5.30729.01
;
;Example(s):	Delete some key:
;		$DeleteKey = DelKey('HKEY_CURRENT_USER\Test\Some\New\Key')
;		? 'Deleted key : ' + $DeleteKey
;
;Comments : This has been successfully tested on Windows XP SP3 with DOT NET 3.5.30729.01.
;
;Source:
Function DelKey($Key)
Dim $Win32,$Hive,$Action

Imports $Win32 = Microsoft.Win32

$Hive = $Key.ToString.Split("\".ToCharArray())[0]
$Key = $Key.Remove($Hive+'\',$Hive.Length+1)

Select
   Case $Hive = 'HKEY_CLASSES_ROOT' Or $Hive = 'HKCR'
	$Hive = $Win32.Registry.ClassesRoot
   Case $Hive = 'HKEY_CURRENT_USER' Or $Hive = 'HKCU'
	$Hive = $Win32.Registry.CurrentUser
   Case $Hive = 'HKEY_LOCAL_MACHINE' Or $Hive = 'HKLM'
	$Hive = $Win32.Registry.LocalMachine
   Case $Hive = 'HKEY_USERS' Or $Hive = 'HKU'
	$Hive = $Win32.Registry.Users
   Case 1
	$atHive = 'Error'
EndSelect

If $atHive = 'Error'
   $AddKey = 'Unknown hive'
Else
   Try
	 $Action = $Hive.DeleteSubKey($Key,1)
   EndTry
   Catch
	 $e
   EndCatch

   If $e
	 $DelKey = $e.Message
   Else
	 $DelKey = $Action
   EndIf
EndIf
EndFunction

System.ArgumentException: Cannot delete a subkey tree because the subkey does not exist.
   at Microsoft.Scripting.Interpreter.ThrowInstruction.Run(InterpretedFrame frame)
   at Microsoft.Scripting.Interpreter.Interpreter.Run(InterpretedFrame frame)

;SteelKix Macro: @TIME
;
;Author:		Boforce
;
;Contributors:	Richard von Mallesch (It took my meds)
;
;Action:		Retrieve current Time 
;
;Syntax:		@TIME
;
;Version:		1.0
;
;Date:		2009-09-28
;
;Date Revised:	2009-09-28
;
;Parameters	None
;
;Remarks:		None
;
;Returns:		Time (in the format HH:MM:SS) 
;
;Dependencies:
; SteelKix version: 0.2
; Tested with Dot Net 3.5.30729.01
;
;Example(s):	Get Current Time:
;		? @TIME
;		Result > 10:23:15
;
;Comments : This has been successfully tested on Windows XP SP3 with DOT NET 3.5.30729.01.
;
;Source:
Macro TIME
Dim $dtn,$rc
Imports $dtn = System.DateTime.Now

Try
   $rc = $dtn.ToString("HH:mm:ss")
EndTry
Catch
   $e
EndCatch

If $e
   $TIME = $e.Message
Else
   $TIME = $rc
EndIf
EndMacro


;SteelKix Macro: @DAY
;
;Author:		Boforce
;
;Contributors:	Richard von Mallesch (It took my meds)
;
;Action:		Retrieve day of the week 
;
;Syntax:		@DAY
;
;Version:		1.0
;
;Date:		2009-09-28
;
;Date Revised:	2009-09-28
;
;Parameters	None
;
;Remarks:		None
;
;Returns:		Day (Monday, Tuesday, etc.) 
;
;Dependencies:
; SteelKix version: 0.2
; Tested with Dot Net 3.5.30729.01
;
;Example(s):	Get day of the week:
;		? @DAY
;		Result > Monday
;
;Comments : This has been successfully tested on Windows XP SP3 with DOT NET 3.5.30729.01.
;
;Source:
Macro DAY
Dim $dtn,$rc
Imports $dtn = System.DateTime.Now

Try
   $rc = $dtn.DayOfWeek
EndTry
Catch
   $e
EndCatch

If $e
   $DAY = $e.Message
Else
   $DAY = $rc
EndIf
EndMacro

;SteelKix Macro: @MONTHNO
;
;Author:		Boforce
;
;Contributors:	Richard von Mallesch (It took my meds)
;
;Action:		Retrieve the number of the current month of the year 
;
;Syntax:		@MONTHNO
;
;Version:		1.0
;
;Date:		2009-09-28
;
;Date Revised:	2009-09-28
;
;Parameters	None
;
;Remarks:		None
;
;Returns:		Month number, beginning with January (1-12)
;
;Dependencies:
; SteelKix version: 0.2
; Tested with Dot Net 3.5.30729.01
;
;Example(s):	Get month number of the year:
;		? @MONTHNO
;		Result > 10 (if month is October)
;
;Comments : This has been successfully tested on Windows XP SP3 with DOT NET 3.5.30729.01.
;
;Source:
Macro MONTHNO
Dim $dtn,$rc
Imports $dtn = System.DateTime.Now

Try
   $rc = $dtn.Month
EndTry
Catch
   $e
EndCatch

If $e
   $MONTHNO = $e.Message
Else
   $MONTHNO = $rc
EndIf
EndMacro

;SteelKix Macro: @MONTH
;
;Author:		Boforce
;
;Contributors:	Richard von Mallesch (It took my meds)
;
;Action:		Retrieve the name of the current month of the year
;
;Syntax:		@MONTH
;
;Version:		1.0
;
;Date:		2009-09-28
;
;Date Revised:	2009-09-28
;
;Parameters	None
;
;Remarks:		None
;
;Returns:		Name of the Month
;
;Dependencies:
; SteelKix version: 0.2
; Tested with Dot Net 3.5.30729.01
;
;Example(s):	Get month of the year:
;		? @MONTH
;		Result > OCTOBER (if month is October)
;
;Comments : This has been successfully tested on Windows XP SP3 with DOT NET 3.5.30729.01.
;
;Source:
Macro MONTH
Dim $dtn,$glob,$rc
Imports $dtn = System.DateTime.Now
Imports $glob = System.Globalization

Try
   $rc = $dtn.Month
EndTry
Catch
   $e
EndCatch

If $e
   $MONTH = $e.Message
Else
   $MONTH = $glob.DateTimeFormatInfo.CurrentInfo.GetMonthName($rc).ToUpper()
EndIf
EndMacro