haiku/build/jam/MathRules

606 lines
13 KiB
Plaintext
Raw Normal View History

# Rules providing basic arithmetic operations
HAIKU_ZERO = + 0 ;
HAIKU_ONE = + 1 ;
HAIKU_PAD_9 = 0 1 2 3 4 5 6 7 8 ;
# a > b <==> $(HAIKU_DIGIT_GREATER_$(a)[1$(b)])
HAIKU_DIGIT_GREATER_0 = $(HAIKU_PAD_9) ;
HAIKU_DIGIT_GREATER_1 = $(HAIKU_PAD_9) 1 ;
HAIKU_DIGIT_GREATER_2 = $(HAIKU_PAD_9) 1 1 ;
HAIKU_DIGIT_GREATER_3 = $(HAIKU_PAD_9) 1 1 1 ;
HAIKU_DIGIT_GREATER_4 = $(HAIKU_PAD_9) 1 1 1 1 ;
HAIKU_DIGIT_GREATER_5 = $(HAIKU_PAD_9) 1 1 1 1 1 ;
HAIKU_DIGIT_GREATER_6 = $(HAIKU_PAD_9) 1 1 1 1 1 1 ;
HAIKU_DIGIT_GREATER_7 = $(HAIKU_PAD_9) 1 1 1 1 1 1 1 ;
HAIKU_DIGIT_GREATER_8 = $(HAIKU_PAD_9) 1 1 1 1 1 1 1 1 ;
HAIKU_DIGIT_GREATER_9 = $(HAIKU_PAD_9) 1 1 1 1 1 1 1 1 1 ;
# a + b == $(HAIKU_DIGIT_ADD_$(a)[1$(b)]) (carry ignored)
HAIKU_DIGIT_ADD_0 = $(HAIKU_PAD_9) 0 1 2 3 4 5 6 7 8 9 ;
HAIKU_DIGIT_ADD_1 = $(HAIKU_PAD_9) 1 2 3 4 5 6 7 8 9 0 ;
HAIKU_DIGIT_ADD_2 = $(HAIKU_PAD_9) 2 3 4 5 6 7 8 9 0 1 ;
HAIKU_DIGIT_ADD_3 = $(HAIKU_PAD_9) 3 4 5 6 7 8 9 0 1 2 ;
HAIKU_DIGIT_ADD_4 = $(HAIKU_PAD_9) 4 5 6 7 8 9 0 1 2 3 ;
HAIKU_DIGIT_ADD_5 = $(HAIKU_PAD_9) 5 6 7 8 9 0 1 2 3 4 ;
HAIKU_DIGIT_ADD_6 = $(HAIKU_PAD_9) 6 7 8 9 0 1 2 3 4 5 ;
HAIKU_DIGIT_ADD_7 = $(HAIKU_PAD_9) 7 8 9 0 1 2 3 4 5 6 ;
HAIKU_DIGIT_ADD_8 = $(HAIKU_PAD_9) 8 9 0 1 2 3 4 5 6 7 ;
HAIKU_DIGIT_ADD_9 = $(HAIKU_PAD_9) 9 0 1 2 3 4 5 6 7 8 ;
# a - b == $(HAIKU_DIGIT_SUB_$(a)[1$(b)]) (carry ignored)
HAIKU_DIGIT_SUB_0 = $(HAIKU_PAD_9) 0 9 8 7 6 5 4 3 2 1 ;
HAIKU_DIGIT_SUB_1 = $(HAIKU_PAD_9) 1 0 9 8 7 6 5 4 3 2 ;
HAIKU_DIGIT_SUB_2 = $(HAIKU_PAD_9) 2 1 0 9 8 7 6 5 4 3 ;
HAIKU_DIGIT_SUB_3 = $(HAIKU_PAD_9) 3 2 1 0 9 8 7 6 5 4 ;
HAIKU_DIGIT_SUB_4 = $(HAIKU_PAD_9) 4 3 2 1 0 9 8 7 6 5 ;
HAIKU_DIGIT_SUB_5 = $(HAIKU_PAD_9) 5 4 3 2 1 0 9 8 7 6 ;
HAIKU_DIGIT_SUB_6 = $(HAIKU_PAD_9) 6 5 4 3 2 1 0 9 8 7 ;
HAIKU_DIGIT_SUB_7 = $(HAIKU_PAD_9) 7 6 5 4 3 2 1 0 9 8 ;
HAIKU_DIGIT_SUB_8 = $(HAIKU_PAD_9) 8 7 6 5 4 3 2 1 0 9 ;
HAIKU_DIGIT_SUB_9 = $(HAIKU_PAD_9) 9 8 7 6 5 4 3 2 1 0 ;
# a * b == $(HAIKU_DIGIT_MULT_CARRY_$(a)[1$(b)]) $(HAIKU_DIGIT_MULT_$(a)[1$(b)])
HAIKU_DIGIT_MULT_0 = $(HAIKU_PAD_9) 0 0 0 0 0 0 0 0 0 0 ;
HAIKU_DIGIT_MULT_1 = $(HAIKU_PAD_9) 0 1 2 3 4 5 6 7 8 9 ;
HAIKU_DIGIT_MULT_2 = $(HAIKU_PAD_9) 0 2 4 6 8 0 2 4 6 8 ;
HAIKU_DIGIT_MULT_3 = $(HAIKU_PAD_9) 0 3 6 9 2 5 8 1 4 7 ;
HAIKU_DIGIT_MULT_4 = $(HAIKU_PAD_9) 0 4 8 2 6 0 4 8 2 6 ;
HAIKU_DIGIT_MULT_5 = $(HAIKU_PAD_9) 0 5 0 5 0 5 0 5 0 5 ;
HAIKU_DIGIT_MULT_6 = $(HAIKU_PAD_9) 0 6 2 8 4 0 6 2 8 4 ;
HAIKU_DIGIT_MULT_7 = $(HAIKU_PAD_9) 0 7 4 1 8 5 2 9 6 3 ;
HAIKU_DIGIT_MULT_8 = $(HAIKU_PAD_9) 0 8 6 4 2 0 8 6 4 2 ;
HAIKU_DIGIT_MULT_9 = $(HAIKU_PAD_9) 0 9 8 7 6 5 4 3 2 1 ;
HAIKU_DIGIT_MULT_CARRY_0 = $(HAIKU_PAD_9) 0 0 0 0 0 0 0 0 0 0 ;
HAIKU_DIGIT_MULT_CARRY_1 = $(HAIKU_PAD_9) 0 0 0 0 0 0 0 0 0 0 ;
HAIKU_DIGIT_MULT_CARRY_2 = $(HAIKU_PAD_9) 0 0 0 0 0 1 1 1 1 1 ;
HAIKU_DIGIT_MULT_CARRY_3 = $(HAIKU_PAD_9) 0 0 0 0 1 1 1 2 2 2 ;
HAIKU_DIGIT_MULT_CARRY_4 = $(HAIKU_PAD_9) 0 0 0 1 1 2 2 2 3 3 ;
HAIKU_DIGIT_MULT_CARRY_5 = $(HAIKU_PAD_9) 0 0 1 1 2 2 3 3 4 4 ;
HAIKU_DIGIT_MULT_CARRY_6 = $(HAIKU_PAD_9) 0 0 1 1 2 3 3 4 4 5 ;
HAIKU_DIGIT_MULT_CARRY_7 = $(HAIKU_PAD_9) 0 0 1 2 2 3 4 4 5 6 ;
HAIKU_DIGIT_MULT_CARRY_8 = $(HAIKU_PAD_9) 0 0 1 2 3 4 4 5 6 7 ;
HAIKU_DIGIT_MULT_CARRY_9 = $(HAIKU_PAD_9) 0 0 1 2 3 4 5 6 7 8 ;
# pragma mark - Number Operations
rule NormalizeNum number
{
# NormalizeNum <number> ;
local sign ;
if $(number[1]) = "-" || $(number[1] = "+" {
sign = $(number[1]) ;
number = $(number[2-]) ;
} else {
sign = "+" ;
}
# cut off leading zeros
local number = [ FReverse $(number) ] ;
while $(number[1]) = 0 {
number = $(number[2-]) ;
}
number = [ FReverse $(number) ] ;
# zero is respresented as + 0
if ! $(number) {
number = 0 ;
sign = "+" ;
}
return $(sign) $(number) ;
}
rule Num string : dontExit
{
# Num <number string> [ : <dontExit> ] ;
# split the string into three parts: sign, digits, and remainder
local temp = [ Match ([^0-9]*)([0-9]+)(.*) : $(string) ] ;
# there must be digits, but there must not be a remainder
if ! $(temp[2]) || $(temp[3]) {
if $(dontExit) {
return ;
}
Exit "Not a number" ;
}
# get the sign
local number ;
if ! $(temp[1]) {
number = "+" ;
} else if $(temp[1]) = "+" || $(temp[1]) = "-" {
number = $(temp[1]) ;
} else {
if $(dontExit) {
return ;
}
Exit "Not a number (sign)" ;
}
# split the digits
temp = $(temp[2]) ;
while $(temp[1]) {
# split off the last digit
temp = [ Match (.*)([0-9]) : $(temp[1]) ] ;
number += $(temp[2]) ;
}
# normalize
return [ NormalizeNum $(number) ] ;
}
rule Num2String number
{
# Num2String <number> ;
local sign = $(number[1]) ;
if $(sign) = "+" {
sign = "" ;
}
number = [ FReverse $(number[2-]) ] ;
return $(sign)$(number:J=) ;
}
rule NumGreaterAbs a : b
{
# NumGreaterAbs <a> : <b> ;
# we compare from least to most significant digit
local cmp = 0 ;
while $(a) && $(b) {
# chop off the first digit
local da = $(a[1]:E=0) ;
local db = $(b[1]:E=0) ;
a = $(a[2-]) ;
b = $(b[2-]) ;
if $(da) != $(db) {
if $(HAIKU_DIGIT_GREATER_$(da)[1$(db)]) {
cmp = 1 ;
} else {
cmp = -1 ;
}
}
}
# a is greater, if b is not longer and a is either longer or equally long
# and greater according to the digits comparison
if ! $(b) && ( $(a) || $(cmp) = 1 ) {
return 1 ;
}
return ;
}
rule AddNumAbs a : b
{
# AddNum <a> : <b> ;
local result ;
local carry ;
while $(a) || $(b) || $(carry) {
# chop off the first digit
local da = $(a[1]:E=0) ;
local db = $(b[1]:E=0) ;
a = $(a[2-]) ;
b = $(b[2-]) ;
# add carry to the first digit
if $(carry) {
local daa = $(HAIKU_DIGIT_ADD_1[1$(da)]) ;
carry = $(HAIKU_DIGIT_GREATER_$(da)[1$(daa)]) ;
da = $(daa) ;
}
# add digits
local dr = $(HAIKU_DIGIT_ADD_$(da)[1$(db)]) ;
if $(HAIKU_DIGIT_GREATER_$(da)[1$(dr)]) {
carry = 1 ;
}
result += $(dr) ;
}
return $(result) ;
}
rule SubNumAbs a : b
{
# SubNum <a> : <b> ;
local result ;
local carry ;
while $(a) && ( $(b) || $(carry) ) {
# chop off the first digit
local da = $(a[1]:E=0) ;
local db = $(b[1]:E=0) ;
a = $(a[2-]) ;
b = $(b[2-]) ;
# sub carry from the first digit
if $(carry) {
local daa = $(HAIKU_DIGIT_SUB_$(da)[11]) ;
carry = $(HAIKU_DIGIT_GREATER_$(daa)[1$(da)]) ;
da = $(daa) ;
}
# sub digits
local dr = $(HAIKU_DIGIT_SUB_$(da)[1$(db)]) ;
if $(HAIKU_DIGIT_GREATER_$(dr)[1$(da)]) {
carry = 1 ;
}
result += $(dr) ;
}
if $(b) || $(carry) {
Exit "Error: SubNumAbs: Can't subtract greater from smaller number." ;
}
return $(result) ;
}
rule NegNum a
{
# NegNum <a> ;
if $(a[1]) = "+" {
if $(a) = $(HAIKU_ZERO) {
return $(a) ;
}
return "-" $(a[2-]) ;
} else {
return "+" $(a[2-]) ;
}
}
rule AddNum a : b
{
# AddNum <a> : <b> ;
local signa = $(a[1]) ;
local signb = $(b[1]) ;
a = $(a[2-]) ;
b = $(b[2-]) ;
if $(signa) = $(signb) {
return $(signa) [ AddNumAbs $(a) : $(b) ] ;
} else {
local result ;
if [ NumGreaterAbs $(a) : $(b) ] {
result = $(signa) [ SubNumAbs $(a) : $(b) ] ;
} else {
result = $(signb) [ SubNumAbs $(b) : $(a) ] ;
}
return [ NormalizeNum $(result) ] ;
}
}
rule SubNum a : b
{
# SubNum <a> : <b> ;
return [ AddNum $(a) : [ NegNum $(b) ] ] ;
}
rule MultNumAbsDigit a : digit
{
# MultNumAbsDigit <a> : <digit> ;
local digitMultiples = $(HAIKU_DIGIT_MULT_$(digit)) ;
local digitCarries = $(HAIKU_DIGIT_MULT_CARRY_$(digit)) ;
local result ;
local carry = 0 ;
while $(a) || $(carry) != 0 {
# chop off the first digit
local da = $(a[1]:E=0) ;
a = $(a[2-]) ;
local dr = $(digitMultiples[1$(da)]) ;
# add carry to the resulting digit
if $(carry) {
local dra = $(HAIKU_DIGIT_ADD_$(dr)[1$(carry)]) ;
carry = $(HAIKU_DIGIT_GREATER_$(dr)[1$(dra)]:E=0) ;
dr = $(dra) ;
}
# new carry
carry = $(HAIKU_DIGIT_ADD_$(carry:E=0)[1$(digitCarries[1$(da)])]) ;
result += $(dr) ;
}
return $(result) ;
}
rule MultNum a : b
{
# MultNum <a> : <b> ;
# If one of the factors is 0, we save us computation and normalization.
if $(a) = $(HAIKU_ZERO) || $(b) = $(HAIKU_ZERO) {
return $(HAIKU_ZERO) ;
}
# get the sign for the result
local sign = "+" ;
if $(a[1]) != $(b[1]) {
sign = "-" ;
}
a = $(a[2-]) ;
b = $(b[2-]) ;
# multiply the individual digits of b with a and add up the result
local result = 0 ;
local prefix ;
while $(b) {
local db = $(b[1]) ;
b = $(b[2-]) ;
local adb = $(prefix) [ MultNumAbsDigit $(a) : $(db) ] ;
result = [ AddNumAbs $(result) : $(adb) ] ;
prefix += 0 ;
}
return $(sign) $(result) ;
}
rule NumGreater a : b
{
local signa = $(a[1]) ;
local signb = $(b[1]) ;
a = $(a[2-]) ;
b = $(b[2-]) ;
if $(signa) = $(signb) {
if $(signa) = "+" {
return [ NumGreaterAbs $(a) : $(b) ] ;
} else {
return [ NumGreaterAbs $(b) : $(a) ] ;
}
} else {
if $(signa) = "+" {
return 1 ;
} else {
return ;
}
}
}
# pragma mark - Number String Operations
rule Inc a
{
# Inc <number string a> ;
return [ Num2String [ AddNum [ Num $(a) ] : + 1 ] ] ;
}
rule Dec a
{
# Dec <number string a> ;
return [ Num2String [ AddNum [ Num $(a) ] : - 1 ] ] ;
}
rule Neg a
{
# Neg <number string a> ;
return [ Num2String [ NegNum [ Num $(a) ] ] ] ;
}
rule Add a : b
{
# Add <number string a> : <number string b> ;
return [ Num2String [ AddNum [ Num $(a) ] : [ Num $(b) ] ] ] ;
}
rule Sub a : b
{
# Sub <number string a> : <number string b> ;
return [ Num2String [ SubNum [ Num $(a) ] : [ Num $(b) ] ] ] ;
}
rule Mult a : b
{
# Mult <number string a> : <number string b> ;
return [ Num2String [ MultNum [ Num $(a) ] : [ Num $(b) ] ] ] ;
}
rule Equal a : b
{
# Equal <number string a> : <number string b> ;
if [ Num $(a) ] = [ Num $(b) ] {
return 1 ;
}
return ;
}
rule Less a : b
{
# Less <number string a> : <number string b> ;
return [ NumGreater [ Num $(b) ] : [ Num $(a) ] ] ;
}
rule Greater a : b
{
# Greater <number string a> : <number string b> ;
return [ NumGreater [ Num $(a) ] : [ Num $(b) ] ] ;
}
rule LessOrEqual a : b
{
# LessOrEqual <number string a> : <number string b> ;
if [ NumGreater [ Num $(a) ] : [ Num $(b) ] ] {
return ;
}
return 1 ;
}
rule GreaterOrEqual a : b
{
# GreaterOrEqual <number string a> : <number string b> ;
if [ NumGreater [ Num $(b) ] : [ Num $(a) ] ] {
return ;
}
return 1 ;
}
# pragma mark - Expression Parser
rule ParseAtom expression
{
# ParseAtom <expression> ;
# expression: '(' expression ')' | number
if $(expression[1]) = "(" {
local result = [ ParseExpression $(expression[2-]) ] ;
if $(result[2]) != ")" {
Exit "ParseAtom: Parse error: Expected \")\"." ;
}
return $(result[1]) $(result[3-]) ;
} else {
if ! $(expression) {
Exit "ParseAtom: Parse error: Unexpected end of expression." ;
}
local num = [ Num $(expression[1]) : 1 ] ;
if ! $(num) {
Exit "ParseAtom: Parse error: Expected number instead of:"
$(expression[1]) ;
}
return [ Num2String $(num) ] $(expression[2-]) ;
}
}
rule ParseUnary expression
{
# ParseUnary <expression> ;
# expression: ('+'/'-')* atom
if ! $(expression) {
Exit "ParseUnary: Parse error: Unexpected end of expression." ;
}
# eat all unary "+" and "-" operations
local neg ;
while $(expression[1]) = "+" || $(expression[1]) = "-" {
if $(expression[1]) = "-" {
if $(neg) {
neg = ;
} else {
neg = 1 ;
}
}
expression = $(expression[2-]) ;
}
local result = [ ParseAtom $(expression) ] ;
if $(neg) {
return [ Neg $(result[1]) ] $(result[2-]) ;
}
return $(result) ;
}
rule ParseTerm expression
{
# ParseTerm <expression> ;
# expression: unary ('*' unary)*
local result = [ ParseUnary $(expression) ] ;
local product = $(result[1]) ;
expression = $(result[2-]) ;
while $(expression[1]) = "*" {
# get the operation
local operation ;
operation = Mult ;
# parse the next operand
result = [ ParseUnary $(expression[2-]) ] ;
expression = $(result[2-]) ;
# compute the product
product = [ $(operation) $(product) : $(result[1]) ] ;
}
return $(product) $(expression) ;
}
rule ParseExpression expression
{
# ParseExpression <expression> ;
# expression: term ('+'/'-' term)*
local result = [ ParseTerm $(expression) ] ;
local sum = $(result[1]) ;
expression = $(result[2-]) ;
while $(expression[1]) = "+" || $(expression[1]) = "-" {
# get the operation
local operation ;
if $(expression[1]) = "+" {
operation = Add ;
} else {
operation = Sub ;
}
# parse the next operand
result = [ ParseTerm $(expression[2-]) ] ;
expression = $(result[2-]) ;
# compute the sum
sum = [ $(operation) $(sum) : $(result[1]) ] ;
}
return $(sum) $(expression) ;
}
rule Expr expression
{
# Expr <expression> ;
# tokenize the expression
local tokens ;
for string in $(expression) {
while $(string) {
local split = [ Match "[ \t]*(-|[()+*]|[0-9]*)(.*)" : $(string) ] ;
if ! $(split[1]) {
Exit "Expr: Syntax error: Invalid token: \"$(string)\"." ;
}
tokens += $(split[1]) ;
string = $(split[2]) ;
}
}
local result = [ ParseExpression $(tokens) ] ;
if $(result[2-]) {
Exit "Expr: Garbage at end of expression:" $(result[2-]) ;
}
return $(result[1]) ;
}