#include <StringConstants.au3> ; to declare the Constants of StringRegExp
#include <Array.au3> ; UDF needed for _ArrayDisplay and _ArrayConcatenate
Local $sRegex = "(?xJ)(?(DEFINE)" & @CRLF & _
"(?<add> \s*\+\s* )" & @CRLF & _
"(?<eq> \s*=\s* )" & @CRLF & _
"# Remove all zeroes except the last one if the number is 0" & @CRLF & _
"(?<zero> (?:0(?=\d))*+ )" & @CRLF & _
"# cl: last digit of left operand being 1, cr: last digit of right operand being 1, \d(?:0|\b) check if last digit from result is 0" & @CRLF & _
"# there will be carry if cl and cr are set, or cl or cr are set and the last digit from result is 0" & @CRLF & _
"(?<carry> (?(cl)(?(cr)|\d(?:0|\b))|(?(cr)\d(?:0|\b)|(*F))) )" & @CRLF & _
"# add carry with l1 (current digit of left operand being 1) and r1 (current digit of right operand being 1)" & @CRLF & _
"# i.e. returns result of carry + l1 + r1 in Z/2Z" & @CRLF & _
"(?<digitadd> (?(?= (?(?=(?(l1)(?(r1)|(*F))|(?(r1)(*F))))(?&carry)|(?!(?&carry))) )1|0) )" & @CRLF & _
"# check for a single digit at the current offset whether the result is correct" & @CRLF & _
"# ro: right operand out of bounds (i.e. the current digit is at a higher offset than the size of the left operand)" & @CRLF & _
"# if we're out of bounds of the right operand, cr is just not set (i.e. handled as if there were leading zeroes)" & @CRLF & _
"(?<recursedigit>" & @CRLF & _
"# now, with the r and f, we can figure out r1 and cr at the current offset and also perform binary carry addition at that offset in the result" & @CRLF & _
" (?&add) (?&zero) (?:\d*(?:0|1(?<r1>)))? (?(ro)|(?=(?<cr>1)?))\k<r> (?&eq) \d*(?&digitadd)\k<f>\b" & @CRLF & _
"# iterate through the whole left operand to find the sequences (for right operand and result) of the same length as the offset of the current digit" & @CRLF & _
"| (?=\d* (?&add) (?&zero) (?:\k<r>(?<ro>)|\d*(?<r>\d\k<r>)) (?&eq) \d*(?<f>\d\k<f>)\b) \d(?&recursedigit)" & @CRLF & _
")" & @CRLF & _
"# run the check, sets l1 and cl accordingly and initializes the r (right operand) and f (final result) groups to be empty" & @CRLF & _
"(?<checkdigit> (?:0|1(?<l1>)) (?=(?<cl>1)?) (?<r>) (?<f>) (?&recursedigit) )" & @CRLF & _
"# "trivial" increment of a binary number, i.e. a +1 is applied to the part of the right operand which exceeds the length of the left operand" & @CRLF & _
"(?<carryoverflow>" & @CRLF & _
"# number contains a zero, just update the part after the last zero" & @CRLF & _
" (?<x>\d+) 0 (?<y> \k<r> (?&eq) 0*\k<x>1 | 1(?&y)0 )" & @CRLF & _
"# number contains only ones, add a leading 1 and replace all the ones by zeroes" & @CRLF & _
"| (?<z> 1\k<r> (?&eq) 0*10 | 1(?&z)0 )" & @CRLF & _
")" & @CRLF & _
"# ensure correct lengths of the final operand and handle right operands being longer than the left operand" & @CRLF & _
"(?<recurseoverflow>" & @CRLF & _
"# the left operand is longer than or as long as the right one. In the latter case, the final result will always be exactly one digit longer than the operands" & @CRLF & _
"# in the former case, if the first non-leading zero (from the left) of the left operand is at a higher or equal offset to the length of the right operand, the final result will be one digit longer than the left operand" & @CRLF & _
" (?&add) 0*+ (?(rlast) \k<r> (?&eq) 0*(?(ro)(?(addone)1)|1)\k<f>\b" & @CRLF & _
"# the right operand has a zero at the offset equal to the length of the left operand. Then just copy the leading digits to the final result" & @CRLF & _
" | (?:(?<remaining>\d+)(?=0\d* (?&eq) \d*(?=1)\k<f>\b)\k<r> (?&eq) (*PRUNE) 0*\k<remaining>\k<f>\b" & @CRLF & _
"# otherwise there will be some carry which needs to be applied before copying the leading digits to the final result" & @CRLF & _
" | (?&carryoverflow)\k<f>\b))" & @CRLF & _
"# iterate through the whole left operand to find the sequences (for right operand and result) of the same length as the left operand" & @CRLF & _
"| (?=\d* (?&add) 0*+ (?:\k<r>(?<ro>)|(?=(?:\d\k<r>(?&eq)(?<rlast>))?)\d*(?<r>\d\k<r>)) (?&eq) \d*(?<f>\d\k<f>)\b)" & @CRLF & _
"# check - only at the first non-leading zero - whether the right operand is longer than the current offset of the iteration, or just as long and having a carry (i.e. the digit at that offset in the final result is 0)" & @CRLF & _
" (?(nullchecked)|(?=(?<addone>(?=0)(?=(?:\d(?=\d*(?&add)\d*(?&eq)\d*(?<c>\d\k<c>)\b))+(?&add))(?<longer>(?&add)0*|\d(?&longer)\d)(\d+(?&eq)|(?&eq)\d*(?=0)\k<c>))?)(?=(?<nullchecked>0)?))" & @CRLF & _
" \d(?&recurseoverflow)" & @CRLF & _
")" & @CRLF & _
"(?<s>" & @CRLF & _
" (?=\d) 0*? (?<arg>[01]+)? (?&add) (?=\d) 0*? (?<arg>(?(arg)(*F))[01]+)? (?&eq) (*PRUNE) \k<arg>" & @CRLF & _
"| (?&zero)" & @CRLF & _
"# traverse the digits one by one and verify the correctness of each offset individually" & @CRLF & _
" (?=(?<iteratedigits> (?=(?&checkdigit))\d (?:\b|(?&iteratedigits)) ))" & @CRLF & _
"# assert exact format here" & @CRLF & _
" (?=[01]+ (?&add) [01]+ (?&eq) [01]+ \b)" & @CRLF & _
"# remove leading zeroes and force an additional digit on the final result in case the left operand is only ones and the right operand not longer than the left" & @CRLF & _
" 0*? (?<r>) (?<f>) (?<c>) (?=(?<addone>1+(?&add))?) (?&recurseoverflow)" & @CRLF & _
"# Handle 0 + x or x + 0 separately to avoid messing around in the big subpatterns" & @CRLF & _
")" & @CRLF & _
")" & @CRLF & _
"\b(?&s)\b"
Local $sString = "- 1 + 1 = 0" & @CRLF & _
"- 1 + 1 = 1" & @CRLF & _
"- 0 + 1 = 11" & @CRLF & _
"+ 1 + 1 = 10" & @CRLF & _
"- 1 + 10 = 101" & @CRLF & _
"- 0 + 11 = 101" & @CRLF & _
"+ 0 + 1 = 1" & @CRLF & _
"- 0 + 0 = 10" & @CRLF & _
"+ 1 + 0 = 1" & @CRLF & _
"- 1 + 101 = 1010" & @CRLF & _
"+ 10 + 0 = 10" & @CRLF & _
"+ 10 + 1 = 11" & @CRLF & _
"+ 11 + 1 = 100" & @CRLF & _
"+ 100 + 1 = 101" & @CRLF & _
"+ 01 + 10 = 11" & @CRLF & _
"+ 10 + 10 = 100" & @CRLF & _
"+ 010 + 010 = 100" & @CRLF & _
"+ 101 + 11 = 1000" & @CRLF & _
"- 101 + 10 = 1111" & @CRLF & _
"- 100 + 10 = 111" & @CRLF & _
"- 101 + 10 = 101" & @CRLF & _
"+ 101 + 10 = 111" & @CRLF & _
"+ 11 + 101 = 1000" & @CRLF & _
"+ 11 + 1011 = 1110" & @CRLF & _
"+ 11 + 10101 = 11000" & @CRLF & _
"+ 1 + 1111 = 10000" & @CRLF & _
"+ 111 + 11 = 1010" & @CRLF & _
"+ 1110 + 100 = 10010" & @CRLF & _
"+ 11 + 11 = 110" & @CRLF & _
"+ 1111 + 11 = 10010" & @CRLF & _
"- 010 + 010 = 000" & @CRLF & _
"- 100 + 100 = 1100" & @CRLF & _
"+ 100 + 100 = 1000" & @CRLF & _
"+ 1000 + 100 = 1100" & @CRLF & _
"+ 1 + 1000 = 1001" & @CRLF & _
"+ 1000 + 1 = 1001" & @CRLF & _
"+ 110 + 1100 = 10010" & @CRLF & _
"- 110 + 1010 = 1000" & @CRLF & _
"- 10 + 1 = 11111001"
Local $aArray = StringRegExp($sString, $sRegex, $STR_REGEXPARRAYGLOBALFULLMATCH)
Local $aFullArray[0]
For $i = 0 To UBound($aArray) -1
_ArrayConcatenate($aFullArray, $aArray[$i])
Next
$aArray = $aFullArray
; Present the entire match result
_ArrayDisplay($aArray, "Result")
Please keep in mind that these code samples are automatically generated and are not guaranteed to work. If you find any syntax errors, feel free to submit a bug report. For a full regex reference for AutoIt, please visit: https://www.autoitscript.com/autoit3/docs/functions/StringRegExp.htm