pythonica/pythonica.py at master · tklink/pythonica

479 lines (444 loc) · 13.3 KB
"""	Pythonica.py

This module does input and output parsing.  All the real work is done
by PythonicaCore.
"""

import string
import re
import sys
from pythonicacore import *

gEntryNum = 1
gSymToName = {}
gNameToSym = {}
gNameToPrec = {}
gNonchainable = ('ReplaceAll','Rule','Power','Minus','Divide')
# note: instead of just "nonchainable", we should note whether
# each function groups left, groups right, or chains
# (compare -> and /. in Mathematica; right and left, resp.)

#----------------------------------------------------------------------
def buildOperTables():
	global gSymToName, gNameToPrec
	ops = ( '/.',	'ReplaceAll',
			'->',	'Rule',
			'==',	'Equal',
			'=',	'Set',
			'=.',	'Unset',
			'+',	'Plus',
			'-',	'Minus',
			'*',	'Times',
			'/',	'Divide',
			'^',	'Power')
	for i in range(0,len(ops)/2):
		gSymToName[ops[i*2]] = ops[i*2+1]
		gNameToSym[ops[i*2+1]] = ops[i*2]
		gNameToPrec[ops[i*2+1]] = i
buildOperTables()

#----------------------------------------------------------------------
def endOfExpr(s):
	# return the position at which this token ends
	# it may be delimited by a delimiter, or the end of the string
	p = 0
	maxp = len(s)
	while p < maxp:
		# check for non-alphanumeric chars
		if not s[p].isalnum() and s[p] not in ['[','(','.']:
			return p
#		# check for one-char opers
#		if s[p] in (gSymToName.keys() + [',',' ']):
#			#if p>0: return p
#			return p
#		# check for two-char opers
#		if p < maxp-1 and s[p:p+2] in gSymToName.keys():
#			return p

		# check for groupings...
		if s[p] == '[':					# if we start a '[...]',
			# make sure this isn't a slice
			if p > 0 and s[p+1] == '[':
				# it's a slice
				return p
			nest = 1
			while nest:					# ...finish it
				p += 1
				if s[p] == '[': nest += 1
				if s[p] == ']': nest -= 1
			return p + 1
		if s[p] == '(':					# if we start a '(...)',
			if p == 0:					# Make sure we're at the beginning of the string
				nest = 1
				while nest:					# ...finish it
					p = p + 1
					if s[p] == '(': nest = nest + 1
					if s[p] == ')': nest = nest - 1
				return p + 1
			else:
				# We're in the middle of the string. End the token now
				return p
		p += 1
	return p

#----------------------------------------------------------------------
def endOfArg(s):
	# returns the position where this argument ends
	# an argument ends on a comma or end of string, ignoring commas in groups
	p = 0
	maxp = len(s)
	while p < maxp:
		if s[p] == ',':
			return p
		
		if s[p] == '[':
			nest = 1
			while nest:
				p += 1
				if s[p] == '[': nest += 1
				if s[p] == ']': nest -= 1
		if s[p] == '(':
			nest = 1
			while nest:
				p += 1
				if s[p] == '(': nest += 1
				if s[p] == ')': nest -= 1
		p += 1
	return p

#----------------------------------------------------------------------
def splitExprs(s):
	# split on delimiters, ignoring those nested in '[...]' or '(...)'
	outexpr = []
	outdelim = []
	while s:
		end = endOfExpr(s)
		outexpr.append(s[:end])
		if end >= len(s):
			outdelim.append('')
		elif s[end:end+2] in ['[[',']]']:
			outdelim.append(s[end])
		elif s[end:end+2] in gSymToName.keys():
			outdelim.append(s[end:end+2])
		elif s[end] in gSymToName.keys():
			outdelim.append(s[end])
		elif not s[end].isalnum():
			outdelim.append(s[end])
		else:
			outdelim.append('*')
			end -= 1
		s = s[end+len(outdelim[-1]):]
	return outexpr,outdelim

#----------------------------------------------------------------------
def splitArgs(s):
	# split arguments - split on commas, skipping groups
	outexpr = []
	while s:
		end = endOfArg(s)
		outexpr.append(s[:end])
		s = s[end+1:]
	return outexpr
		

#----------------------------------------------------------------------
def subPercent(s):
	"""subPercent(s): replace one '%' with Out[-1],
	'%%' with the Out[-2], etc., and %n (where n is
	an integer) with the Out[n]."""
	while 1:
		l = len(s)
		pos = s.find('%')
		if pos < 0: return s
		cnt = 1
		while pos+cnt < l and s[pos+cnt] in '%0123456789':
			cnt = cnt+1
		substr = s[pos:pos+cnt]
		if len(substr) > 1 and substr[1] != '%':
			rep = 'Out[' + substr[1:] + ']'
		else:
			rep = 'Out[-' + str(len(substr)) + ']'
		s = s[:pos] + rep + s[pos+cnt:]

