Arithmetic evaluation: Difference between revisions

→‎{{header|Python}}: remove unneeded code
(→‎{{header|Ada}}: Incorrect heading)
(→‎{{header|Python}}: remove unneeded code)
Line 1,196:
return self.opr(self.l.eval(), self.r.eval())
 
class EPLeafNode(object):
def __init__( self, valStrg ):
self.v = int(valStrg)
Line 1,211:
def v1( self, valStrg ):
# Value String
self.nodestak.append( EPLeafNode(valStrg))
self.__dict__.update(self.state2)
# print 'push', valStrg
 
def o1o2( self, operchar ):
# Operator character or open paren in state1
print 'parse error: near operator %s' % operchar
def po1( self, operchar ):
# Open Parenthesis
def openParen(a,b):
return 0 # function should not be called
# hide precidence level of previous operator
self.operstak.append( (openParen, 0) )
self.__dict__.update(self.state1)
def pc1( self,operchar ):
# Close Parenthesis
print 'parse error - near operator ")"'
 
opDict= { '+': ( operator.add, 12, 2 ),
def v2( self, valStrg ):
'-': (operator.sub, 12, 2 ),
# Value String
print 'parse error -'*': near(operator.mul, %s '3, %3 valStrg),
'/': (operator.div, 23, 3 ),
self.topValue = EP(valStrg)
'^': ( pow, 4, 5 ), # right associative exponentiation for grins
 
def o2 '(': self( openParen, operchar 0, 8 ):
# Operator character
opDict= { '+': ( operator.add, 1 ),
'-': (operator.sub, 1 ),
'*': (operator.mul, 2 ),
'/': (operator.div, 2 ),
}
operPrecoperPrecidence = opDict[operchar][12]
while len(self.operstakredeuce(operPrecidence)>0:
tailOper = self.operstak[len(self.operstak)-1]
if tailOper[1] < operPrec: break
self.redeuce()
 
self.operstak.append(opDict[operchar])
self.__dict__.update(self.state1)
# print 'pushop', operchar
 
def po2syntaxErr(self, char ):
# Open Parenthesis
print 'parse error - near operator "(%s"' %char
 
def pc2( self,operchar ):
# Close Parenthesis
# reduce node until matching open paren found
while len(self.operstakredeuce( 1 )>0:
tailOper = self.operstak[len(self.operstak)-1]
if tailOper[1] == 0: break
self.redeuce()
if len(self.operstak)>0:
self.operstak.pop() # pop off open parenthesis
Line 1,271 ⟶ 1,249:
 
def end(self):
self.redeuce(0)
return self.redeucenodestak.pop()
 
def po1redeuce( self, operchar precidence):
while len(self.operstak)>0:
tailOper = self.redeuceoperstak[len(self.operstak)-1]
if tailOper[1] < operPrecprecidence: break
return self.nodestak.pop()
 
def redeuce( tailOper = self.operstak.pop():
tailOper vrgt = self.operstaknodestak.pop()
vrgt vlft= self.nodestak.pop()
vlft= self.nodestak.popappend( AstNode(tailOper[0], vlft, vrgt))
# print 'reduce'
self.nodestak.append( AstNode(tailOper[0], vlft, vrgt))
# print 'reduce'
 
state1 = { 'v': v1, 'o':o1syntaxErr, 'po':po1o2, 'pc':pc1syntaxErr }
state2 = { 'v': v2syntaxErr, 'o':o2, 'po':po2syntaxErr, 'pc':pc2 }
 
 
Line 1,291 ⟶ 1,272:
for c in exprssn:
cp += 1
if c in '+-/*^()': # throw in exponentiation (^)for grins
if bgn is not None:
p.v(p, exprssn[bgn:cp])
Anonymous user