regular expressions batch - regex

Question

I'm writing a calculator on a cmd with enabled binary operations. I need to validate input data (remove letters, and other symbols that are not required for arithmetic operations)
#echo off
set data=
echo %* | findstr /R "\/\? ECHO" > nul
IF "%ERRORLEVEL%" EQU "0" goto printHelp
:main
set data= %data%%1
shift
if "%1" == "" (
echo %data% | findstr /R "^[0123456789*-+()/%!^_&|]*$" >nul 2>&1
if "%ERRORLEVEL%" EQU 0 (
echo Incorrect input data
exit /B
)
goto :result
) else (
goto :main
)
:result
set /a data="%data%"
echo %data%
exit /B
:printHelp
echo.
echo --------------------------------------------------
echo Using: calculator.bat [/?] [EXPRESSION]
echo helps you to consider arithmetic in Command Line
echo --------------------------------------------------
exit /B
My regular expression is not working. Also not considered to be a binary operation. What could be the problem?

Answer 1

Part 1 - Why your "regex is not working"
Your logic is wrong. FINDSTR sets ERRORLEVEL to 0 if there is a match, 1 if no match. Your regex is verifying that all characters are "valid", but your condition is treating a match as incorrect input.
Your IF statement uses quotes on one side, but not on the other. You must be consistent, otherwise it can never evaluate to TRUE.
Percent literals must be doubled within a batch script. Your regex has a percent literal that should be written as %%.
You use %ERRORLEVEL% in the same code block that sets the value. This cannot work because the value is expanded when the code block is parsed - before the value is set.
The simplest alternative is to use if errorlevel 1, which returns true if ERRORLEVEL is >= 1.
Another option is to enable delayed expansion with SETLOCAL ENABLEDELAYEDEXPANSION at top, and then use if !errorlevel! neq 0. But this would require that quoted ! literal in your regex be escaped as ^!, and ^ literal escaped as ^^.
My favorite option is to use the && and || conditional operators instead of IF.
findstr ... >nul && (match found statements) || (no match statements)
In your case, you want to take action if there was no match, so you only need the || operator.
Part 2 - Why your whole concept is not a good idea
Your validation is overly simplistic. Simply screening out invalid characters does not prevent errors. For example, 1**2 will result in an error, even though all characters are "valid". There are many other inputs with "valid" characters that would result in an error.
SET /A can work directly with environment variables. It knows how to access the value without you expanding the value in your code. This can be a powerful tool. A variable name used in a computation can include any character that is not an operator. So one can argue that there are no invalid characters for SET /A computations. Your exclusion of "invalid" characters prevents use of variables in computations.
Below is a simple batch calculator program I wrote some time ago. It is in an endless loop requesting input and displaying the result, until you enter a quit command. It supports all operators supported by SET /A.
It allows you to define and use variables in your expressions. The result of the most recent computation is always stored in a variable named #.
The calculator can display results as decimal, hexidecimal, or binary.
By default, it only displays the result of the last computation. It can be instructed to also display the value of all variables after each computation.
You can enter a command instead of a math computation. All commands begin with a \
\ Quit
\V Toggle variable listing ON or OFF
\D Decimal mode - results are displayed as decimal
\H Hex mode - results are displayed as hexidecimal
\B Binary mode - results are displayed as binary
\C X Clear variable X
\C * Clear all variables
\C X* Clear all variables that begin with X
Entering nothing will list all the currently defined variables.
Cleared variables are undefined. Note that an undefined variable has an implicit value of 0.
Here is the code:
#echo off
setlocal enableDelayedExpansion
for /f "delims==" %%v in ('set') do set %%v=
set __skip=#COMSPEC#PATHEXT#PROMPT#__mode#__str#__skip#__clr###__dispVars#
set __mode=Dec
set __dispVars=0
:top
echo:
set __str=
set /p "__str=%__mode%> "
if "!__str!"=="\" exit /b
if "!__str!"=="" call :dispVar # & call :dispVars & goto :top
if /i "!__str:~0,2!"=="\C" call :clearVars &goto :top
if /i "!__str!"=="\H" (set __mode=Hex) ^
else if /i "!__str!"=="\D" (set __mode=Dec) ^
else if /i "!__str!"=="\B" (set __mode=Bin) ^
else if /i "!__str!"=="\V" (set /a "__dispVars=^!__dispVars") ^
else set /a #=(!__str!)
call :dispVar #
if !__dispVars! gtr 0 call :dispVars
goto :top
:clearVars
for /f "delims=,; " %%v in ("!__str:~2!") do (
set __clr=%%v
if "!__clr:~-1!"=="*" (
set __clr=!__clr:~0,-1!
for /f "delims==" %%x in ('set !__clr!') do (
if "!__skip:#%%x#=!"=="!__skip!" set "%%x="
)
) else set "%%v="
)
call :dispVar #
call :dispVars
exit /b
:dispVars
setlocal
for /f "tokens=1,2 delims==" %%v in ('set') do if "!__skip:#%%v#=!"=="!__skip!" call :dispVar %%v
exit /b
:dispVar Var
setlocal
if !__mode!==Hex call :num2hex %1 disp
if !__mode!==Bin call :num2bin %1 disp
if !__mode!==Dec set /a disp=!%~1!
set var=%~1
if "!var:~0,6!"=="!var!" (
set "var=!var! ----------"
set "var=!var:~0,6!"
)
echo %var% = !disp!
exit /b
:num2hex NumVal RtnVar
setlocal enabledelayedexpansion
set hex=
set /a "dec=%~1"
set "map=0123456789ABCDEF"
for /l %%n in (1,1,8) do (
set /a "d=dec&15,dec>>=4"
for %%d in (!d!) do set "hex=!map:~%%d,1!!hex!"
)
(endlocal & rem return values
set %~2=%hex%
exit /b
)
exit /b
:num2bin NumVal RtnVar
setlocal enabledelayedexpansion
set bin=
set /a "dec=%~1"
for /l %%n in (1,1,32) do (
set /a "d=dec&1,dec>>=1"
set "bin=!d!!bin!"
)
(endlocal & rem return values
set %~2=%bin%
exit /b
)
exit /b
And here are the results of a short session:
D:\test>calculate.bat
Dec> 2*3
# ---- = 6
Dec> a=#+1
# ---- = 7
Dec>
# ---- = 7
a ---- = 7
Dec> b=(a+=5)*2
# ---- = 24
Dec> \v
# ---- = 24
a ---- = 12
b ---- = 24
Dec> c=b/3
# ---- = 8
a ---- = 12
b ---- = 24
c ---- = 8
Dec> \h
# ---- = 00000008
a ---- = 0000000C
b ---- = 00000018
c ---- = 00000008
Hex> \b
# ---- = 00000000000000000000000000001000
a ---- = 00000000000000000000000000001100
b ---- = 00000000000000000000000000011000
c ---- = 00000000000000000000000000001000
Bin> \
D:\test>