path: root/lib/Tcl.py

# An emulator for John Ousterhout's 'Tcl' language in Python (wow!).
# Currently only the most basic commands are implemented.
#
# Design choices:
#
# - Names used for functions are not exactly those used by C Tcl.
# In Python, names without 'Tcl_' prefix are acceptable because
# names are less global than in C (and often they are prefixed
# with a module name anyway). Parameter conventions also differ.
#
# - The Tcl Interpreter type is implemented using a Python class.
# Almost all functions with an Interpreter as first parameter are
# methods of this class.
# Applications can create derived classes to add additional commands
# or to override specific internal functions.
#
# - Tcl errors are mapped to Python exceptions.
# (I bet Ousterhout would have done the same in a language with
# a proper exception mechanism).
#
# - Tcl expressions are evaluated by Python's built-in function eval().
# This makes Python Tcl scripts incompatible with C Tcl scripts,
# but is the only sensible solution for a quick-and-dirty version.
# It also makes an escape to Python possible.
#
# - The Backslash function interprets \<newline>, since it
# can return a string instead of a character.


from TclUtil import *


# Exceptions used to signify 'break' and 'continue'

TclBreak = 'TclBreak'
TclContinue = 'TclContinue'
TclReturn = 'TclReturn'


class CmdBuf():
 #
 def Create(buffer):
 buffer.string = ''
 return buffer
 #
 def Assemble(buffer, str):
 buffer.string = buffer.string + str
 if buffer.string[-1:] = '\n':
 i, end = 0, len(buffer.string)
 try:
 while i < end:
 list, i = FindNextCommand( \
 buffer.string, i, end, 0)
 except TclMatchingError:
 return ''
 except TclSyntaxError:
 pass # Let Eval() return the error
 ret = buffer.string
 buffer.string = ''
 return ret
 else:
 return ''


class _Frame():
 def Create(frame):
 frame.locals = {}
 return frame

class _Proc():
 #
 def Create(proc, (interp, args, body)):
 proc.interp = interp
 proc.args = SplitList(args) # Do this once here
 proc.body = body
 return proc
 #
 def Call(proc, argv):
 if len(argv) <> len(proc.args)+1:
 raise TclRuntimeError, \
 'wrong # args to proc "' + \
 argv[0] + '"'
 # XXX No defaults or variable length 'args' yet
 frame = _Frame().Create()
 for i in range(len(proc.args)):
 frame.locals[proc.args[i]] = argv[i+1]
 proc.interp.stack.append(frame)
 try:
 value = proc.interp.Eval(proc.body)
 except TclReturn, value:
 pass
 del proc.interp.stack[-1:]
 return value


import regexp
_expand_prog = regexp.compile('([^[$\\]+|\n)*')
del regexp

