Merge pull request #24 from hintjens/master

Fails to catch syntax error "1 { 1 }"

Author: hintjens

README.md

@@ -32,21 +32,21 @@
 
 **<a href="#toc3-414">The Shell</a>**
 
-**<a href="#toc3-419">Arguments</a>**
+**<a href="#toc3-421">Arguments</a>**
 
-**<a href="#toc3-428">Other Goals</a>**
+**<a href="#toc3-430">Other Goals</a>**
 
-**<a href="#toc2-447">Design Notes</a>**
+**<a href="#toc2-449">Design Notes</a>**
 
-**<a href="#toc2-455">Bibliography</a>**
+**<a href="#toc2-457">Bibliography</a>**
 
-**<a href="#toc2-464">Technicalities</a>**
+**<a href="#toc2-466">Technicalities</a>**
 
-**<a href="#toc3-467">Ownership and License</a>**
+**<a href="#toc3-469">Ownership and License</a>**
 
-**<a href="#toc3-478">Building and Installing</a>**
+**<a href="#toc3-480">Building and Installing</a>**
 
-**<a href="#toc3-511">This Document</a>**
+**<a href="#toc3-513">This Document</a>**
 
 Seriously, this is renewing my hope in technology. Thanks @hintjens -- Jason J. Gullickson ‏@jasonbot2000
 
@@ -455,7 +455,9 @@ We use GSL code generation to build the core language pieces. There are two case
 
 The zs shell provides command history, editing, and tab completion using the Tab key or '?' (as I'm trying to not use special characters in the language, the question mark should remain free for the CLI) (We'll see). We use the editline library for this; it is a clone of the FSF readline function, though much smaller and without extra dependencies. One neat feature is that as you define commands, these become available in the shell.
 
-<A name="toc3-419" title="Arguments" />
+To animate the state machines for the lexer and parser, run "zs -v".
+
+<A name="toc3-421" title="Arguments" />
 ### Arguments
 
 The nice thing about languages is the Internet Comments per Kiloline of Code (IC/KLOC) factor, easily 10-1,000 times higher than for things like protocols, security mechanisms, or library functions. Make a messy API and no-one gives a damn. Ah, but a language! Everyone has an opinion. I kind of like this, the long troll.
@@ -464,7 +466,7 @@ If you want to talk about minor details like my use of < and > for strings, be m
 
 When doing an experiment, "everyone else does it this way, so you should too" is not valid science. Unless, the alternatives are known to be painful, toxic, or deadly. In fact doing stuff no-one expects is kind of exactly the point.
 
-<A name="toc3-428" title="Other Goals" />
+<A name="toc3-430" title="Other Goals" />
 ### Other Goals
 
 Disclaimer: the "vision" thing is way overrated. I only add this section because it's fun.
@@ -483,15 +485,15 @@ Since each box will have an arbitrary set of atomics, bytecode is not portable.
 
 Perhaps the most compelling reason for a new language project is to give the ZeroMQ community an opportunity to work together. We are often fragmented across platforms and operating systems, yet we are solving the same kinds of problems over and over. A shared language would bring together valuable experience. This is the thing which excites me the most, which we managed to almost do using C (as it can be wrapped in anything, so ties together many cultural threads).
 
-<A name="toc2-447" title="Design Notes" />
+<A name="toc2-449" title="Design Notes" />
 ## Design Notes
 
 * Any language aspect that takes more than 10 minutes to understand is too complex.
 * Function names are case-sensitive because the real world is case sensitive (1 M vs. 1 m).
 * Special characters are annoying and I want to reduce or eliminate the need on them. Some punctuation is OK.
 * Real numbers and whole numbers are not the same set in reality. How much is 2 + 2? Anything from 3 to 5, if you are counting real things.
 
-<A name="toc2-455" title="Bibliography" />
+<A name="toc2-457" title="Bibliography" />
 ## Bibliography
 
 * http://www.complang.tuwien.ac.at/forth/threaded-code.html
