Merge pull request #2 from NJdevPro/extend

Extend

Author: NJdevPro

.gitignore

@@ -1,2 +1,3 @@
 *~
-minilisp
+minilisp
+*.o

README.md

@@ -2,24 +2,31 @@ MiniLisp with REPL
 ==================
 
 Foreword by N. Janin:
-This is my attempt at making Rui Ueyama (rui314)'s MiniLisp slightly more user friendly and powerful.
-Not being limited by the 1000 lines challenge, I've added a few basic primitives 
+This is my attempt at making Rui Ueyama (rui314)'s MiniLisp slightly more user friendly 
+and powerful.
+Not being limited by the 1000 lines challenge, I've added a number of basic primitives 
 to the original program, while trying to keep the goal of simplicity and conciseness.
-The whole program compiles to less than 100 kb without debugging symbols and should be able to run on low powered devices.
 
+The whole program compiles to less than 100 kb without debugging symbols and should be 
+able to run on low powered devices.
+
+The whole program compiles to less than 100 kb and should be able to run on low powered devices.
 The added primitives:
 * strings
-* operators >, >=, <=, or, and, not,
+* predicates >, >=, <=, or, and, not,
+
 * functions length, reverse, progn, load.
-This has the side effect of being much faster as well, since all these primitives are compiled 
-instead of being interpreted.
+
+This has the side effect of being much faster as well, since all these primitives are 
+compiled instead of being interpreted.
 
 Among the bells and whistles, I've added a REPL based on Justine Tunney (jart)'s bestline.
 
 In this version, instead of passing a file using pipes, you simply pass the files as command parameters :
 ./minilisp f1 f2 etc
 
-The files all share the same environment, so all the symbols, functions and macros defined in f1 can be reused in the following files. 
+The files all share the same environment, so all the symbols, functions and macros defined 
+in f1 can be reused in the following files. 
 
 ## Shortcuts
 
