From: Marius Gavrilescu <marius@ieval.ro>
Date: Sat, 10 Feb 2018 18:40:34 +0000 (+0000)
Subject: More docs
X-Git-Tag: 0.001001~2
X-Git-Url: http://git.ieval.ro/?p=app-scheme79asm.git;a=commitdiff_plain;h=9924aa7bca1bd04de3ab5db16e0204d8d2bf6541

More docs
---

diff --git a/README b/README
index 85e76bc..588ca25 100644
--- a/README
+++ b/README
@@ -6,12 +6,29 @@ B<Design of LISP-Based Processors> paper by Steele and Sussman.
 
 The SIMPLE processor expects input in a particular tagged-pointer
 format. This module takes a string containing a sequence of
-S-expressions of the form C<(tag . value)> representing a tagged
-pointer. Here the tag is either a number or one of several predefined
-values (see the source for a full list), and the value is either a
-number or another tagged pointer. These values are laid out in memory
-and a block of verilog code assigning the memory contents to an array
-named C<mem> is printed.
+S-expressions. Each S-expression is a list of one of three types:
+
+(tag value), for example (symbol nil), represents a value to be
+put in memory (for example a number, or a symbol, or a variable
+reference).
+
+(tag list), where list is of one of these three types,
+represents a tagged pointer. In this case, list is (recursively)
+laid out in memory as per these rules, and a pointer to that location
+(and tagged tag) is put somewhere in memory.
+
+(tag list1 list2), where list1 and list2 are of one of these
+three types (not necessarily the same type). In this case, list1
+and list2 are (recursively) laid out in memory such that list1
+is at position X and list2 is at position X+1, and a pointer of
+type tag and value X is put somewhere in memory.
+
+After this process the very last pointer placed in memory is moved to
+the special location 5 (which is where SIMPLE expects to find the
+expression to be evaluated).
+
+In normal use a single S-expression will be supplied, representing an
+entire program.
 
 INSTALLATION
 
diff --git a/lib/App/Scheme79asm.pm b/lib/App/Scheme79asm.pm
index c971c2c..77a09f9 100644
--- a/lib/App/Scheme79asm.pm
+++ b/lib/App/Scheme79asm.pm
@@ -163,23 +163,42 @@ App::Scheme79asm - assemble sexp to Verilog ROM for SIMPLE processor
 
   use App::Scheme79asm;
   my $asm = App::Scheme79asm->new(type_bits => 3, addr_bits => 5);
-  $asm->parse_and_print('(number . 70)');
+  $asm->parse_and_print('(number 70)');
 
 =head1 DESCRIPTION
 
-B<NOTE:> this module does not do much at the moment.
-
 SIMPLE is a LISP processor defined in the 1979
 B<Design of LISP-Based Processors> paper by Steele and Sussman.
 
 The SIMPLE processor expects input in a particular tagged-pointer
 format. This module takes a string containing a sequence of
-S-expressions of the form C<(tag . value)> representing a tagged
-pointer. Here the tag is either a number or one of several predefined
-values (see the source for a full list), and the value is either a
-number or another tagged pointer. These values are laid out in memory
-and a block of verilog code assigning the memory contents to an array
-named C<mem> is printed.
+S-expressions. Each S-expression is a list of one of three types:
+
+C<(tag value)>, for example C<(symbol nil)>, represents a value to be
+put in memory (for example a number, or a symbol, or a variable
+reference).
+
+C<(tag list)>, where C<list> is of one of these three types,
+represents a tagged pointer. In this case, C<list> is (recursively)
+laid out in memory as per these rules, and a pointer to that location
+(and tagged C<tag>) is put somewhere in memory.
+
+C<(tag list1 list2)>, where C<list1> and C<list2> are of one of these
+three types (not necessarily the same type). In this case, C<list1>
+and C<list2> are (recursively) laid out in memory such that C<list1>
+is at position X and C<list2> is at position X+1, and a pointer of
+type tag and value X is put somewhere in memory.
+
+After this process the very last pointer placed in memory is moved to
+the special location 5 (which is where SIMPLE expects to find the
+expression to be evaluated).
+
+In normal use a single S-expression will be supplied, representing an
+entire program.
+
+The B<parse_and_print> method takes such a string and prints a block
+of verilog code assigning the memory contents to an array named
+C<mem>.
 
 More documentation and features to follow.