@@ -500,10 +502,10 @@ Perhaps the most compelling reason for a new language project is to give the Zer
 * http://en.wikipedia.org/wiki/Concatenative_programming_language
 * https://wiki.haskell.org/Functional_programming
 
-<A name="toc2-464" title="Technicalities" />
+<A name="toc2-466" title="Technicalities" />
 ## Technicalities
 
-<A name="toc3-467" title="Ownership and License" />
+<A name="toc3-469" title="Ownership and License" />
 ### Ownership and License
 
 The contributors are listed in AUTHORS. This project uses the MPL v2 license, see LICENSE.
@@ -514,7 +516,7 @@ ZeroScript uses the [CLASS (C Language Style for Scalabilty)](http://rfc.zeromq.
 
 To report an issue, use the [ZeroScript issue tracker](https://github.com/lepaspace/zs/issues) at github.com.
 
-<A name="toc3-478" title="Building and Installing" />
+<A name="toc3-480" title="Building and Installing" />
 ### Building and Installing
 
 Here's how to build ZeroScript from GitHub:
@@ -547,7 +549,7 @@ You will need the pkg-config, libtool, and autoreconf packages.
 
 Uses: https://github.com/troglobit/editline. Get the tarballs from http://troglobit.com/editline.html.
 
-<A name="toc3-511" title="This Document" />
+<A name="toc3-513" title="This Document" />
 ### This Document
 
 This document is originally at README.txt and is built using [gitdown](http://github.com/imatix/gitdown).

README.txt

@@ -403,6 +403,8 @@ We use GSL code generation to build the core language pieces. There are two case
 
 The zs shell provides command history, editing, and tab completion using the Tab key or '?' (as I'm trying to not use special characters in the language, the question mark should remain free for the CLI) (We'll see). We use the editline library for this; it is a clone of the FSF readline function, though much smaller and without extra dependencies. One neat feature is that as you define commands, these become available in the shell.
 
+To animate the state machines for the lexer and parser, run "zs -v".
+
 ### Arguments
 
 The nice thing about languages is the Internet Comments per Kiloline of Code (IC/KLOC) factor, easily 10-1,000 times higher than for things like protocols, security mechanisms, or library functions. Make a messy API and no-one gives a damn. Ah, but a language! Everyone has an opinion. I kind of like this, the long troll.

doc/zs_pipe.doc

@@ -10,127 +10,116 @@ This is the class interface:
     //  if construction failed due to lack of available memory.
     zs_pipe_t *
         zs_pipe_new (void);
-
+    
     //  Destroy the zs_pipe and free all memory used by the object.
     void
         zs_pipe_destroy (zs_pipe_t **self_p);
-
-    //  Sets pipe register to contain a specified whole number; any previous
-    //  value in the register is lost.
-    void
-        zs_pipe_set_whole (zs_pipe_t *self, int64_t whole);
-
-    //  Sets pipe register to contain a specified real number; any previous
-    //  value in the register is lost.
-    void
-        zs_pipe_set_real (zs_pipe_t *self, double real);
-
-    //  Sets pipe register to contain a specified string; any previous value
-    //  in the register is lost.
-    void
-        zs_pipe_set_string (zs_pipe_t *self, const char *string);
-
-    //  Sends current pipe register to the pipe; returns 0 if successful, or
-    //  -1 if the pipe register was empty. Clears the register.
-    int
-        zs_pipe_send (zs_pipe_t *self);
-
+    
     //  Send whole number to pipe; this wipes the current pipe register.
     void
         zs_pipe_send_whole (zs_pipe_t *self, int64_t whole);
-
+    
     //  Send real number to pipe; this wipes the current pipe register.
     void
         zs_pipe_send_real (zs_pipe_t *self, double real);
-
+    
     //  Send string to pipe; this wipes the current pipe register.
     void
         zs_pipe_send_string (zs_pipe_t *self, const char *string);
-
+    
     //  Returns true if the pipe contains at least one real number. Returns false
     //  otherwise.
     bool
         zs_pipe_realish (zs_pipe_t *self);
-
+    
     //  Receives the next value off the pipe, into the register. Any previous
     //  value in the register is lost. Returns true if a value was successfully
     //  received. If no values were received, returns false. This method does
     //  not block.
     bool
         zs_pipe_recv (zs_pipe_t *self);
-
+    
     //  Returns the type of the register, 'w' for whole, 'r' for real, or 's' for
     //  string. Returns -1 if the register is empty.
     char
         zs_pipe_type (zs_pipe_t *self);
-
+    
     //  Returns the value of the register, coerced to a whole number. This can
     //  cause loss of precision. If no conversion was possible, or the register
     //  is empty, returns zero.
     int64_t
         zs_pipe_whole (zs_pipe_t *self);
-
+    
     //  Returns the value of the register, coerced to a real number. This can
     //  cause loss of precision. If no conversion was possible, or the register
     //  is empty, returns zero.
     double
         zs_pipe_real (zs_pipe_t *self);
-
+    
     //  Returns the value of the register, coerced to a string if needed. If the
     //  register is empty, returns an empty string "". The caller must not modify
     //  or free the string.
-    char *
+    const char *
         zs_pipe_string (zs_pipe_t *self);
-
+    
     //  Receives the next value off the pipe, into the register, and coerces it
     //  to a whole if needed. If there is no value to receive, returns 0.
     int64_t
         zs_pipe_recv_whole (zs_pipe_t *self);
-
+    
     //  Receives the next value off the pipe, into the register, and coerces it
     //  to a real if needed. If there is no value to receive, returns 0.
     double
         zs_pipe_recv_real (zs_pipe_t *self);
-
+    
     //  Receives the next value off the pipe, into the register, and coerces it
     //  to a string if needed. If there is no value to receive, returns "". The
     //  The caller must not modify or free the string.
-    char *
+    const char *
         zs_pipe_recv_string (zs_pipe_t *self);
-
+    
     //  Marks an end of phrase in the pipe. This is used to delimit the pipe
     //  as input for later function calls. Marks are ignored when receiving
     //  values off a pipe.
     void
         zs_pipe_mark (zs_pipe_t *self);
-
+    
+    //  Pulls a single value from the source pipe into the pipe. If there was
+    //  no value to pull, sends a constant '1' value to the pipe.
+    void
+        zs_pipe_pull_single (zs_pipe_t *self, zs_pipe_t *source);
+    
     //  Pulls a list of values from the source pipe into the pipe. This function
     //  does a "modest" pull: in a phrase, pulls the last single value. After a
     //  phrase, pulls the preceding phrase.
     void
         zs_pipe_pull_modest (zs_pipe_t *self, zs_pipe_t *source);
-
+    
     //  Pulls a list of values from the source pipe into the pipe. This function
     //  does a "greedy" pull: in a phrase, pulls the current phrase. After a
     //  phrase, pulls the preceding entire sentence.
     void
         zs_pipe_pull_greedy (zs_pipe_t *self, zs_pipe_t *source);
-
+    
     //  Pulls a list of values from the source pipe into the pipe. This function
     //  does an array pull: (a) move last value to input, then (b) move either rest
     //  of current phrase, or entire previous phrase, to input.
     void
         zs_pipe_pull_array (zs_pipe_t *self, zs_pipe_t *source);
-
+    
     //  Return pipe contents, as string. Caller must free it when done. Values are
     //  separated by spaces. This empties the pipe.
     char *
         zs_pipe_paste (zs_pipe_t *self);
-
+    
+    //  Print pipe contents, for debugging, prints nothing if pipe is empty
+    void
+        zs_pipe_print (zs_pipe_t *self, const char *prefix);
+    
     //  Empty the pipe of any values it might contain.
     void
         zs_pipe_purge (zs_pipe_t *self);
-
+    
     //  Self test of this class
     void
         zs_pipe_test (bool animate);
@@ -139,10 +128,10 @@ This is the class self test code:
 
     zs_pipe_t *pipe = zs_pipe_new ();
     zs_pipe_t *copy = zs_pipe_new ();
-
+    
     zs_pipe_send_whole (pipe, 12345);
     zs_pipe_send_string (pipe, "Hello World");
-
+    
     bool rc = zs_pipe_recv (pipe);
     assert (rc);
     int64_t whole = zs_pipe_whole (pipe);
@@ -152,10 +141,11 @@ This is the class self test code:
     const char *string = zs_pipe_string (pipe);
     assert (streq (string, "Hello World"));
     assert (!zs_pipe_recv (pipe));
-
+    
     char *results = zs_pipe_paste (pipe);
     assert (streq (results, ""));
-
+    zstr_free (&results);
+    
     zs_pipe_send_whole (pipe, 4);
     zs_pipe_send_whole (pipe, 5);
     zs_pipe_send_whole (pipe, 6);
@@ -164,7 +154,7 @@ This is the class self test code:
     zs_pipe_purge (pipe);
     whole = zs_pipe_recv_whole (pipe);
     assert (whole == 0);
-
+    
     //  Test phrases
     zs_pipe_mark (pipe);
     zs_pipe_send_whole (pipe, 1);
@@ -180,13 +170,13 @@ This is the class self test code:
     zs_pipe_send_whole (pipe, 9);
     zs_pipe_mark (pipe);
     zs_pipe_send_whole (pipe, 10);
-
+    
     //  Modest pull should take single last value
     zs_pipe_pull_modest (copy, pipe);
     whole = zs_pipe_recv_whole (copy);
     assert (whole == 10);
     assert (!zs_pipe_recv (copy));
-
+    
     //  Modest pull should take last phrase
     zs_pipe_pull_modest (copy, pipe);
     whole = zs_pipe_recv_whole (copy);
@@ -196,20 +186,20 @@ This is the class self test code:
     whole = zs_pipe_recv_whole (copy);
     assert (whole == 9);
     assert (!zs_pipe_recv (copy));
-
+    
     //  Add some more to the pipe...
     zs_pipe_mark (pipe);
     zs_pipe_send_whole (pipe, 7);
     zs_pipe_send_whole (pipe, 8);
-
+    
     //  Greedy pull should take just those two values now
     zs_pipe_pull_greedy (copy, pipe);
     whole = zs_pipe_recv_whole (copy);
     assert (whole == 7);
     whole = zs_pipe_recv_whole (copy);
     assert (whole == 8);
     assert (!zs_pipe_recv (copy));
-
+    
     //  Greedy pull should take all six remaining values
     zs_pipe_pull_greedy (copy, pipe);
     whole = zs_pipe_recv_whole (copy);
@@ -225,10 +215,10 @@ This is the class self test code:
     whole = zs_pipe_recv_whole (copy);
     assert (whole == 6);
     assert (!zs_pipe_recv (copy));
-
+    
     //  Check pipe is empty
     assert (!zs_pipe_recv (copy));
-
+    
     //  Test array pull
     zs_pipe_send_whole (pipe, 1);
     zs_pipe_send_whole (pipe, 2);
@@ -239,7 +229,7 @@ This is the class self test code:
     zs_pipe_send_whole (pipe, 6);
     zs_pipe_mark (pipe);
     zs_pipe_send_whole (pipe, 7);
-
+    
     zs_pipe_pull_array (copy, pipe);
     whole = zs_pipe_recv_whole (copy);
     assert (whole == 7);
@@ -250,7 +240,7 @@ This is the class self test code:
     whole = zs_pipe_recv_whole (copy);
     assert (whole == 6);
     assert (!zs_pipe_recv (copy));
-
+    
     //  Test casting
     zs_pipe_purge (pipe);
     zs_pipe_send_whole (pipe, 1);
@@ -264,7 +254,7 @@ This is the class self test code:
     assert (!zs_pipe_realish (pipe));
     real = zs_pipe_recv_real (pipe);
     assert (real == 3.0);
-
+    
     zs_pipe_destroy (&copy);
     zs_pipe_destroy (&pipe);