wisp-cvs

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

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

Modified Files:
	.cvsignore Makefile.am 
Added Files:
	hello.tran tran.py 
Log Message:
added tran.py and hello.tran

--- NEW FILE: hello.tran ---
\\\\ hello.tran - produce a friendly greeting
\
\ Copyleft © 2003 by Andres Soolo (di...@us...)
\ This file is licensed under the GNU GPL v2.  If you
\ don't know what that means, please do read the GPL.
\
\\\\ @(#) $Id: hello.tran,v 1.1 2003/04/12 11:17:57 digg Exp $

\ This file is intended to be processed using tran.py

\ ia32 registers
:regs reg32 %eax %ecx %edx %ebx %esp %ebp %esi %edi ;
:regs reg16 %ax %cx %dx %bx %sp %bp %si %di ;
:regs reg8  %al %cl %dl %bl %ah %ch %dh %bh ;

lit       :macro $int #xCD b, b, ;
reg32 lit :macro $mov swap minor #o270 + b, t, ;

\ main entry point

label _start
    %edx 6 $mov
    %ecx ref message $mov
    %ebx 1 $mov
    %eax 4 $mov
    #x80 $int
    %ebx 0 $mov
    %eax 1 $mov
    #x80 $int

.data
label message
    #/H b, #/E b, #/L b, #/L b, #/O b, 10 b,

\ vim: ft=forth

--- NEW FILE: tran.py ---
#! /usr/bin/python

#### tran.py - an NG Worth translator prototype
#
# Copyleft © 2003 by Andres Soolo (di...@us...)
# This file is licensed under the GNU GPL v2.  If you
# don't know what that means, please do read the GPL.
#
#### @(#) $Id: tran.py,v 1.1 2003/04/12 11:17:57 digg Exp $

from __future__ import generators

from shlex import shlex
from types import *
import elf
import string
import sys
from linkie import Linkie

class Lexer (shlex):
    def __init__ (this, instream = None, infile = None):
        shlex.__init__(this, instream = instream, infile = infile)
        this.commenters = '\\'
        this.quotes = '"'
        this.wordchars += '!#$%*+,-./:;<=>?@'
    def get_token (this):
        tok = shlex.get_token(this)
        if tok == '': tok = None
        elif tok[:2] == '#o': tok = string.atol(tok[2:], 8)
        elif tok[:2] == '#x': tok = string.atol(tok[2:], 16)
        else:
            try: tok = string.atol(tok, 10)
            except: pass
        return tok

class _Register (tuple):
    def parent (this):
        if len(this): return _Register(this[:-1])
        else:         return None
    def child_generator (this):
        i = 0
        while 1:
            yield Register(this + (i,))
            i += 1
    def __repr__ (this):
        return 'Register' + tuple.__repr__(this)

class ClassMarker:
    def __init__ (this, id):
        this.id = id

def Register (*args):
    return _Register(args)

def b_comma (n):
    if type(n) == LongType:     cursect.emit_byte(n)
    elif type(n) == StringType: cursect.emit_byte_sum([n])
    else: raise 'Literal expected', n
def t_comma (n):
    if type(n) == LongType:     cursect.emit_tetra(n)
    elif type(n) == StringType: cursect.emit_tetra_sum([n])
    else: raise 'Literal expected', n
def label (name):
    cursect.place_symbol('&' + name)
def dot_data ():
    global cursect
    cursect = Data
def dot_text ():
    global cursect
    cursect = Text
def ref (name):
    Regstack.append('&' + name)
def drop (x): pass
def minor (reg):
    Regstack.append(long(reg[-1]))
def swap (x, y):
    Regstack.append(y); Regstack.append(x)
def colon_macro (name):
    global State, Regstack, current_recordee
    if len(Regstack) > 2: raise 'too long argument pattern', Regstack
    name = ' '.join([name] + [matchers(i).next() for i in Regstack])
    Regstack = []
    if Meaning.has_key(name): raise 'duplicate declaration', name
    newmac = []
    Meaning[name] = ('macro', newmac)
    current_recordee = newmac
    State = state_record
def colon_regs (family):
    global State, current_register_index
    if Meaning.has_key(family): raise 'duplicate declaration', tok
    Register(current_register_family)
    f = Register(current_register_family)
    Meaning[family] = 'simple', f
    Registers[f] = family
    current_register_index = 0
    State = state_regs
def plus (a, b):
    Regstack.append(a + b)

def matchers (object):
    if isinstance(object, ClassMarker):
        yield object.id
    elif type(object) == LongType:
        yield 'int'
        yield 'lit'
    elif type(object) == StringType:
        yield 'sym'
        yield 'lit'
    elif isinstance(object, _Register):
        while object <> None:
            yield Registers[object]
            object = object.parent()
    yield 'any'

def match_generator (root):
    yield root
    if len(Regstack) < 1: yield None # want more registers
    m = matchers(Regstack[-1])
    try:
        while 1:
            yield root + ' ' + m.next()
    except StopIteration: pass
    if len(Regstack) < 2: yield None
    m1 = matchers(Regstack[-2])
    try:
        while 1:
            n1 = m1.next()
            m2 = matchers(Regstack[-1])
            try:
                while 1: yield root + ' ' + n1 + ' ' + m2.next()
            except StopIteration: pass
    except StopIteration: pass

def state_outer (tok):
    global Regstack
    if type(tok) == LongType:
        Regstack.append(tok)
    elif type(tok) == StringType and tok[:2] == '#/' and len(tok) == 3:
        Regstack.append(long(ord(tok[2])))
    else:
        root = tok
        mg = match_generator(root)
        try:
            while not 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]
        mtype = m[0]
        if mtype == 'builtin':
            argc = m[2] & MA_ARGC
            if len(Regstack) < argc: raise 'Stack too empty', tok
            if argc:
                arg = Regstack[-argc:]; Regstack = Regstack[:-argc]
            else:
                arg = []
            if m[2] & MA_PREFIX:
                tok = get_token()
                if type(tok) <> StringType: raise 'word expected'
                arg.append(tok)
            apply(m[1], arg)
        elif mtype == 'macro':
            Macrostack.append([0, m[1]])
        elif mtype == 'simple':
            Regstack.append(m[1])
        else: raise 'Unknown meaning type in', `Meaning[tok]`