#----------------------------------------------------------------------
def stripSpaces(s):
	"""stripSpaces(s): strip all spaces from the input string,
	except that if a space occurs between any combination of
	numbers and symbols, convert it to '*'."""
	
	out = ''
	hadsym = 0		# flag: did we just have a symbol or number?
	hadspace = 1	# flag: did we just have some whitespace?
	symchars = string.letters + string.digits
	for c in s:
		if c != ' ':
			if hadspace:
				# we just had a space...
				if c in symchars:
					# and now we see a symbol
					# if we had a symbol before that, throw in a '*'
					if hadsym: out = out + '*'
			hadsym = (c in symchars)
			out = out + c
			hadspace = 0
		else:
			hadspace = 1
	return out

#----------------------------------------------------------------------
def isNumber(s):
	# detect if s is a number - allows negative sign and a single period
	if len(s) == 0:
		return False
	if s[0] == '-': s = s[1:]
	if s.find('.') != s.rfind('.'):
		# too many periods
		return False
	for char in s:
		if char not in "0123456789.":
			return False
	return True

#----------------------------------------------------------------------
def parseOneExpr(s):
	"""parseOneExpr(s): build one token from the string s.
	This string should immediately be a token, and contain no
	paretheses, operators, etc., except within arguments."""
	
	wip = []
	# get first token
	delim = re.search(r'[][, ]', s)
	if not delim:
		delim = -1
		token = s
		delimchar = '\n'
	else:
		delim = delim.span()[0]
		token = s[:delim]
		delimchar = s[delim]
	expr = None
	
	# do we have a FullForm expression (e.g., Head[args])?
	if delimchar == '[':
		# check for a list
		if token == '':
			expr = ExprList()
		else:
			# check for a built-in symbol; otherwise, use ExprSymbol
			try: expr = eval('Expr' + token + '()' )
			except: expr = Expr([],token)
		# ...find all the elements for this expression
		estr = s[:endOfExpr(s)+1]
		estr = estr[delim+1:-1]
		estrlist = splitArgs(estr)
#		print "args:", estrlist
		expr.setData(map(parse, estrlist))

	# if not, then do we have a number?
#	elif token[0] in '0123456789' or (len(token)>1 and \
#		 token[0] == '-' and token[1] in '0123456789'):
#		# a Number...
#		expr = ExprNumber(float(token))
	elif isNumber(token):
		# A number...
		expr = ExprNumber(float(token))
	
	# if not, do we have a complex number?
	elif token[-1] == 'j' and (len(token) == 1 or isNumber(token[:-1])):
		# A complex number...
		if len(token) == 1:
			expr = ExprComplex((0,1))
		else:
			expr = ExprComplex((0,float(token[:-1])))

	# if neither of those, then it must be a symbol
	else:
		# a Symbol...
		# Symbols can't start with numbers, tho
		if token[0].isdigit() or (token[0] == '-' and token[1].isdigit()):
			raise "Symbol::parse", "Symbols can't start with a digit."
		expr = ExprSymbol(token)
	return expr

#----------------------------------------------------------------------
def parse(s):
	global gSymToName, gNameToPrec, gNonchainable
	# split into tokens...
	estrlist,delimlist = splitExprs(s)
	# crawl through tokens, combining where operators are found
	wip = []			# stack of expressions
#	print "estrlist:", estrlist
#	print "delimlist:", delimlist
	
	# evaluate each token, considering its following delimiter
	for i in range(0,len(estrlist)):
		if estrlist[i]:
			if estrlist[i][0] == '(':
				# if we have parentheses, parse their contents!
				expr = parse(estrlist[i][1:-1])
			else:
				# otherwise, load a single expression
				expr = parseOneExpr(estrlist[i])
		else: expr = None

		if delimlist[i] in gSymToName.keys():
			# we have an operator...
			opername = gSymToName[delimlist[i]]
			try:
				operclass = eval('Expr' + opername)
			except:
				raise "Bug", "Undefined operator " + opername

			if not wip:
				# first expression we've seen; throw it on the stack
				wip.append(operclass(expr))

			elif not wip[-1].Head():
				# current expression is headless -- make it us
				wip[-1].head = opername
				if expr: wip[-1].data.append(expr)

			elif wip[-1].Head() == opername and opername not in gNonchainable:
				# same operator; append to previous data
				wip[-1].data.append(expr)

			else:
				# figure out where to stuff token,
				# according to precedence rules
				myPrecedence = gNameToPrec[opername]
				curPrecedence = gNameToPrec[wip[-1].Head()]
				if curPrecedence < myPrecedence:
					# current head has lower precedence... start a new level
#					print opername, "higher than", wip[-1].Head()
					wip.append(operclass(expr))
					wip[-2].data.append(wip[-1])
				else:
					# current head has higher precedence...
					# add expr to current, then move it within us
#					print opername, "lower than", wip[-1].Head()
					if expr: wip[-1].data.append(expr)
					which = len(wip)-2
					while which >= 0:
						if gNameToPrec[ wip[which].Head() ] >= myPrecedence:
#							print "...lower than", wip[which].Head()
							pass
						else:
#							print "...but not lower than", wip[which].Head()
							break
						which -= 1
					which += 1 # we want to wrap around one level higher
#					print "Stuffing around wip", which
					if wip[which].Head() != opername or opername in gNonchainable:
						if which == 0:
							wip[0] = operclass(wip[0])
							del wip[1:]
						else:
							wip[which-1].data[-1] = operclass(wip[which-1].data[-1])
							wip[which] = wip[which-1].data[-1]
					else:
						# get rid of wip entries above which
						del wip[which+1:]
		elif delimlist[i] == '[':
			# we have a slice
			expr = ExprSlice(expr)
			if wip:
				wip[-1].data.append(expr)
			wip.append(expr)
		elif delimlist[i] == ']':
			# end of slice
			args = parse(estrlist[i])
			if args.Head() != 'List': # this should never happen
				raise 'parse::syntax', "Syntax error after token '%s'." % estrlist[i]
			wip[-1].data.append(args.data)
		elif delimlist[i] == '':
			if not wip:
				wip.append(expr)
			else:
				wip[-1].data.append(expr)
		else:
			raise "parse::operators", "Undefined operator '%s'." % delimlist[i]
#		print "wip:", tostr(wip)
	if len(wip) >= 1:
		return wip[0]
	else:
		return None

#----------------------------------------------------------------------
def unparse(expr, leftprec=-1, rightprec=-1):
	# is this expression something we have an operator for?
	head = expr.Head()
	if head not in gNameToPrec.keys():
		# nope, no operator... just print normally
		out = str(expr)
		return out
	# yep, we have an operator... get it, and its precedence
	prec = gNameToPrec[head]
	# (for readability, we'll code a couple of formatting hacks)
	op = gNameToSym[head]
	if op == '*': op = ' '
	elif op != '^': op = ' ' + op + ' '
	# combine data using operator -- pass precedence info
	out = ''
	# leftmost argument gets has our left, and us for the right
	if len(expr.data) > 0:
		if len(expr.data) == 1: r = rightprec
		else: r = prec
		out = unparse(expr.data[0],leftprec,r)
	# middle arguments have us on both left and right
	if len(expr.data) > 2:
		out = out + op + \
		  op.join(map(lambda x,p=prec:unparse(x,p,p),expr.data[1:-1]))
	# last argument has our right, and us for the left
	if len(expr.data) > 1:
		out = out + op + \
				unparse(expr.data[-1],prec,rightprec)
	# use parenthesis if we're lower precedence than our neighbors
	if prec < leftprec or prec < rightprec:
		out = '(' + out + ')'
	return out

#----------------------------------------------------------------------
def handleInput(s, surpressOutput=0):
	"""handleInput(s, surpressOutput=0): handle the given input,
	generating output if the second parameter is 0.  Return a
	tuple of (input-expr, output-expr)."""
	
	s = stripSpaces(subPercent(s))
	if s:
		inexp = parse(s)
		if inexp != None:
			eval = inexp.Eval()
			if surpressOutput:
				simp = eval.Simplify()
				while simp != eval:
					eval = simp
					simp = eval.Simplify()
			else:
				print
				print "in FullForm:", inexp
				print "evaluates to:", eval
				# now simplify
				simp = eval.Simplify()
				while simp != eval:
					print "simplifies to:", simp
					eval = simp
					simp = eval.Simplify()
			return inexp,simp
	return None,None

#----------------------------------------------------------------------
def mainLoop():
	global gEntryNum
	s = 'foo'
	while s:
		inexp = None
		outexp = None
		try:
			numstr = '[' + str(gEntryNum) + ']'
			s = raw_input("In" + numstr + " :=   ")
			# break on ';' and surpress output for all but the last
			commands = s.split(";")
			for c in commands[:-1]:
				inexp,outexp = handleInput(c,1)
			# on the last one, don't surpress output
			if commands[-1]:
				inexp,outexp = handleInput(commands[-1])
				if outexp:
					print
					print "Out" + numstr, "=  ", unparse(outexp)
		except EOFError:
			raise
		except:
			# only display the message and keep going if this is the main module
			info = sys.exc_info()
			if __name__ == '__main__':
				if not isinstance(info[0], types.ClassType):
					print "%s: %s" % info[:2]
				else:
					print "Syntax Error"
			else:
				raise
		print
		
		# Turn the inexp/outexp into a None expression if they're None
		if inexp == None:
			inexp = Expr()
		if outexp == None:
			outexp = Expr()
		# store the in/out data for future reference
		StoreInOut( inexp,outexp )
		gEntryNum = gEntryNum + 1

#----------------------------------------------------------------------

if __name__ == '__main__':
	try:
		mainLoop()
		raw_input("Press Return.")
	except EOFError:
		print "" # print a newline
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Expand file tree

Search code, repositories, users, issues, pull requests...

FilesExpand file tree

pythonica.py

Latest commit

History

pythonica.py

File metadata and controls

Expand file tree
