[Wisp-cvs] wisp/users/dig tran-builtins,1.19,1.20 tran.py,1.91,1.92

[<di...@us...>]

Update of /cvsroot/wisp/wisp/users/dig
In directory sc8-pr-cvs1:/tmp/cvs-serv9695

Modified Files:
	tran-builtins tran.py 
Log Message:
replaced Meaning by interpreter.meaning

Index: tran-builtins
===================================================================
RCS file: /cvsroot/wisp/wisp/users/dig/tran-builtins,v
retrieving revision 1.19
retrieving revision 1.20
diff -u -d -r1.19 -r1.20
--- tran-builtins	17 May 2003 10:43:54 -0000	1.19
+++ tran-builtins	17 May 2003 10:54:46 -0000	1.20
@@ -77,8 +77,8 @@
         raise 'too long argument pattern', interpreter.regstack
     name = ' '.join([name] + [matchers(i).next() for i in interpreter.regstack])
     interpreter.regstack = []
-    if Meaning.has_key(name): raise 'duplicate declaration', name
-    interpreter.recordee = Meaning[name] = []
+    if interpreter.meaning.has_key(name): raise 'duplicate declaration', name
+    interpreter.recordee = interpreter.meaning[name] = []
     def record_state (tok):
         if tok == Semicolon:
             interpreter.state = interpreter.outer_state
@@ -89,8 +89,8 @@
 
 :regs|family
     def regs_state0 (family):
-        if Meaning.has_key(family):
-            f = Meaning[family]
+        if interpreter.meaning.has_key(family):
+            f = interpreter.meaning[family]
             if not isinstance(f, Register):
                 raise 'unable to declare subregisters for', f
             if not interpreter.hanging.has_key(f):
@@ -103,7 +103,7 @@
             f = interpreter.regpaths[-1]
             interpreter.regpaths[-1] = f.next()
             interpreter.regpaths.append(f.child())
-            Meaning[family] = f
+            interpreter.meaning[family] = f
             Registers[f] = family
         interpreter.state = regs_state
     def regs_state (tok):
@@ -115,15 +115,15 @@
             r = interpreter.regpaths[-1]
             if interpreter.hanging.has_key(r.parent()):
                 raise 'misplaced ellipsis'
-            elif Meaning.has_key(tok):
-                if Meaning[tok] == Meaning[':regs']:
+            elif interpreter.meaning.has_key(tok):
+                if interpreter.meaning[tok] == interpreter.meaning[':regs']:
                     interpreter.state = regs_state0
-                elif Meaning[tok] == Meaning['...']:
+                elif interpreter.meaning[tok] == interpreter.meaning['...']:
                     interpreter.hanging[r.parent()] = r[-1]
                 else: raise 'duplicate declaration', tok
             else:
                 interpreter.regpaths[-1] = r.next()
-                Meaning[tok] = r
+                interpreter.meaning[tok] = r
                 Registers[r] = tok
     regs_state0(family)
 

Index: tran.py
===================================================================
RCS file: /cvsroot/wisp/wisp/users/dig/tran.py,v
retrieving revision 1.91
retrieving revision 1.92
diff -u -d -r1.91 -r1.92
--- tran.py	17 May 2003 10:43:54 -0000	1.91
+++ tran.py	17 May 2003 10:54:46 -0000	1.92
@@ -219,33 +219,35 @@
 
 Generic_Register = Register()
 
-MA_PREFIX = 1
-Meaning = {'reg': Generic_Register,
-           '...': Unique('...'),
-           'tetras': ['dup', '+', 'dup', '+'], # FIXME
-}
-for m in 'any const int lit sum sym'.split(' '):
-    Meaning[m] = Class_Marker(m)
+class Interpreter (object):
+    __slots__ = 'text data bss current recordee regpaths hanging regstack state meaning'.split()
 
-bf = open('tran-builtins', 'r')
-builtins = bf.read()
-bf.close()
+    universal_meaning = {
+        'reg': Generic_Register,
+        '...': Unique('...'),
+        'tetras': ['dup', '+', 'dup', '+'], # FIXME
+    }
+    for m in 'any const int lit sum sym'.split(' '):
+        universal_meaning[m] = Class_Marker(m)
 
-for b in builtins.split('\n\n'):
-    if b[0] != '#':
-        name, code = b.split('\n', 1)
-        np = (name + '|').split('|')
-        name = np[0]
-        pa = np[1]
-        exec 'def _p (%s):\n%s\n' % (pa, code)
-        flags = 0
-        if pa: flags |= MA_PREFIX
-        Meaning[name] = 'builtin', _p, flags
+    # load builtins
+    _bf = open('tran-builtins', 'r')
+    _builtins = _bf.read()
+    _bf.close()
 
-Registers = {Generic_Register: 'reg'} # for reverse translation
+    MA_PREFIX = 1
+
+    for _b in _builtins.split('\n\n'):
+        if _b[0] != '#':
+            _name, _code = _b.split('\n', 1)
+            _np = (_name + '|').split('|')
+            _name = _np[0]
+            _pa = _np[1]
+            exec 'def _p (%s):\n%s\n' % (_pa, _code)
+            _flags = 0
+            if _pa: _flags |= MA_PREFIX
+            universal_meaning[_name] = 'builtin', _p, _flags
 
-class Interpreter (object):
-    __slots__ = 'text data bss current recordee regpaths hanging regstack state'.split()
     def __init__ (this, byte_order):
         this.text = Linkie('<')
         this.data = Linkie('<')
@@ -256,6 +258,7 @@
         this.hanging = {}
         this.regstack = []
         this.state = this.outer_state
+        this.meaning = Interpreter.universal_meaning.copy()
     def outer_state (this, tok):
         if isinstance(tok, Integer_Literal):
             this.regstack.append(tok)
@@ -263,30 +266,32 @@
             root = tok
             mg = match_generator(root)
             try:
-                while not Meaning.has_key(tok):
+                while not interpreter.meaning.has_key(tok):
                     tok = mg.next()
                     if tok == None:
                         raise 'stack too empty or meaningless word', root
             except StopIteration:
                 raise 'meaningless word', root
-            m = Meaning[tok]
+            m = interpreter.meaning[tok]
             if isinstance(m, list): prep.push(Macro_Cursor(m))
             elif isinstance(m, Stackable): this.regstack.append(m)
             elif isinstance(m, tuple):
                 mtype = m[0]
                 if mtype == 'builtin':
-                    if m[2] & MA_PREFIX:
+                    if m[2] & Interpreter.MA_PREFIX:
                         tok = prep.get_token()
                         if not isinstance(tok, str): raise 'word expected', tok
                         m[1](tok)
                     else:
                         m[1]()
-                else: raise 'Unknown meaning type in', `Meaning[tok]`
+                else: raise 'Unknown meaning type in', `interpreter.meaning[tok]`
             else: raise 'Unknown meaning format for', tok
         else: raise 'bad token', tok
 
 interpreter = Interpreter('<')
 
+Registers = {Generic_Register: 'reg'} # for reverse translation
+
 default_output_names = {'elf': 'a.out', 'pe': 'untitled.exe'}
 verbose = 0
 format = 'elf'
@@ -307,7 +312,7 @@
     if output_name == None: output_name = default_output_names[format]
     if list_words:
         wd = {}
-        for w in Meaning.keys():
+        for w in interpreter.meaning.keys():
             s = w.find(' ')
             if s != -1: w = w[:s]
             wd[w] = 1