Commit 81e2923796b9dfd028f5a5b0a0d4ef1bd4af0a0d - Tamsin

+3

-2

bin/tamsin less more

2	2	from os.path import realpath, dirname, join
3	3	import sys
4	4
5		sys.path.insert(0, join(dirname(realpath(sys.argv[0])), '..', 'src'))
	5	tamsin_dir = join(dirname(realpath(sys.argv[0])), '..')
	6	sys.path.insert(0, join(tamsin_dir, 'src'))
6	7
7	8	from tamsin.main import main
8	9
9	10
10	11	if __name__ == '__main__':
11		main(sys.argv[1:])
	12	main(sys.argv[1:], tamsin_dir=tamsin_dir)

+10

-13

doc/TODO.markdown less more

1	1	----
2	2
3	3	* turn system library back into built-in keywords (esp. if ¶ can be used)
4		* better command-line argument parsing
5		* `@include` -- for the scanner, especially
6		* `$.unquote` should take left and right quotes to expect
7		* define a stringify-repr operation on terms
	4	* `@include` -- for the scanner, especially -- move metac's to `lib`
	5	* figure out why compiled version of tamsin-ast hangs...
	6	* arbitrary non-printable characters in terms: `\x99`
	7	* `byte` versus `utf_8` scanners ("char" is vague, isn't it?)
8	8
9	9	### 8-bit clean/UTF-8 ###
10	10
11	11	* 8-bit clean strings, in both Python and C. tests for these as string
12	12	literals, ability to scan them on input, and ability to produce them
13	13	on output.
14		* arbitrary non-printable characters in terms and such
15	14	* decode UTF-8 in compiled C code : character scanner yields one Unicode char
16	15	* more tests for UTF-8
17	16
18		### meta-circularity/bootstrapping ###
19
20		* meta-circular implementation of analyzer!
21		* meta-circular implementation of compiler!
22		* meta-circular implementation of interpreter! (not so useful?)
23		* figure out why compiled verstion of tamsin-ast hangs...
24
25	17	### lower-priority/experimental ###
26	18
	19	* meta-circular implementation of compiler!
	20	* `$.unquote` should take left and right quotes to expect
	21	* define a stringify-repr operation on terms
27	22	* Tamsin scanner: more liberal (every non-alphanum+_ symbol scans as itself,
28	23	incl. ones that have no meaning currently like `/` and `?`)
29	24	* use `←` instead of `@`, why not?
30	25	* `¶foo` means production called `foo`, to disambiguate
31	26	(this would mean unaliasing is less necessary -- call your production
32		`¶return` if you like) -- ASCII version? `p^foo`?
	27	`¶return` if you like) -- ASCII version? `^^foo`? `:foo`? `\|\|foo`? `//foo`?
33	28	* pattern match in send:
34	29	* `fields → F@fields(H,T) & H`
35	30	* maps, implemented as hash tables.

41	36	indeed, this is a fold! something like...
42	37	* `fold rule '' +`
43	38	* `fold rule nil cons`
	39	* maybe `rule/nil/cons`
44	40	i.e.
45	41	* `"fold" & expr0 & term & ("+" \| term)`
46	42	that certainly implies that `+` is a constructor though. hmmm...

50	46	expr1 = term → E & fold ("*" & term) E mul.
51	47	term = "x" \| "y" \| "z" \| "(" & expr0 → E & ")" & E.
52	48
	49	* on that topic — production values and/or lambda productions...
53	50	* auto-generate terms from productions, like Rooibos does
54	51	* `;` = `&`?
55	52	* pretty-print AST for error messages

+1

-1

fixture/compiler.py.markdown less more

0	0
1	1	-> Functionality "Intepret Tamsin program" is implemented by
2	2	-> shell command
3		-> "./loadngo.sh %(test-body-file) < %(test-input-file)"
	3	-> "./bin/tamsin loadngo %(test-body-file) < %(test-input-file)"
4	4

+0

-8

~~loadngo.sh~~ less more

0		#!/bin/sh
1
2		bin/tamsin compile $1 > foo.c && \
3		gcc -g -Ic_src -Lc_src foo.c -o foo -ltamsin && \
4		./foo
5		R=$?
6		#rm -f foo.c foo
7		exit $R

+21

-1

src/tamsin/main.py less more

3	3	# Distributed under a BSD-style license; see LICENSE for more information.
4	4
5	5	import codecs
	6	import os
	7	import subprocess
6	8	import sys
7	9
8	10	from tamsin.event import DebugEventListener

41	43	print unicode(result).encode('UTF-8')
42	44
43	45
44		def main(args):
	46	def main(args, tamsin_dir='.'):
45	47	listeners = []
46	48	if args[0] == '--debug':
47	49	listeners.append(DebugEventListener())

66	68	#print >>sys.stderr, repr(ast)
67	69	compiler = Compiler(ast, sys.stdout)
68	70	compiler.compile()
	71	elif args[0] == 'loadngo':
	72	ast = parse_and_check(args[1])
	73	c_filename = 'foo.c'
	74	exe_filename = './foo'
	75	with codecs.open(c_filename, 'w', 'UTF-8') as f:
	76	compiler = Compiler(ast, f)
	77	compiler.compile()
	78	c_src_dir = os.path.join(tamsin_dir, 'c_src')
	79	command = ("gcc", "-g", "-I%s" % c_src_dir, "-L%s" % c_src_dir,
	80	c_filename, "-o", exe_filename, "-ltamsin")
	81	subprocess.check_call(command)
	82	try:
	83	subprocess.check_call((exe_filename,))
	84	exit_code = 0
	85	except CalledProcessError:
	86	exit_code = 1
	87	subprocess.call(('rm', '-f', c_filename, exe_filename))
	88	sys.exit(exit_code)
69	89	else:
70	90	ast = parse_and_check(args[0])
71	91	run(ast, listeners=listeners)