panelparser.py

minimal python variant for small footprint apps like embedded apps

# Module 'parser'
#
# Parse S-expressions output by the Panel Editor
# (which is written in Scheme so it can't help writing S-expressions).
#
# See notes at end of file.


whitespace = ' \t\n'
operators = '()\''
separators = operators + whitespace + ';' + '"'


# Tokenize a string.
# Return a list of tokens (strings).
#
def tokenize_string(s):
	tokens = []
	while s:
		c = s[:1]
		if c in whitespace:
			s = s[1:]
		elif c == ';':
			s = ''
		elif c == '"':
			n = len(s)
			i = 1
			while i < n:
				c = s[i]
				i = i+1
				if c == '"': break
				if c == '\\': i = i+1
			tokens.append(s[:i])
			s = s[i:]
		elif c in operators:
			tokens.append(c)
			s = s[1:]
		else:
			n = len(s)
			i = 1
			while i < n:
				if s[i] in separators: break
				i = i+1
			tokens.append(s[:i])
			s = s[i:]
	return tokens


# Tokenize a whole file (given as file object, not as file name).
# Return a list of tokens (strings).
#
def tokenize_file(fp):
	tokens = []
	while 1:
		line = fp.readline()
		if not line: break
		tokens = tokens + tokenize_string(line)
	return tokens


# Exception raised by parse_exr.
#
syntax_error = 'syntax error'


# Parse an S-expression.
# Input is a list of tokens as returned by tokenize_*().
# Return a pair (expr, tokens)
# where expr is a list representing the s-expression,
# and tokens contains the remaining tokens.
# May raise syntax_error.
#
def parse_expr(tokens):
	if (not tokens) or tokens[0] <> '(':
		raise syntax_error, 'expected "("'
	tokens = tokens[1:]
	expr = []
	while 1:
		if not tokens:
			raise syntax_error, 'missing ")"'
		if tokens[0] == ')':
			return expr, tokens[1:]
		elif tokens[0] == '(':
			subexpr, tokens = parse_expr(tokens)
			expr.append(subexpr)
		else:
			expr.append(tokens[0])
			tokens = tokens[1:]


# Parse a file (given as file object, not as file name).
# Return a list of parsed S-expressions found at the top level.
#
def parse_file(fp):
	tokens = tokenize_file(fp)
	exprlist = []
	while tokens:
		expr, tokens = parse_expr(tokens)
		exprlist.append(expr)
	return exprlist


# EXAMPLE:
#
# The input
#	'(hip (hop hur-ray))'
#
# passed to tokenize_string() returns the token list
#	['(', 'hip', '(', 'hop', 'hur-ray', ')', ')']
#
# When this is passed to parse_expr() it returns the expression
#	['hip', ['hop', 'hur-ray']]
# plus an empty token list (because there are no tokens left.
#
# When a file containing the example is passed to parse_file() it returns
# a list whose only element is the output of parse_expr() above:
#	[['hip', ['hop', 'hur-ray']]]


# TOKENIZING:
#
# Comments start with semicolon (;) and continue till the end of the line.
#
# Tokens are separated by whitespace, except the following characters
# always form a separate token (outside strings):
#	( ) '
# Strings are enclosed in double quotes (") and backslash (\) is used
# as escape character in strings.