@@ -170,12 +177,16 @@ car.
     (setcar cell 'x)
     cell  ; -> (x . b)
 
-`length` and `reverse` operate on a whole list. They can also operate on their arguments.
+`length` and `reverse` operate on a whole list or a string. They can also operate on their 
+arguments when their number is > 1.
+
+    (length '(1 2 3))   ; -> 3
+    (length 1 2 t)      ; -> 3
+    (length "1 2 3")    ; -> 5
 
-    (length '(1 2 3)) ; -> 3
-    (length 1 2 t) ; -> 3
-    (reverse '(a b c)) ; -> (c b a)
-    (reverse '(a) b c) ; -> (c b (a))
+    (reverse '(a b c))  ; -> (c b a)
+    (reverse "1234")    ; -> "4321" 
+    (reverse '((a) b "c")  ; -> ("c" b (a))
 
 ### Numeric operators
 
@@ -207,7 +218,7 @@ the second.
     (< 3 3)    ; -> ()
     (< 4 3)    ; -> ()
 
-The other comparison operators `>`, `<=`, `>=` work in a similar fashion.
+The other numerical predicates `>`, `<=`, `>=` work in a similar fashion.
 
 `and` takes two or more arguments, evaluates them, and returns the last argument
 that returns true, if all the arguments return true, or () otherwise.
@@ -224,10 +235,10 @@ that returns true.
     (or () ())   ; -> ()
     (or)         ; -> ()
 
-NB: because all the arguments are evaluated, `and` and `or` do not operate like 
-their counterparts written in Lisp, as those stop evaluation at the first argument
-that returns. If the arguments have side effects, this may affect the program 
-differently.
+Nota Bene: because all the arguments are evaluated, `and` and `or` do not operate  
+like their counterparts written in Lisp, as those stop evaluation at the first 
+argument that returns. If the arguments have side effects, this may affect the 
+program differently.
 
 ### Conditionals
 
@@ -247,12 +258,11 @@ exhaustion error.
 
 ### Imperative programming
 
-`progn` executes several expressions consecutively.
+`(progn expr expr ...)` executes several expressions in sequence.
 
-    (progn (print 'I 'own) 
-        (defun add(x y)(+ x y)
-        (println (add 3 7) 'cents)))  ; -> I own 
-                                         10 cents
+    (progn (print "I own ") 
+        (defun add(x y)(+ x y))
+        (println (add 3 7) " cents"))  ; -> prints "I own 10 cents"
 
 ### Equivalence test operators
 
@@ -269,7 +279,7 @@ contents but actually different are considered to not be the same by `eq`.
 
 `string-concat` concatenates strings.
 
-    (string-concat) ;                 -> ""
+    (string-concat)                 ; -> ""
     (string-concat "A" "B" "C" "D") ; -> "ABCD"
 
 `symbol->string` turns a symbol into a string.
@@ -285,8 +295,9 @@ contents but actually different are considered to not be the same by `eq`.
 
 `print` prints a given object to the standard output.
 
-    (print 3)               ; prints "3"
-    (print '(hello world))  ; prints "(hello world)"
+    (print 3)               ; -> "3"
+    (print '(hello world))  ; -> "(hello world)"
+    (print "hello" "world") ; -> "hello world"
 
 `println` does the same, adding a return at the end.
 
@@ -345,12 +356,21 @@ is not defined.
     (define val (+ 3 5))
     (setq val (+ val 1))  ; increment "val"
 
-### system functions
+### Introspection
+
+`atom` returns () if the argument is a cell, t otherwise.
+
+    (atom '(a b))   ; -> ()
+    (atom "")       ; -> t
+    (atom ())       ; -> t
+    
+### System functions
 `load` loads a Lisp file and evaluates all its content, adding it to the environment.
 
-    (load 'example/nqueens.lisp) -> run the file and store its evaluated functions and macros
+    (load "example/nqueens.lisp") -> run the file and store its evaluated functions
+                                     and macros
 
-`exit` quits the interpreter and returns integer passed as parameter.
+`exit` quits the interpreter and returns the integer passed as parameter.
 
     (exit 0) -> quit with success
 

examples/hanoi.lisp

@@ -1,12 +1,5 @@
 (defun list (x . y) (cons x y))
 
-(defun mapc1 (fn xs)
-  (if (= () xs)
-      ()
-      (progn 
-        (fn (car xs)) 
-        (mapc1 fn (cdr xs)))))
-
 (defun hanoi-print (disk from to)
   (println (string-concat "Move disk " disk 
     " from " (symbol->string from) 

src/ketopt.h

@@ -0,0 +1,123 @@
+// From https://github.com/attractivechaos/klib
+// Under MIT/X11 license.
+
+#ifndef KETOPT_H
+#define KETOPT_H
+
+#include <string.h> /* for strchr() and strncmp() */
+
+#define ko_no_argument       0
+#define ko_required_argument 1
+#define ko_optional_argument 2
+
+typedef struct {
+	int ind;   /* equivalent to optind */
+	int opt;   /* equivalent to optopt */
+	char *arg; /* equivalent to optarg */
+	int longidx; /* index of a long option; or -1 if short */
+	/* private variables not intended for external uses */
+	int i, pos, n_args;
+} ketopt_t;
+
+typedef struct {
+	char *name;
+	int has_arg;
+	int val;
+} ko_longopt_t;
+
+ketopt_t KETOPT_INIT = { 1, 0, 0, -1, 1, 0, 0 };
+
+static void ketopt_permute(char *argv[], int j, int n) /* move argv[j] over n elements to the left */
+{
+	int k;
+	char *p = argv[j];
+	for (k = 0; k < n; ++k)
+		argv[j - k] = argv[j - k - 1];
+	argv[j - k] = p;
+}
+
+/**
+ * Parse command-line options and arguments
+ *
+ * This fuction has a similar interface to GNU's getopt_long(). Each call
+ * parses one option and returns the option name.  s->arg points to the option
+ * argument if present. The function returns -1 when all command-line arguments
+ * are parsed. In this case, s->ind is the index of the first non-option
+ * argument.
+ *
+ * @param s         status; shall be initialized to KETOPT_INIT on the first call
+ * @param argc      length of argv[]
+ * @param argv      list of command-line arguments; argv[0] is ignored
+ * @param permute   non-zero to move options ahead of non-option arguments
+ * @param ostr      option string
+ * @param longopts  long options
+ *
+ * @return ASCII for a short option; ko_longopt_t::val for a long option; -1 if
+ *         argv[] is fully processed; '?' for an unknown option or an ambiguous
+ *         long option; ':' if an option argument is missing
+ */
+int ketopt(ketopt_t *s, int argc, char *argv[], int permute, const char *ostr, const ko_longopt_t *longopts)
+{
+	int opt = -1, i0, j;
+	if (permute) {
+		while (s->i < argc && (argv[s->i][0] != '-' || argv[s->i][1] == '\0'))
+			++s->i, ++s->n_args;
+	}
+	s->arg = 0, s->longidx = -1, i0 = s->i;
+	if (s->i >= argc || argv[s->i][0] != '-' || argv[s->i][1] == '\0') {
+		s->ind = s->i - s->n_args;
+		return -1;
+	}
+	if (argv[s->i][0] == '-' && argv[s->i][1] == '-') { /* "--" or a long option */
+		if (argv[s->i][2] == '\0') { /* a bare "--" */
+			ketopt_permute(argv, s->i, s->n_args);
+			++s->i, s->ind = s->i - s->n_args;
+			return -1;
+		}
+		s->opt = 0, opt = '?', s->pos = -1;
+		if (longopts) { /* parse long options */
+			int k, n_exact = 0, n_partial = 0;
+			const ko_longopt_t *o = 0, *o_exact = 0, *o_partial = 0;
+			for (j = 2; argv[s->i][j] != '\0' && argv[s->i][j] != '='; ++j) {} /* find the end of the option name */
+			for (k = 0; longopts[k].name != 0; ++k)
+				if (strncmp(&argv[s->i][2], longopts[k].name, j - 2) == 0) {
+					if (longopts[k].name[j - 2] == 0) ++n_exact, o_exact = &longopts[k];
+					else ++n_partial, o_partial = &longopts[k];
+				}
+			if (n_exact > 1 || (n_exact == 0 && n_partial > 1)) return '?';
+			o = n_exact == 1? o_exact : n_partial == 1? o_partial : 0;
+			if (o) {
+				s->opt = opt = o->val, s->longidx = o - longopts;
+				if (argv[s->i][j] == '=') s->arg = &argv[s->i][j + 1];
+				if (o->has_arg == 1 && argv[s->i][j] == '\0') {
+					if (s->i < argc - 1) s->arg = argv[++s->i];
+					else opt = ':'; /* missing option argument */
+				}
+			}
+		}
+	} else { /* a short option */
+		const char *p;
+		if (s->pos == 0) s->pos = 1;
+		opt = s->opt = argv[s->i][s->pos++];
+		p = strchr((char*)ostr, opt);
+		if (p == 0) {
+			opt = '?'; /* unknown option */
+		} else if (p[1] == ':') {
+			if (argv[s->i][s->pos] == 0) {
+				if (s->i < argc - 1) s->arg = argv[++s->i];
+				else opt = ':'; /* missing option argument */
+			} else s->arg = &argv[s->i][s->pos];
+			s->pos = -1;
+		}
+	}
+	if (s->pos < 0 || argv[s->i][s->pos] == 0) {
+		++s->i, s->pos = 0;
+		if (s->n_args > 0) /* permute */
+			for (j = i0; j < s->i; ++j)
+				ketopt_permute(argv, j, s->n_args);
+	}
+	s->ind = s->i - s->n_args;
+	return opt;
+}
+
+#endif