class Interpreter():
 #
 def Create(interp):
 interp.globals = {}
 interp.commands = {}
 interp.stack = []
 interp.commands['break'] = interp.BreakCmd
 interp.commands['concat'] = interp.ConcatCmd
 interp.commands['continue'] = interp.ContinueCmd
 interp.commands['echo'] = interp.EchoCmd
 interp.commands['eval'] = interp.EvalCmd
 interp.commands['expr'] = interp.ExprCmd
 interp.commands['for'] = interp.ForCmd
 interp.commands['glob'] = interp.GlobCmd
 interp.commands['global'] = interp.GlobalCmd
 interp.commands['if'] = interp.IfCmd
 interp.commands['index'] = interp.IndexCmd
 interp.commands['list'] = interp.ListCmd
 interp.commands['proc'] = interp.ProcCmd
 interp.commands['rename'] = interp.RenameCmd
 interp.commands['return'] = interp.ReturnCmd
 interp.commands['set'] = interp.SetCmd
 return interp
 #
 def Delete(interp):
 #
 # Only break circular references here;
 # most things will be garbage-collected.
 #
 for name in interp.commands.keys():
 del interp.commands[name]
 #
 def CreateCommand(interp, (name, proc)):
 interp.commands[name] = proc
 #
 def DeleteCommand(interp, (name)):
 del interp.commands[name]
 #
 # Local variables are maintained on the stack.
 # A local variable with value "None" is a dummy
 # meaning that the corresponding global variable
 # should be used.
 #
 def GetVar(interp, varName):
 dict = interp.globals
 if interp.stack:
 d = interp.stack[-1:][0].locals
 if d.has_key(varName) and d[varName] = None:
 pass
 else:
 dict = d
 if not dict.has_key(varName):
 raise TclRuntimeError, \
 'Variable "' + varName + '" not found'
 return dict[varName]
 #
 def SetVar(interp, (varName, newValue)):
 dict = interp.globals
 if interp.stack:
 d = interp.stack[-1:][0].locals
 if d.has_key(varName) and d[varName] = None:
 pass
 else:
 dict = d
 dict[varName] = newValue
 #
 def Expand(interp, (str, i, end)):
 if end <= i: return ''
 if str[i] = '{' and str[end-1] = '}':
 return str[i+1:end-1]
 if str[i] = '"' and str[end-1] = '"':
 i, end = i+1, end-1
 result = ''
 while i < end:
 c = str[i]
 if c = '\\':
 x, i = Backslash(str, i, end)
 result = result + x
 elif c = '[':
 j = BalanceBrackets(str, i, end)
 x = interp.EvalBasic(str, i+1, j-1, 1)
 result = result + x
 i = j
 elif c = '$':
 i = i+1
 j = FindVarName(str, i, end)
 name = str[i:j]
 i = j
 if not name:
 result = result + '$'
 else:
 if name[:1] = '{' and name[-1:] = '}':
 name = name[1:-1]
 result = result + interp.GetVar(name)
 else:
 j = _expand_prog.exec(str, i)
 j = min(j, end)
 result = result + str[i:j]
 i = j
 return result
 #
 def EvalBasic(interp, (str, i, end, bracketed)):
 result = ''
 while i < end:
 indexargv, i = FindNextCommand( \
 str, i, end, bracketed)
 if indexargv:
 argv = []
 for x, y in indexargv:
 arg = interp.Expand(str, x, y)
 argv.append(arg)
 name = argv[0]
 if not interp.commands.has_key(name):
 raise TclRuntimeError, \
 'Command "' + name + \
 '" not found'
 result = interp.commands[name](argv)
 return result
 #
 def Eval(interp, str):
 return interp.EvalBasic(str, 0, len(str), 0)
 #
 def ExprBasic(interp, (str, begin, end)):
 expr = interp.Expand(str, begin, end)
 i = SkipSpaces(expr, 0, len(expr))
 expr = expr[i:]
 try:
 return eval(expr, {})
 except (NameError, TypeError, RuntimeError, EOFError), msg:
 import sys
 raise TclRuntimeError, sys.exc_type + ': ' + msg
 #
 def Expr(interp, str):
 return interp.ExprBasic(str, 0, len(str))
 #
 # The rest are command implementations
 #
 def BreakCmd(interp, argv):
 if len(argv) <> 1:
 raise TclRuntimeError, 'usage: break'
 raise TclBreak
 #
 def ConcatCmd(interp, argv):
 if len(argv) < 2:
 raise TclRuntimeError, 'usage: concat arg ...'
 return Concat(argv[1:])
 #
 def ContinueCmd(interp, argv):
 if len(argv) <> 1:
 raise TclRuntimeError, 'usage: continue'
 raise TclContinue
 #
 def EchoCmd(interp, argv):
 for arg in argv[1:]: print arg,
 print
 return ''
 #
 def EvalCmd(interp, argv):
 if len(argv) < 2:
 raise TclRuntimeError, 'usage: eval arg [arg ...]'
 str = Concat(argv[1:])
 return interp.Eval(str)
 #
 def ExprCmd(interp, argv):
 if len(argv) <> 2:
 raise TclRuntimeError, 'usage: expr expression'
 expr = argv[1]
 result = interp.Expr(expr)
 if type(result) <> type(''): result = `result`
 return result
 #
 def ForCmd(interp, argv):
 if len(argv) <> 5:
 raise TclRuntimeError, \
 'usage: for start test next body'
 x = interp.Eval(argv[1])
 while interp.Expr(argv[2]):
 try:
 x = interp.Eval(argv[4])
 except TclBreak:
 break
 except TclContinue:
 pass
 x = interp.Eval(argv[3])
 return ''
 #
 def GlobCmd(interp, argv):
 import macglob
 if len(argv) < 2:
 raise TclRuntimeError, 'usage: glob pattern ...'
 list = []
 for pat in argv[1:]:
 list = list + macglob.glob(pat)
 if not list:
 raise TclRuntimeError, 'no match for glob pattern(s)'
 return BuildList(list)
 #
 def GlobalCmd(interp, argv):
 if len(argv) < 2:
 raise TclRuntimeError, 'usage: global varname ...'
 if not interp.stack:
 raise TclRuntimeError, 'global used outside proc'
 dict = interp.stack[-1:][0].locals
 for name in argv[1:]:
 dict[name] = None
 return ''
 #
 def IfCmd(interp, argv):
 argv = argv[:]
 if len(argv) > 2 and argv[2] = 'then': del argv[2]
 if len(argv) > 3 and argv[3] = 'else': del argv[3]
 if not 3 <= len(argv) <= 4:
 raise TclRuntimeError, \
 'usage: if test [then] trueBody [else] falseBody'
 if interp.Expr(argv[1]):
 return interp.Eval(argv[2])
 if len(argv) > 3:
 return interp.Eval(argv[3])
 return ''
 #
 def IndexCmd(interp, argv):
 if len(argv) <> 3:
 raise TclRuntimeError, 'usage: index value index'
 import string
 try:
 index = string.atoi(argv[2])
 if index < 0: raise string.atoi_error
 except string.atoi_error:
 raise TclRuntimeError, 'bad index: ' + argv[2]
 list = SplitList(argv[1])
 if index >= len(list): return ''
 return list[index]
 #
 def ListCmd(interp, argv):
 if len(argv) < 2:
 raise TclRuntimeError, 'usage: list arg ...'
 return BuildList(argv[1:])
 #
 def ProcCmd(interp, argv):
 if len(argv) <> 4:
 raise TclRuntimeError, 'usage: proc name args body'
 x = _Proc().Create(interp, argv[2], argv[3])
 interp.CreateCommand(argv[1], x.Call)
 return ''
 #
 def RenameCmd(interp, argv):
 if len(argv) <> 3:
 raise TclRuntimeError, 'usage: rename oldName newName'
 oldName, newName = argv[1], argv[2]
 if not interp.commands.has_key(oldName):
 raise TclRuntimeError, \
 'command "' + oldName + '" not found'
 if newName: interp.commands[newName] = interp.commands[oldName]
 del interp.commands[oldName]
 return ''
 #
 def ReturnCmd(interp, argv):
 if not 1 <= len(argv) <= 2:
 raise TclRuntimeError, 'usage: return [arg]'
 if len(argv) = 1: raise TclReturn, ''
 raise TclReturn, argv[1]
 #
 def SetCmd(interp, argv):
 n = len(argv)
 if not 2 <= n <= 3:
 raise TclRuntimeError, 'usage: set varname [newvalue]'
 if n = 2: return interp.GetVar(argv[1])
 interp.SetVar(argv[1], argv[2])
 return ''


# The rest are just demos:

def MainLoop(interp):
 buffer = CmdBuf().Create()
 if not interp.globals.has_key('ps1'): interp.globals['ps1'] = '% '
 if not interp.globals.has_key('ps2'): interp.globals['ps2'] = ''
 psname = 'ps1'
 while 1:
 try:
 line = raw_input(interp.globals[psname])
 except (EOFError, KeyboardInterrupt):
 print
 break
 line = buffer.Assemble(line + '\n')
 if not line:
 psname = 'ps2'
 else:
 psname = 'ps1'
 try:
 x = interp.Eval(line)
 if x <> '': print 'Result:', `x`
 except (TclRuntimeError, TclSyntaxError, \
 TclMatchingError), msg:
 print 'Error:', msg
 except (TclBreak, TclContinue):
 print 'Error: break or continue outside loop'
 except TclReturn, value:
 # Return outside proc returns to main loop
 if value: print value


the_interpreter = Interpreter().Create()

def main():
 MainLoop(the_interpreter)


# XXX To do:
# for proc: "args" and default arguments
# More commands:
# case
# uplevel
# info
# string
# list operations
# error, catch
# print
# scan, format
# source
# history?
# others?