-í
!~L=c       s†     d  Z    d k Z  d k T d k l Z  d k T e d „ Z + d d „ Z 8 e d „ Z	 I d e
 f d	 „  ƒ  YZ d S(
   sL   Contains most of the real work of evaluating expressions & calling functionsN(   s   *(   s   dbgsc    sd     | t j o  t i } n  t d |  t |  ƒ | f IJ t |  t	 ƒ o*  |  | j o  | |  Sn  |  Sn  |  d | i
 j o8  t d |  d IJ | i
 |  d i |  d ƒ Sn   d } ! t |  | | ƒ " t d |  IJ$ x: t | t |  ƒ ƒ D$ ]  } % t |  | | ƒ |  | <qW' t |  d |  d ƒ }  ( |  Sd S(   sP  That's expression, namespace, where ns is a table of string-to-atom
        mappings.
    expr can be a string, a LispList
    It gets recursively evaluated, the first elt getting
    called.  And namespace substitution happens, too.

    THIS FUNCTION IS NOT COPY SAFE needs a writable copy of expr!!!
        But ns is read-only.
    s'   EvalExpr begin: %s, %s and namespace=%si    s?   EvalExpr: '%s' is a macro, not recursively evaluating elements.i   s    EvalExpr: After substitution: %sN(   s   interpers   Nones   interpreters   the_interpers   dbgss   exprs   types   nss
   isinstances   strs   builtin_macross   Calls	   startfroms
   Substitutes   ranges   lens   is   EvalExprs   CallFunction(   s   exprs   nss   interpers   is	   startfrom(    (    s   ./evaller.pys   EvalExpr s&   	  #	 	i   c  	  sè   + , - xØ t  | t |  ƒ ƒ D- ]¾ } . t |  | t ƒ o| / t d |  | IJ0 |  | | j oB 1 t d | |  | |  | f IJ2 d | |  | g |  | <n 4 t d IJn& 6 t	 o t |  | t
 ƒ p t ‚ q Wd S(   s2   Does namespace substitution on lispList, in-place.s&   thinking about substitutions for %s...s   	substituting %s for %s!s   quotes   	not subbing.N(   s   ranges	   startfroms   lens   lispLists   is
   isinstances   strs   dbgss   nss	   __debug__s   lists   AssertionError(   s   lispLists   nss	   startfroms   i(    (    s   ./evaller.pys
   Substitute+ s    	#c    s˜   8 < > | t j o ? t i } n @ |  | i j o A | i |  } n8 B |  | i j o C | i |  } n E t d |  ‚ F | i	 | ƒ Sd S(   sÄ   Does function-namespaces lookup and then calls the correct function.
    It's expected that the function's arguments have already been resolved,
    that is, you only call this from EvalExpr.
    s   Unknown function name '%s'!N(   s   interpers   Nones   interpreters   the_interpers   fnNames   builtin_functionss   fns   defined_functionss   LispExceptions   Calls   args(   s   fnNames   argss   interpers   fn(    (    s   ./evaller.pys   CallFunction8 s   s   LispFunctionc      sA   I d  Z  M O d d „ Z V d „  Z \ d „  Z d d „  Z RS(   s–   This is a function defined in Lisp, as opposed to a BuiltinFunction
    that's implemented in Python.

    However, they both have the same interface.s   < no name ever given :( >c    sL   O P | |  _  Q | |  _ R | |  _ S t d IJT t d t ƒ  IJd  S(   Ns   New LispFunction created.s8     %(lispname)s, params=%(params)s, evals_to=%(evals_to)s(   s   paramss   selfs   evals_tos   lispnames   dbgss   vars(   s   selfs   paramss   evals_tos   lispname(    (    s   ./evaller.pys   __init__O s
   c    sd   V W X t  | ƒ t  |  i ƒ j o; Y d |  i t  | ƒ t  |  i ƒ f } [ t | ƒ ‚ n d S(   s   Helper for Call()s*   Call died!, '%s' got %d args but wants %d!N(   s   lens   argss   selfs   paramss   lispnames	   error_msgs   LispException(   s   selfs   argss	   error_msg(    (    s   ./evaller.pys	   checkargsV s   (c    s,   \ ` a t  |  i | ƒ } b t | ƒ Sd S(   s}   Helper for Call()
        Example:  If params=['a','b'] and args=[1, 2],
            then we return { 'a':1, 'b':2 }
        N(   s   zips   selfs   paramss   argss   itemss   dict(   s   selfs   argss   items(    (    s   ./evaller.pys   make_namespace\ s   c  
  s®   d e f |  i | ƒ g t d |  i | t | ƒ f IJi |  i | ƒ } j t d |  i | f IJl t t	 |  i
 ƒ | ƒ } m t d |  i | t | ƒ f IJo | Sd S(   s;   Precondition: args have already been recursively evaluated!s   %s's Call() begin: args=%s  %ss!   %s's Call(): created namespace=%ss   %s's Call(): returning %s %sN(   s   selfs	   checkargss   argss   dbgss   lispnames   types   make_namespaces   thisCallsNamespaces   EvalExprs   deepcopys   evals_tos   eval_result(   s   selfs   argss   thisCallsNamespaces   eval_result(    (    s   ./evaller.pys   Calld s   ##(   s   __doc__s   __init__s	   checkargss   make_namespaces   Call(    (    (    s   ./evaller.pys   LispFunctionI s
   	(   s   __doc__s   interpreters	   lisp_excss   debugs   dbgss   copys   Nones   EvalExprs
   Substitutes   CallFunctions   objects   LispFunction(   s   dbgss   EvalExprs   CallFunctions   LispFunctions   interpreters
   Substitute(    (    s   ./evaller.pys   ? s   

#