def state_record (tok):
    global State, current_recordee
    if tok == ';':
        State = state_outer
        current_recordee = None
    else:
        current_recordee.append(tok)
def state_regs (tok):
    global State, current_register_family, current_register_index
    if tok != ';':
        if Meaning.has_key(tok): raise 'duplicate declaration', tok
        r = Register(current_register_family, current_register_index)
        Meaning[tok] = 'simple', r
        Registers[r] = tok
        current_register_index += 1
    else:
        State = state_outer
        current_register_family += 1
        current_register_index = None

# Main output sections.
Text = Linkie('<')
Data = Linkie('<')
cursect = Text
Regstack = []
Generic_Register = Register()
reggen = Generic_Register.child_generator()

MA_ARGC   = 007
MA_PREFIX = 010
Meaning = {
    '.data':        ('builtin', dot_data,    0),
    '.text':        ('builtin', dot_text,    0),
    ':macro':       ('builtin', colon_macro, 0 | MA_PREFIX),
    ':regs':        ('builtin', colon_regs, 0 | MA_PREFIX),
    'any':          ('simple',  ClassMarker('any')),
    'b, lit':       ('builtin', b_comma,     1),
    'drop any':     ('builtin', drop,        1),
    'int':          ('simple',  ClassMarker('int')),
    'label':        ('builtin', label,       0 | MA_PREFIX),
    'lit':          ('simple',  ClassMarker('lit')),
    'ref':          ('builtin', ref,         0 | MA_PREFIX),
    'reg':          ('simple',  Generic_Register),
    'swap any any': ('builtin', swap,        2),
    't, lit':       ('builtin', t_comma,     1),
    'minor reg':    ('builtin', minor,       1),
    '+ int int':    ('builtin', plus,        2),
}
current_recordee = None
current_register_family = 0
State = state_outer
Macrostack = []
Registers = {Generic_Register: 'reg'} # for reverse translation

lex = Lexer(instream = open(sys.argv[1], 'r'), infile = sys.argv[1])

def get_token ():
    if Macrostack:
        tok = Macrostack[-1][1][Macrostack[-1][0]]
        Macrostack[-1][0] += 1
        if Macrostack[-1][0] >= len(Macrostack[-1][1]):
            Macrostack.pop()
        return tok
    else:
        return lex.get_token()

def mainloop ():
    tok = get_token()
    while tok <> None:
        State(tok)
        tok = get_token()

mainloop()
print 'TEXT'; Text.dump()
print 'DATA'; Data.dump()
if Regstack:
    raise 'Regstack not empty after parsing ended', Regstack
binary = elf.make_ELF32_executable(text = Text, data = Data, want_symbols = 1)

f = open('a.out', 'w')
binary.get_file().tofile(f)
f.close()

Index: .cvsignore
===================================================================
RCS file: /cvsroot/wisp/wisp/users/dig/.cvsignore,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- .cvsignore	8 Apr 2003 16:01:30 -0000	1.5
+++ .cvsignore	12 Apr 2003 11:17:57 -0000	1.6
@@ -3,5 +3,6 @@
 *.pyo
 Makefile
 Makefile.in
+a.out
 hello
 hellowosym

Index: Makefile.am
===================================================================
RCS file: /cvsroot/wisp/wisp/users/dig/Makefile.am,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- Makefile.am	10 Apr 2003 19:07:20 -0000	1.7
+++ Makefile.am	12 Apr 2003 11:17:57 -0000	1.8
@@ -12,4 +12,4 @@
 all:
 
 clean: clean-am
-	-rm -f *~ *.pyc *.pyo *.exe hello hellowosym
+	-rm -f *~ *.pyc *.pyo *.exe a.out hello hellowosym