Initial commit

37 files changed, 2221 insertions, 0 deletions

diff --git a/src/examples/.cvsignore b/src/examples/.cvsignore
new file mode 100644
index 0000000..b05754c
--- /dev/null
+++ b/src/examples/.cvsignore
@@ -0,0 +1,29 @@
+cat
+cmp
+cp
+echo
+halt
+hex-dump
+ls
+mcat
+mcp
+mkdir
+pwd
+rm
+shell
+bubsort
+insult
+lineup
+matmult
+recursor
+lab2test
+pfs_writer
+pfs
+sumargv
+longrun
+pfs_reader
+child
+parent
+dummy
+create-bad
+*.d
diff --git a/src/examples/Makefile b/src/examples/Makefile
new file mode 100644
index 0000000..92d9038
--- /dev/null
+++ b/src/examples/Makefile
@@ -0,0 +1,50 @@
+SRCDIR = ..
+
+# Test programs to compile, and a list of sources for each.
+# To add a new test, put its name on the PROGS list
+# and then add a name_SRC line that lists its source files.
+PROGS = cat cmp cp echo halt hex-dump ls mcat mcp mkdir pwd rm shell \
+	bubsort insult lineup matmult recursor \
+	sumargv lab2test lab1test lab1test2 pfs pfs_reader pfs_writer dummy longrun \
+	child parent create-bad
+
+# Added test programs
+sumargv_SRC = sumargv.c
+lab2test_SRC = lab2test.c
+lab1test_SRC = lab1test.c
+lab1test2_SRC = lab1test2.c
+pfs_SRC = pfs.c
+pfs_reader_SRC = pfs_reader.c
+pfs_writer_SRC = pfs_writer.c
+longrun_SRC = longrun.c
+dummy_SRC = dummy.c
+child_SRC = child.c
+parent_SRC = parent.c
+create-bad_SRC = create-bad.c
+
+# Should work from project 2 onward.
+cat_SRC = cat.c
+cmp_SRC = cmp.c
+cp_SRC = cp.c
+echo_SRC = echo.c
+halt_SRC = halt.c
+hex-dump_SRC = hex-dump.c
+insult_SRC = insult.c
+lineup_SRC = lineup.c
+ls_SRC = ls.c
+recursor_SRC = recursor.c
+rm_SRC = rm.c
+
+# Should work in project 3; also in project 4 if VM is included.
+bubsort_SRC = bubsort.c
+matmult_SRC = matmult.c
+mcat_SRC = mcat.c
+mcp_SRC = mcp.c
+
+# Should work in project 4.
+mkdir_SRC = mkdir.c
+pwd_SRC = pwd.c
+shell_SRC = shell.c
+
+include $(SRCDIR)/Make.config
+include $(SRCDIR)/Makefile.userprog
diff --git a/src/examples/bubsort.c b/src/examples/bubsort.c
new file mode 100644
index 0000000..343219e
--- /dev/null
+++ b/src/examples/bubsort.c
@@ -0,0 +1,38 @@
+/* sort.c 
+
+   Test program to sort a large number of integers.
+ 
+   Intention is to stress virtual memory system.
+ 
+   Ideally, we could read the unsorted array off of the file
+   system, and store the result back to the file system! */
+#include <stdio.h>
+
+/* Size of array to sort. */
+#define SORT_SIZE 128
+
+int
+main (void)
+{
+  /* Array to sort.  Static to reduce stack usage. */
+  static int array[SORT_SIZE];
+
+  int i, j, tmp;
+
+  /* First initialize the array in descending order. */
+  for (i = 0; i < SORT_SIZE; i++)
+    array[i] = SORT_SIZE - i - 1;
+
+  /* Then sort in ascending order. */
+  for (i = 0; i < SORT_SIZE - 1; i++)
+    for (j = 0; j < SORT_SIZE - 1 - i; j++)
+      if (array[j] > array[j + 1])
+	{
+	  tmp = array[j];
+	  array[j] = array[j + 1];
+	  array[j + 1] = tmp;
+	}
+
+  printf ("sort exiting with code %d\n", array[0]);
+  return array[0];
+}
diff --git a/src/examples/cat.c b/src/examples/cat.c
new file mode 100644
index 0000000..c8d229d
--- /dev/null
+++ b/src/examples/cat.c
@@ -0,0 +1,34 @@
+/* cat.c
+
+   Prints files specified on command line to the console. */
+
+#include <stdio.h>
+#include <syscall.h>
+
+int
+main (int argc, char *argv[]) 
+{
+  bool success = true;
+  int i;
+  
+  for (i = 1; i < argc; i++) 
+    {
+      int fd = open (argv[i]);
+      if (fd < 0) 
+        {
+          printf ("%s: open failed\n", argv[i]);
+          success = false;
+          continue;
+        }
+      for (;;) 
+        {
+          char buffer[1024];
+          int bytes_read = read (fd, buffer, sizeof buffer);
+          if (bytes_read == 0)
+            break;
+          write (STDOUT_FILENO, buffer, bytes_read);
+        }
+      close (fd);
+    }
+  return success ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/src/examples/child.c b/src/examples/child.c
new file mode 100644
index 0000000..0c1648d
--- /dev/null
+++ b/src/examples/child.c
@@ -0,0 +1,22 @@
+/* child.c
+ * See parent.c */
+#include <syscall.h>
+#include <stdio.h>
+
+int main (int argc, char* argv[])
+{
+  int i;
+  
+  if (argc != 2)
+    return 0;
+  
+  for(i = 0; i < 20000; i++)
+  {
+    int a = (i * i) + (i * i);
+    int b = i;
+    i = a; a = b; i = b;
+  }
+  printf("PASS Lab %s ON Time.\n", argv[1]);
+
+  return 0;
+}
diff --git a/src/examples/cmp.c b/src/examples/cmp.c
new file mode 100644
index 0000000..94b406d
--- /dev/null
+++ b/src/examples/cmp.c
@@ -0,0 +1,68 @@
+/* cat.c
+
+   Compares two files. */
+
+#include <stdio.h>
+#include <syscall.h>
+
+int
+main (int argc, char *argv[]) 
+{
+  int fd[2];
+
+  if (argc != 3) 
+    {
+      printf ("usage: cmp A B\n");
+      return EXIT_FAILURE;
+    }
+
+  /* Open files. */
+  fd[0] = open (argv[1]);
+  if (fd[0] < 0) 
+    {
+      printf ("%s: open failed\n", argv[1]);
+      return EXIT_FAILURE;
+    }
+  fd[1] = open (argv[2]);
+  if (fd[1] < 0) 
+    {
+      printf ("%s: open failed\n", argv[1]);
+      return EXIT_FAILURE;
+    }
+
+  /* Compare data. */
+  for (;;) 
+    {
+      int pos;
+      char buffer[2][1024];
+      int bytes_read[2];
+      int min_read;
+      int i;
+
+      pos = tell (fd[0]);
+      bytes_read[0] = read (fd[0], buffer[0], sizeof buffer[0]);
+      bytes_read[1] = read (fd[1], buffer[1], sizeof buffer[1]);
+      min_read = bytes_read[0] < bytes_read[1] ? bytes_read[0] : bytes_read[1];
+      if (min_read == 0)
+        break;
+
+      for (i = 0; i < min_read; i++)
+        if (buffer[0][i] != buffer[1][i]) 
+          {
+            printf ("Byte %d is %02hhx ('%c') in %s but %02hhx ('%c') in %s\n",
+                    pos + i,
+                    buffer[0][i], buffer[0][i], argv[1],
+                    buffer[1][i], buffer[1][i], argv[2]);
+            return EXIT_FAILURE;
+          }
+
+      if (min_read < bytes_read[1])
+        printf ("%s is shorter than %s\n", argv[1], argv[2]);
+      else if (min_read < bytes_read[0])
+        printf ("%s is shorter than %s\n", argv[2], argv[1]);
+    }
+
+  printf ("%s and %s are identical\n", argv[1], argv[2]);
+
+  return EXIT_SUCCESS;
+}
diff --git a/src/examples/cp.c b/src/examples/cp.c
new file mode 100644
index 0000000..86a5cd7
--- /dev/null
+++ b/src/examples/cp.c
@@ -0,0 +1,55 @@
+/* cat.c
+
+Copies one file to another. */
+
+#include <stdio.h>
+#include <syscall.h>
+
+int
+main (int argc, char *argv[]) 
+{
+  int in_fd, out_fd;
+
+  if (argc != 3) 
+    {
+      printf ("usage: cp OLD NEW\n");
+      return EXIT_FAILURE;
+    }
+
+  /* Open input file. */
+  in_fd = open (argv[1]);
+  if (in_fd < 0) 
+    {
+      printf ("%s: open failed\n", argv[1]);
+      return EXIT_FAILURE;
+    }
+
+  /* Create and open output file. */
+  if (!create (argv[2], filesize (in_fd))) 
+    {
+      printf ("%s: create failed\n", argv[2]);
+      return EXIT_FAILURE;
+    }
+  out_fd = open (argv[2]);
+  if (out_fd < 0) 
+    {
+      printf ("%s: open failed\n", argv[2]);
+      return EXIT_FAILURE;
+    }
+
+  /* Copy data. */
+  for (;;) 
+    {
+      char buffer[1024];
+      int bytes_read = read (in_fd, buffer, sizeof buffer);
+      if (bytes_read == 0)
+        break;
+      if (write (out_fd, buffer, bytes_read) != bytes_read) 
+        {
+          printf ("%s: write failed\n", argv[2]);
+          return EXIT_FAILURE;
+        }
+    }
+
+  return EXIT_SUCCESS;
+}
diff --git a/src/examples/create-bad.c b/src/examples/create-bad.c
new file mode 100644
index 0000000..4a9688a
--- /dev/null
+++ b/src/examples/create-bad.c
@@ -0,0 +1,32 @@
+/* The following program should be killed by the kernel because the
+   string sent with create starts at one page (the BSS page) and ends
+   outside of it in a page that is not allocated.
+
+   If user memory accesses are not handled correctly by the kernel,
+   then pintos will crash with a page fault exception.
+   
+   Author: Mattias Eriksson
+*/
+
+#include <syscall.h>
+#include <stdio.h>
+#include <string.h>
+
+#define PGS 4096 /* page size */
+#define PMASK 0xfffff000
+
+static char inbss;
+
+int
+main (void)
+{
+  char * bss_page = (char*) ((int)(&inbss) & PMASK);
+  printf("inbss and bss_page: %p, %p\n", &inbss, bss_page);
+  printf("This program should be killed by the kernel.\n");
+
+  memset ( bss_page, 'a', PGS );
+  create (bss_page+PGS-5, 1024);
+  printf("ERROR: this point should not be reached\n");
+  
+  exit(0);
+}
diff --git a/src/examples/dummy.c b/src/examples/dummy.c
new file mode 100644
index 0000000..deeca27
--- /dev/null
+++ b/src/examples/dummy.c
@@ -0,0 +1,12 @@
+/* A small dummy process that just uses up a process slot in the long
+ * runtime test */
+
+#include <stdlib.h>
+
+int main(int argc, char* argv[])
+{
+  if (argc != 2)
+    return 0;
+  
+  return atoi(argv[1]);
+}
diff --git a/src/examples/echo.c b/src/examples/echo.c
new file mode 100644
index 0000000..1b136f2
--- /dev/null
+++ b/src/examples/echo.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <syscall.h>
+
+int
+main (int argc, char **argv)
+{
+  int i;
+
+  for (i = 0; i < argc; i++)
+    printf ("%s ", argv[i]);
+  printf ("\n");
+
+  return EXIT_SUCCESS;
+}
diff --git a/src/examples/halt.c b/src/examples/halt.c
new file mode 100644
index 0000000..bad7250
--- /dev/null
+++ b/src/examples/halt.c
@@ -0,0 +1,14 @@
+/* halt.c
+
+   Simple program to test whether running a user program works.
+ 	
+   Just invokes a system call that shuts down the OS. */
+
+#include <syscall.h>
+
+int
+main (void)
+{
+  halt ();
+  /* not reached */
+}
diff --git a/src/examples/hex-dump.c b/src/examples/hex-dump.c
new file mode 100644
index 0000000..ee313f2
--- /dev/null
+++ b/src/examples/hex-dump.c
@@ -0,0 +1,35 @@
+/* hex-dump.c
+
+   Prints files specified on command line to the console in hex. */
+
+#include <stdio.h>
+#include <syscall.h>
+
+int
+main (int argc, char *argv[]) 
+{
+  bool success = true;
+  int i;
+  
+  for (i = 1; i < argc; i++) 
+    {
+      int fd = open (argv[i]);
+      if (fd < 0) 
+        {
+          printf ("%s: open failed\n", argv[i]);
+          success = false;
+          continue;
+        }
+      for (;;) 
+        {
+          char buffer[1024];
+          int pos = tell (fd);
+          int bytes_read = read (fd, buffer, sizeof buffer);
+          if (bytes_read == 0)
+            break;
+          hex_dump (pos, buffer, bytes_read, true);
+        }
+      close (fd);
+    }
+  return success ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/src/examples/insult.c b/src/examples/insult.c
new file mode 100644
index 0000000..98c4e6a
--- /dev/null
+++ b/src/examples/insult.c
@@ -0,0 +1,369 @@
+/* Insult.c
+
+   This is a version of the famous CS 107 random sentence
+   generator.  I wrote a program that reads a grammar definition
+   file and writes a C file containing that grammar as hard code
+   static C strings.  Thus the majority of the code below in
+   machine generated and totally unreadable.  The arrays created
+   are specially designed to make generating the sentences as
+   easy as possible.
+
+   Originally by Greg Hutchins, March 1998.
+   Modified by Ben Pfaff for Pintos, Sept 2004. */
+char *start[] =
+  { "You", "1", "5", ".", "May", "13", ".", "With", "the", "19", "of", "18",
+",", "may", "13", "."
+};
+char startLoc[] = { 3, 0, 4, 7, 16 };
+char *adj[] = { "3", "4", "2", ",", "1" };
+char adjLoc[] = { 3, 0, 1, 2, 5 };
+char *adj3[] = { "3", "4" };
+char adj3Loc[] = { 2, 0, 1, 2 };
+char *adj1[] =
+  { "lame", "dried", "up", "par-broiled", "bloated", "half-baked", "spiteful",
+"egotistical", "ungrateful", "stupid", "moronic", "fat", "ugly", "puny", "pitiful",
+"insignificant", "blithering", "repulsive", "worthless", "blundering", "retarded",
+"useless", "obnoxious", "low-budget", "assinine", "neurotic", "subhuman", "crochety",
+"indescribable", "contemptible", "unspeakable", "sick", "lazy", "good-for-nothing",
+"slutty", "mentally-deficient", "creepy", "sloppy", "dismal", "pompous", "pathetic",
+"friendless", "revolting", "slovenly", "cantankerous", "uncultured", "insufferable",
+"gross", "unkempt", "defective", "crumby"
+};
+char adj1Loc[] =
+  { 50, 0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+43, 44, 45, 46, 47, 48, 49, 50, 51 };
+char *adj2[] =
+  { "putrefied", "festering", "funky", "moldy", "leprous", "curdled", "fetid",
+"slimy", "crusty", "sweaty", "damp", "deranged", "smelly", "stenchy", "malignant",
+"noxious", "grimy", "reeky", "nasty", "mutilated", "sloppy", "gruesome", "grisly",
+"sloshy", "wormy", "mealy", "spoiled", "contaminated", "rancid", "musty",
+"fly-covered", "moth-eaten", "decaying", "decomposed", "freeze-dried", "defective",
+"petrified", "rotting", "scabrous", "hirsute"
+};
+char adj2Loc[] =
+  { 40, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40 };
+char *name[] =
+  { "10", ",", "bad", "excuse", "for", "6", ",", "6", "for", "brains", ",",
+"4", "11", "8", "for", "brains", "offspring", "of", "a", "motherless", "10", "7", "6",
+"7", "4", "11", "8"
+};
+char nameLoc[] = { 7, 0, 1, 6, 10, 16, 21, 23, 27 };
+char *stuff[] =
+  { "shit", "toe", "jam", "filth", "puss", "earwax", "leaf", "clippings",
+"bat", "guano", "mucus", "fungus", "mung", "refuse", "earwax", "spittoon", "spittle",
+"phlegm"
+};
+char stuffLoc[] = { 14, 0, 1, 3, 4, 5, 6, 8, 10, 11, 12, 13, 14, 15, 17, 18 };
+char *noun_and_prep[] =
+  { "bit", "of", "piece", "of", "vat", "of", "lump", "of", "crock", "of",
+"ball", "of", "tub", "of", "load", "of", "bucket", "of", "mound", "of", "glob", "of", "bag",
+"of", "heap", "of", "mountain", "of", "load", "of", "barrel", "of", "sack", "of", "blob", "of",
+"pile", "of", "truckload", "of", "vat", "of"
+};
+char noun_and_prepLoc[] =
+  { 21, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36,
+38, 40, 42 };
+char *organics[] =
+  { "droppings", "mung", "zits", "puckies", "tumors", "cysts", "tumors",
+"livers", "froth", "parts", "scabs", "guts", "entrails", "blubber", "carcuses", "gizards",
+"9"
+};
+char organicsLoc[] =
+  { 17, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
+char *body_parts[] =
+  { "kidneys", "genitals", "buttocks", "earlobes", "innards", "feet"
+};
+char body_partsLoc[] = { 6, 0, 1, 2, 3, 4, 5, 6 };
+char *noun[] =
+  { "pop", "tart", "warthog", "twinkie", "barnacle", "fondue", "pot",
+"cretin", "fuckwad", "moron", "ass", "neanderthal", "nincompoop", "simpleton", "11"
+};
+char nounLoc[] = { 13, 0, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+char *animal[] =
+  { "donkey", "llama", "dingo", "lizard", "gekko", "lemur", "moose", "camel",
+"goat", "eel"
+};
+char animalLoc[] = { 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+char *good_verb[] =
+  { "love", "cuddle", "fondle", "adore", "smooch", "hug", "caress", "worship",
+"look", "at", "touch"
+};
+char good_verbLoc[] = { 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11 };
+char *curse[] =
+  { "14", "20", "23", "14", "17", "20", "23", "14", "find", "your", "9",
+"suddenly", "delectable", "14", "and", "14", "seek", "a", "battleground", "23"
+};
+char curseLoc[] = { 4, 0, 3, 7, 13, 20 };
+char *afflictors[] =
+  { "15", "21", "15", "21", "15", "21", "15", "21", "a", "22", "Rush",
+"Limbaugh", "the", "hosts", "of", "Hades"
+};
+char afflictorsLoc[] = { 6, 0, 2, 4, 6, 8, 12, 16 };
+char *quantity[] =
+  { "a", "4", "hoard", "of", "a", "4", "pack", "of", "a", "truckload", "of",
+"a", "swarm", "of", "many", "an", "army", "of", "a", "4", "heard", "of", "a", "4",
+"platoon", "of", "a", "4", "and", "4", "group", "of", "16"
+};
+char quantityLoc[] = { 10, 0, 4, 8, 11, 14, 15, 18, 22, 26, 32, 33 };
+char *numbers[] =
+  { "a", "thousand", "three", "million", "ninty-nine", "nine-hundred,",
+"ninty-nine", "forty-two", "a", "gazillion", "sixty-eight", "times", "thirty-three"
+};
+char numbersLoc[] = { 7, 0, 2, 4, 5, 7, 8, 10, 13 };
+char *adv[] =
+  { "viciously", "manicly", "merrily", "happily", ",", "with", "the", "19",
+"of", "18", ",", "gleefully", ",", "with", "much", "ritualistic", "celebration", ",",
+"franticly"
+};
+char advLoc[] = { 8, 0, 1, 2, 3, 4, 11, 12, 18, 19 };
+char *metaphor[] =
+  { "an", "irate", "manticore", "Thor's", "belch", "Alah's", "fist", "16",
+"titans", "a", "particularly", "vicious", "she-bear", "in", "the", "midst", "of", "her",
+"menstrual", "cycle", "a", "pissed-off", "Jabberwock"
+};
+char metaphorLoc[] = { 6, 0, 3, 5, 7, 9, 20, 23 };
+char *force[] = { "force", "fury", "power", "rage" };
+char forceLoc[] = { 4, 0, 1, 2, 3, 4 };
+char *bad_action[] =
+  { "spit", "shimmy", "slobber", "find", "refuge", "find", "shelter", "dance",
+"retch", "vomit", "defecate", "erect", "a", "strip", "mall", "build", "a", "26", "have", "a",
+"religious", "experience", "discharge", "bodily", "waste", "fart", "dance", "drool",
+"lambada", "spill", "16", "rusty", "tacks", "bite", "you", "sneeze", "sing", "16",
+"campfire", "songs", "smite", "you", "16", "times", "construct", "a", "new", "home", "throw",
+"a", "party", "procreate"
+};
+char bad_actionLoc[] =
+  { 25, 0, 1, 2, 3, 5, 7, 8, 9, 10, 11, 15, 18, 22, 25, 26, 27, 28, 29, 33,
+35, 36, 40, 44, 48, 51, 52 };
+char *beasties[] =
+  { "yaks", "22", "maggots", "22", "cockroaches", "stinging", "scorpions",
+"fleas", "22", "weasels", "22", "gnats", "South", "American", "killer", "bees", "spiders",
+"4", "monkeys", "22", "wiener-dogs", "22", "rats", "22", "wolverines", "4", ",", "22",
+"pit-fiends"
+};
+char beastiesLoc[] =
+  { 14, 0, 1, 3, 5, 7, 8, 10, 12, 16, 17, 19, 21, 23, 25, 29 };
+char *condition[] =
+  { "frothing", "manic", "crazed", "plague-ridden", "disease-carrying",
+"biting", "rabid", "blood-thirsty", "ravaging", "slavering"
+};
+char conditionLoc[] = { 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+char *place[] =
+  { "in", "24", "25", "upon", "your", "mother's", "grave", "on", "24", "best",
+"rug", "in", "the", "26", "you", "call", "home", "upon", "your", "heinie"
+};
+char placeLoc[] = { 5, 0, 3, 7, 11, 17, 20 };
+char *relation[] =
+  { "your", "your", "your", "your", "father's", "your", "mother's", "your",
+"grandma's"
+};
+char relationLoc[] = { 6, 0, 1, 2, 3, 5, 7, 9 };
+char *in_something[] =
+  { "entrails", "anal", "cavity", "shoes", "house", "pantry", "general",
+"direction", "pants", "bed"
+};
+char in_somethingLoc[] = { 8, 0, 1, 3, 4, 5, 6, 8, 9, 10 };
+char *bad_place[] =
+  { "rat", "hole", "sewer", "toxic", "dump", "oil", "refinery", "landfill",
+"porto-pottie"
+};
+char bad_placeLoc[] = { 6, 0, 2, 3, 5, 7, 8, 9 };
+char **daGrammar[27];
+char *daGLoc[27];
+
+static void
+init_grammar (void)
+{
+  daGrammar[0] = start;
+  daGLoc[0] = startLoc;
+  daGrammar[1] = adj;
+  daGLoc[1] = adjLoc;
+  daGrammar[2] = adj3;
+  daGLoc[2] = adj3Loc;
+  daGrammar[3] = adj1;
+  daGLoc[3] = adj1Loc;
+  daGrammar[4] = adj2;
+  daGLoc[4] = adj2Loc;
+  daGrammar[5] = name;
+  daGLoc[5] = nameLoc;
+  daGrammar[6] = stuff;
+  daGLoc[6] = stuffLoc;
+  daGrammar[7] = noun_and_prep;
+  daGLoc[7] = noun_and_prepLoc;
+  daGrammar[8] = organics;
+  daGLoc[8] = organicsLoc;
+  daGrammar[9] = body_parts;
+  daGLoc[9] = body_partsLoc;
+  daGrammar[10] = noun;
+  daGLoc[10] = nounLoc;
+  daGrammar[11] = animal;
+  daGLoc[11] = animalLoc;
+  daGrammar[12] = good_verb;
+  daGLoc[12] = good_verbLoc;
+  daGrammar[13] = curse;
+  daGLoc[13] = curseLoc;
+  daGrammar[14] = afflictors;
+  daGLoc[14] = afflictorsLoc;
+  daGrammar[15] = quantity;
+  daGLoc[15] = quantityLoc;
+  daGrammar[16] = numbers;
+  daGLoc[16] = numbersLoc;
+  daGrammar[17] = adv;
+  daGLoc[17] = advLoc;
+  daGrammar[18] = metaphor;
+  daGLoc[18] = metaphorLoc;
+  daGrammar[19] = force;
+  daGLoc[19] = forceLoc;
+  daGrammar[20] = bad_action;
+  daGLoc[20] = bad_actionLoc;
+  daGrammar[21] = beasties;
+  daGLoc[21] = beastiesLoc;
+  daGrammar[22] = condition;
+  daGLoc[22] = conditionLoc;
+  daGrammar[23] = place;
+  daGLoc[23] = placeLoc;
+  daGrammar[24] = relation;
+  daGLoc[24] = relationLoc;
+  daGrammar[25] = in_something;
+  daGLoc[25] = in_somethingLoc;
+  daGrammar[26] = bad_place;
+  daGLoc[26] = bad_placeLoc;
+}
+
+#include <ctype.h>
+#include <debug.h>
+#include <random.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syscall.h>
+
+void expand (int num, char **grammar[], char *location[], int handle);
+
+static void
+usage (int ret_code, const char *message, ...) PRINTF_FORMAT (2, 3);
+
+static void
+usage (int ret_code, const char *message, ...)
+{
+  va_list args;
+
+  if (message != NULL) 
+    {
+      va_start (args, message);
+      vprintf (message, args);
+      va_end (args);
+    }
+  
+  printf ("\n"
+          "Usage: insult [OPTION]...\n"
+          "Prints random insults to screen.\n\n"
+          "  -h:               this help message\n"
+          "  -s <integer>:     set the random seed (default 4951)\n"
+          "  -n <integer>:     choose number of insults (default 4)\n"
+          "  -f <file>:        redirect output to <file>\n");
+
+  exit (ret_code);
+}
+
+int
+main (int argc, char *argv[])
+{
+  int sentence_cnt, new_seed, i, file_flag, sent_flag, seed_flag;
+  int handle;
+  
+  new_seed = 4951;
+  sentence_cnt = 4;
+  file_flag = 0;
+  seed_flag = 0;
+  sent_flag = 0;
+  handle = STDOUT_FILENO;
+
+  for (i = 1; i < argc; i++)
+    {
+      if (strcmp (argv[1], "-h") == 0)
+        usage (0, NULL);
+      else if (strcmp (argv[i], "-s") == 0)
+	{
+	  if (seed_flag++)
+	    usage (-1, "Can't have more than one seed");
+	  if (++i >= argc)
+	    usage (-1, "Missing value for -s");
+	  new_seed = atoi (argv[i]);
+	}
+      else if (strcmp (argv[i], "-n") == 0)
+	{
+	  if (sent_flag++)
+	    usage (-1, "Can't have more than one sentence option");
+	  if (++i >= argc)
+	    usage (-1, "Missing value for -n");
+	  sentence_cnt = atoi (argv[i]);
+	  if (sentence_cnt < 1)
+	    usage (-1, "Must have at least one sentence");
+	}
+      else if (strcmp (argv[i], "-f") == 0)
+	{
+	  if (file_flag++)
+	    usage (-1, "Can't have more than one output file");
+	  if (++i >= argc)
+	    usage (-1, "Missing value for -f");
+
+          /* Because files have fixed length in the basic Pintos
+             file system, the 0 argument means that this option
+             will not be useful until project 4 is
+             implemented. */
+	  create (argv[i], 0);
+	  handle = open (argv[i]);
+          if (handle < 0)
+            {
+              printf ("%s: open failed\n", argv[i]);
+              return EXIT_FAILURE;
+            }
+	}
+      else
+        usage (-1, "Unrecognized flag");
+    }
+
+  init_grammar ();
+
+  random_init (new_seed);
+  hprintf (handle, "\n");
+
+  for (i = 0; i < sentence_cnt; i++)
+    {
+      hprintf (handle, "\n");
+      expand (0, daGrammar, daGLoc, handle);
+      hprintf (handle, "\n\n");
+    }
+  
+  if (file_flag)
+    close (handle);
+
+  return EXIT_SUCCESS;
+}
+
+void
+expand (int num, char **grammar[], char *location[], int handle)
+{
+  char *word;
+  int i, which, listStart, listEnd;
+
+  which = random_ulong () % location[num][0] + 1;
+  listStart = location[num][which];
+  listEnd = location[num][which + 1];
+  for (i = listStart; i < listEnd; i++)
+    {
+      word = grammar[num][i];
+      if (!isdigit (*word))
+	{
+	  if (!ispunct (*word))
+            hprintf (handle, " ");
+          hprintf (handle, "%s", word);
+	}
+      else
+	expand (atoi (word), grammar, location, handle);
+    }
+
+}
diff --git a/src/examples/lab1test.c b/src/examples/lab1test.c
new file mode 100644
index 0000000..1b5aa2b
--- /dev/null
+++ b/src/examples/lab1test.c
@@ -0,0 +1,107 @@
+/* I cleaned this file up a bit, but it is still not pretty. -- ME */
+#include <stdio.h>
+#include <string.h>
+#include <syscall.h>
+#include <stdarg.h>
+
+int main(void)
+{  
+  char *descr = "This is test program v0.1 that tests your implementation basic system calls\n";
+  char *test1 = "The first test is to create three files.\n";
+  char *test2 = "Now lets write some data to the files. Write some binary data to some files.\n";
+  char *test3 = "Test string that is written to a file.\n";
+  char *test4 = "Test to read back data from files.\n";
+  char *test5 = "Test to read from and write to bad file handles.\n";
+  char *test6 = "Get data from console. Please, write something (10 characters).\n";
+  char *test7 = "Test to open a file that does not exist.\n";
+  char binarydata[10];
+  char sbuf[50];
+  int file[3];
+  int num_bytes_read, i;
+
+  binarydata[0] = 1;
+  binarydata[1] = 2;
+  binarydata[2] = 3;
+  binarydata[3] = 4;
+  binarydata[4] = 5;
+  binarydata[5] = 0;
+  binarydata[6] = 1;
+  binarydata[7] = 2;
+  binarydata[8] = 3;
+  binarydata[9] = 4;
+
+  write(STDOUT_FILENO, descr, strlen(descr));
+  write(STDOUT_FILENO, test1, strlen(test1));
+  if (!create("test0", strlen(test3))) {
+    printf("Could not create test0\n");
+    halt();
+  }
+  if (!create("test1", 1024)){
+    printf("Could not create test1\n");
+    halt();
+  }
+  if (!create("test2", 1024)){
+    printf("Could not create test1\n");
+    halt();
+  }
+	
+  for(i = 0; i < 2; i++){
+    snprintf(sbuf, 50, "test%d", i);
+    file[i] = open(sbuf);
+    if(file[i] > 1){
+    }
+    else{
+      printf("Could not open %s\n", sbuf);
+      halt();
+    }
+  }
+	
+  write(STDOUT_FILENO, test6, strlen(test6));
+  num_bytes_read = read(STDIN_FILENO, sbuf, 10);
+  if(num_bytes_read != 10){
+    printf("Did not read 10 characters from the console.\n");
+    halt();
+  }
+	
+  write(STDOUT_FILENO, test2, strlen(test2));
+  write(file[0], test3, strlen(test3));
+  write(file[1], binarydata, 10);
+	
+  write(STDOUT_FILENO, test4, strlen(test4));
+  close(file[0]);
+  file[0] = open("test0");
+  num_bytes_read = read(file[0], sbuf, 50);
+  if(num_bytes_read != (int)strlen(test3)){
+    printf("Could not read back from test0 (%u),  %u characters read instead!\n", (unsigned int)strlen(test3), num_bytes_read);
+    halt();
+  }
+  
+  num_bytes_read = read(file[1], sbuf, 10);
+  if(num_bytes_read != 10){
+    printf("Could not read back binary data from test1\n");
+    halt();
+  }
+  if(!memcmp(sbuf, binarydata, 10)) {
+    printf("Data read back from test1 does not match what was written\n");
+    halt();
+  }
+  close(file[1]);
+	
+  write(STDOUT_FILENO, test5, strlen(test5));
+  write(87, "hej", 3);
+  num_bytes_read = read(1006, sbuf, 3);
+  if(num_bytes_read != -1){
+    printf("You should catch that I tried to read from file 1006\n");
+  }
+	
+  write(STDOUT_FILENO, test7, strlen(test7));
+  file[2] = open("fdsfa");
+  if(file[2] > 1){
+    printf(sbuf, "Got file handle when opening non-existing file\n");
+    write(STDOUT_FILENO, sbuf, strlen(sbuf));
+    halt();
+  }
+
+  printf("Test passed\n");
+  halt();
+}
diff --git a/src/examples/lab1test2.c b/src/examples/lab1test2.c
new file mode 100644
index 0000000..4438025
--- /dev/null
+++ b/src/examples/lab1test2.c
@@ -0,0 +1,208 @@
+/*
+  Complete test suite for most system calls implemented in lab 1.
+
+   This program tests the minimum file limit and verifies all
+   returned data.
+
+   Tested requirements:
+     - write must return number of bytes written
+     - create must return whether the file was created
+     - a user program must be able to have 128 files open
+       at the same time
+     - opening a file must return a valid file descriptor
+     - opening a file mulitiple times must return unique
+       file descriptors
+     - reading from a closed file must fail
+     - reading from an invalid file descriptor must fail
+     - attempting to open missing files must fail
+     - read must return number of bytes read
+     - read after write must return written data
+     - reading from console be implemented
+     - exit must terminate the user program
+
+   Untested requirements:
+     - halt must shut down the system
+     - file descriptors must be closed on process exit
+*/
+#include <stdio.h>
+#include <string.h>
+#include <syscall.h>
+#include <stdarg.h>
+
+#define FD_TEST_COUNT 128
+#define READ_SIZE 50
+#define READ_CONSOLE_COUNT 10
+
+#define RED   "\x1B[31m"
+#define GRN   "\x1B[32m"
+#define YEL   "\x1B[33m"
+#define BLU   "\x1B[34m"
+#define MAG   "\x1B[35m"
+#define CYN   "\x1B[36m"
+#define WHT   "\x1B[37m"
+#define RESET "\x1B[0m"
+
+#define TITLE(x) printf(WHT x RESET)
+#define ERROR(x, ...) printf(RED "ERR: " x RESET, ##__VA_ARGS__); halt()
+#define SUCCESS(x) printf(GRN x RESET)
+
+int main(void)
+{
+  char *dummyprint = "Hello, world!\n";
+  char *testdata = "sample file content";
+  bool created;
+  int fd;
+  int bytes_written;
+  int bytes_read;
+  char sbuf[READ_SIZE];
+
+
+
+  TITLE("TEST 1: Printing text\n");
+  bytes_written = write(STDOUT_FILENO, dummyprint, strlen(dummyprint));
+  if (bytes_written < 0 || (size_t)bytes_written != strlen(dummyprint))
+  {
+    ERROR("Incorrect number of written bytes returned from SYS_WRITE.\n");
+  }
+  else
+  {
+    SUCCESS("TEST 1: Passed\n");
+  }
+
+
+
+  TITLE("TEST 2: Creating file\n");
+  created = create("test0", strlen(testdata));
+  if (!created)
+  {
+    ERROR("Could not create file \"test0\", does it already exist?\n");
+  }
+
+  created = create("test0", strlen(testdata));
+  if (created)
+  {
+    ERROR("Succeeded in creating already existing file.\n");
+  }
+
+  SUCCESS("TEST 2: Passed\n");
+
+
+
+  TITLE("TEST 3: Opening files\n");
+  int file_descriptors[FD_TEST_COUNT];
+  int i;
+
+  printf("Opening %d files", FD_TEST_COUNT);
+  for (i = 0; i < FD_TEST_COUNT; ++i)
+  {
+    fd = open("test0");
+    if (fd == -1)
+    {
+      printf("\n");
+      ERROR("Failed to open file, iteration %d.\n", i + 1);
+    }
+
+    if (fd == STDIN_FILENO || fd == STDOUT_FILENO)
+    {
+      printf("\n");
+      ERROR("Opened file with invalid file descriptor.\n");
+    }
+
+    int j;
+    for (j = 0; j < i; ++j)
+    {
+      if (file_descriptors[j] == fd)
+      {
+	printf("\n");
+        ERROR("Opened file with reoccuring file descriptor.\n");
+      }
+    }
+
+    file_descriptors[i] = fd;
+    printf(".");
+  }
+
+  printf("\nDone!\n");
+  printf("Closing files");
+
+  for (i = 0; i < FD_TEST_COUNT; ++i)
+  {
+    close(file_descriptors[i]);
+    bytes_read = read(file_descriptors[i], sbuf, READ_SIZE);
+    if (bytes_read != -1)
+    {
+      printf("\n");
+      ERROR("Successfully read from closed file.\n");
+    }
+
+    printf(".");
+  }
+
+  printf("\nDone!\n");
+
+  bytes_read = read(STDOUT_FILENO, sbuf, READ_SIZE);
+  if (bytes_read != -1)
+  {
+    ERROR("Successfully read from missing file descriptor.\n");
+  }
+
+  fd = open("foobar");
+  if (fd != -1)
+  {
+    ERROR("Successfully opened missing file.\n");
+  }
+
+  SUCCESS("TEST 3: Passed\n");
+
+
+
+  TITLE("TEST 4: Writing to file\n");
+  fd = open("test0");
+  bytes_written = write(fd, testdata, strlen(testdata));
+  if (bytes_written < 0 || (size_t)bytes_written != strlen(testdata))
+  {
+    ERROR("Failed to write %d bytes to file, wrote %d.\n", strlen(testdata), bytes_written);
+  }
+  close(fd);
+
+  SUCCESS("TEST 4: Passed\n");
+
+
+
+  TITLE("TEST 5: Reading from file\n");
+  fd = open("test0");
+  bytes_read = read(fd, sbuf, READ_SIZE);
+  if (bytes_read < 0 || (size_t)bytes_read != strlen(testdata))
+  {
+    ERROR("Failed to read %d bytes from file, read %d.\n", strlen(testdata), bytes_read);
+  }
+
+  if (memcmp(sbuf, testdata, strlen(testdata)) != 0)
+  {
+    ERROR("Read content does not match what was written to file.\n");
+  }
+  close(fd);
+
+  SUCCESS("TEST 5: Passed\n");
+
+
+
+  TITLE("TEST 6: Reading from console\n");
+  printf("Type 10 characters: ");
+  bytes_read = read(STDIN_FILENO, sbuf, READ_CONSOLE_COUNT);
+  printf("\n");
+  if (bytes_read != READ_CONSOLE_COUNT)
+  {
+    ERROR("Failed to read %d characters from console, read %d.\n", READ_CONSOLE_COUNT, bytes_read);
+  }
+
+  SUCCESS("TEST 6: Passed\n");
+
+
+
+  TITLE("The test suite should now exit. Since SYS_WAIT is not implemented yet, the program should hang. ");
+  TITLE("If it does, it means that all tests were successful.\n");
+  exit(0);
+
+  ERROR("ERR: Thread did not exit.\n");
+}
diff --git a/src/examples/lab2test.c b/src/examples/lab2test.c
new file mode 100644
index 0000000..1b5aa2b
--- /dev/null
+++ b/src/examples/lab2test.c
@@ -0,0 +1,107 @@
+/* I cleaned this file up a bit, but it is still not pretty. -- ME */
+#include <stdio.h>
+#include <string.h>
+#include <syscall.h>
+#include <stdarg.h>
+
+int main(void)
+{  
+  char *descr = "This is test program v0.1 that tests your implementation basic system calls\n";
+  char *test1 = "The first test is to create three files.\n";
+  char *test2 = "Now lets write some data to the files. Write some binary data to some files.\n";
+  char *test3 = "Test string that is written to a file.\n";
+  char *test4 = "Test to read back data from files.\n";
+  char *test5 = "Test to read from and write to bad file handles.\n";
+  char *test6 = "Get data from console. Please, write something (10 characters).\n";
+  char *test7 = "Test to open a file that does not exist.\n";
+  char binarydata[10];
+  char sbuf[50];
+  int file[3];
+  int num_bytes_read, i;
+
+  binarydata[0] = 1;
+  binarydata[1] = 2;
+  binarydata[2] = 3;
+  binarydata[3] = 4;
+  binarydata[4] = 5;
+  binarydata[5] = 0;
+  binarydata[6] = 1;
+  binarydata[7] = 2;
+  binarydata[8] = 3;
+  binarydata[9] = 4;
+
+  write(STDOUT_FILENO, descr, strlen(descr));
+  write(STDOUT_FILENO, test1, strlen(test1));
+  if (!create("test0", strlen(test3))) {
+    printf("Could not create test0\n");
+    halt();
+  }
+  if (!create("test1", 1024)){
+    printf("Could not create test1\n");
+    halt();
+  }
+  if (!create("test2", 1024)){
+    printf("Could not create test1\n");
+    halt();
+  }
+	
+  for(i = 0; i < 2; i++){
+    snprintf(sbuf, 50, "test%d", i);
+    file[i] = open(sbuf);
+    if(file[i] > 1){
+    }
+    else{
+      printf("Could not open %s\n", sbuf);
+      halt();
+    }
+  }
+	
+  write(STDOUT_FILENO, test6, strlen(test6));
+  num_bytes_read = read(STDIN_FILENO, sbuf, 10);
+  if(num_bytes_read != 10){
+    printf("Did not read 10 characters from the console.\n");
+    halt();
+  }
+	
+  write(STDOUT_FILENO, test2, strlen(test2));
+  write(file[0], test3, strlen(test3));
+  write(file[1], binarydata, 10);
+	
+  write(STDOUT_FILENO, test4, strlen(test4));
+  close(file[0]);
+  file[0] = open("test0");
+  num_bytes_read = read(file[0], sbuf, 50);
+  if(num_bytes_read != (int)strlen(test3)){
+    printf("Could not read back from test0 (%u),  %u characters read instead!\n", (unsigned int)strlen(test3), num_bytes_read);
+    halt();
+  }
+  
+  num_bytes_read = read(file[1], sbuf, 10);
+  if(num_bytes_read != 10){
+    printf("Could not read back binary data from test1\n");
+    halt();
+  }
+  if(!memcmp(sbuf, binarydata, 10)) {
+    printf("Data read back from test1 does not match what was written\n");
+    halt();
+  }
+  close(file[1]);
+	
+  write(STDOUT_FILENO, test5, strlen(test5));
+  write(87, "hej", 3);
+  num_bytes_read = read(1006, sbuf, 3);
+  if(num_bytes_read != -1){
+    printf("You should catch that I tried to read from file 1006\n");
+  }
+	
+  write(STDOUT_FILENO, test7, strlen(test7));
+  file[2] = open("fdsfa");
+  if(file[2] > 1){
+    printf(sbuf, "Got file handle when opening non-existing file\n");
+    write(STDOUT_FILENO, sbuf, strlen(sbuf));
+    halt();
+  }
+
+  printf("Test passed\n");
+  halt();
+}
diff --git a/src/examples/lab2test_beta.c b/src/examples/lab2test_beta.c
new file mode 100644
index 0000000..c786de8
--- /dev/null
+++ b/src/examples/lab2test_beta.c
@@ -0,0 +1,112 @@
+#include <stdio.h>
+#include <string.h>
+#include <syscall.h>
+#include <stdarg.h>
+#include "debug.h"
+
+void fail(void);
+
+int main(int argc UNUSED, char ** argv UNUSED)
+{  
+  char *test_string = "This is a string that is written to a file.\n";
+  char byte_array[10] = {0,1,2,3,4,0,1,2,3,4};
+  char sbuf[50];
+  int file[3];
+  int num_bytes_read, num_bytes_written;
+
+  printf("\n");
+  printf("*****************************************************************\n");
+  printf("* This program tests your implementation of basic system calls. *\n");
+  printf("*****************************************************************\n\n");
+
+  printf("The first test is to create three files.\n");
+  printf("(Make sure that you have deleted any test files from previous test runs.)\n");
+  if (!create("test0", (int)strlen(test_string)) || !create("test1", 256) || !create("test2", 256)) {
+    printf("Could not create the testfiles.\n");
+    fail();
+  }
+	
+  file[0] = open("test0");
+  file[1] = open("test1");
+  file[2] = open("test2");
+
+  printf("Got file descriptors: %d, %d and %d\n", file[0], file[1], file[2]);
+
+  if (file[0] < 0 || file[1] < 0 || file[2] < 0) {
+    printf("Could not open the test files.\n");
+    fail();
+  }
+	
+  printf("\nTesting to read from console. Type 10 characters, please.\n");
+  num_bytes_read = read(STDIN_FILENO, sbuf, 10);
+  if (num_bytes_read != 10) {
+    printf("Did not read 10 characters from the console.\n");
+    fail();
+  }
+  printf("This is what you wrote: \"%s\"\n", sbuf);
+	
+  printf("\nTesting to write data to files.\n");
+  write(file[0], test_string, strlen(test_string));
+  write(file[1], byte_array, 10);
+	
+  printf("\nTesting to read data back from files.\n");
+  /* Reopening to reset seek position. */
+  close(file[0]);
+  file[0] = open("test0");
+  num_bytes_read = read(file[0], sbuf, 50);
+  if (num_bytes_read != (int)strlen(test_string)) {
+    printf("Could not read back from test0 (%d),  %d characters read instead!\n", (int)strlen(test_string), num_bytes_read);
+    fail();
+  }
+  
+  close(file[1]);
+  file[1] = open("test1");
+  num_bytes_read = read(file[1], sbuf, 10);
+  if (num_bytes_read != 10) {
+    printf("Could not read back binary data from test1\n");
+    fail();
+  }
+  if (memcmp(sbuf, byte_array, 10) != 0) { /* memcmp returns 0 if the data are identical */
+    printf("Data read back from test1 does not match what was written.\n");
+    fail();
+  }
+  close(file[1]);
+	
+  printf("\nTesting write with a bad file descriptor.\n");
+  num_bytes_written = write(file[1], "FOO", 3);
+  if (num_bytes_written != -1) {
+    printf("Writing to a closed file should not be possible.\n");
+    fail();
+  }
+
+  printf("\nTesting read with a bad file descriptor.\n");
+  /* Assuming here that 424242 is a bad file descriptor. */
+  num_bytes_read = read(424242, sbuf, 3);
+  if (num_bytes_read != -1) {
+    printf("Writing to a bad fd should not work.\n");
+    fail();
+  }
+	
+  printf("\nTesting to open a non-existing file.\n");
+  file[2] = open("this.file.does.not.exist!");
+  if (file[2] > 1) {
+    printf("Got file handle when opening non-existing file.\n");
+    fail();
+  }
+
+  printf("\n");
+  printf("*****************************************************************\n");
+  printf("*                 Tests passed; halting machine.                *\n");
+  printf("*****************************************************************\n\n");
+  halt();
+  return -1;
+}
+
+void fail(void)
+{
+  printf("\n");
+  printf("*****************************************************************\n");
+  printf("*                          TEST FAILED                          *\n");
+  printf("*****************************************************************\n\n");
+  halt();
+}
diff --git a/src/examples/lib/.cvsignore b/src/examples/lib/.cvsignore
new file mode 100644
index 0000000..a438335
--- /dev/null
+++ b/src/examples/lib/.cvsignore
@@ -0,0 +1 @@
+*.d
diff --git a/src/examples/lib/user/.cvsignore b/src/examples/lib/user/.cvsignore
new file mode 100644
index 0000000..a438335
--- /dev/null
+++ b/src/examples/lib/user/.cvsignore
@@ -0,0 +1 @@
+*.d
diff --git a/src/examples/lib/user/.dummy b/src/examples/lib/user/.dummy
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/examples/lib/user/.dummy
diff --git a/src/examples/lineup.c b/src/examples/lineup.c
new file mode 100644
index 0000000..60402d0
--- /dev/null
+++ b/src/examples/lineup.c
@@ -0,0 +1,46 @@
+/* lineup.c
+
+   Converts a file to uppercase in-place.
+
+   Incidentally, another way to do this while avoiding the seeks
+   would be to open the input file, then remove() it and reopen
+   it under another handle.  Because of Unix deletion semantics
+   this works fine. */
+
+#include <ctype.h>
+#include <stdio.h>
+#include <syscall.h>
+
+int
+main (int argc, char *argv[])
+{
+  char buf[1024];
+  int handle;
+
+  if (argc != 2)
+    exit (1);
+
+  handle = open (argv[1]);
+  if (handle < 0)
+    exit (2);
+
+  for (;;) 
+    {
+      int n, i;
+
+      n = read (handle, buf, sizeof buf);
+      if (n <= 0)
+        break;
+
+      for (i = 0; i < n; i++)
+        buf[i] = toupper ((unsigned char) buf[i]);
+
+      seek (handle, tell (handle) - n);
+      if (write (handle, buf, n) != n)
+        printf ("write failed\n");
+    }
+
+  close (handle);
+
+  return EXIT_SUCCESS;
+}
diff --git a/src/examples/longrun.c b/src/examples/longrun.c
new file mode 100644
index 0000000..e3399f0
--- /dev/null
+++ b/src/examples/longrun.c
@@ -0,0 +1,86 @@
+/* Start a lot of processes and let them finish to test if we
+ * eventually run out of process slots.
+ * To run the test effectively, if you have a limit on number of
+ * processes, lower the limit to 5 processes and run this test like
+ *
+ *  'longrun 5 400'
+ *
+ * It will fill (and if it works empty) your process table 400 times
+ * :-)
+ *
+ * Note that some pintos tests requires at least 16 simultaneous
+ * processes to work, so be sure to increase the limit before running
+ * pintos tests.
+ */
+
+#include <syscall.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define MAX_SIMULTANEOUS 50
+#define MAX_REPEAT 1000
+
+int main(int argc, char* argv[])
+{
+  char cmd[15];
+  int pid[MAX_SIMULTANEOUS];
+  unsigned i = 0;
+  unsigned j = 0;
+  unsigned simul = 0;
+  unsigned repeat = 0;
+
+  if (argc != 3)
+  {
+    printf("Usage: %s simultaneous repeat\n"
+           "Where 'simultaneous' is the number of simultaneous processes to \n"
+           "start and wait for, and 'repeat' how many times this should be \n"
+           "repeated.\n", argv[0]
+      );
+    return -1;
+  }
+
+  simul = atoi(argv[1]);
+  repeat = atoi(argv[2]);
+
+  if (simul > MAX_SIMULTANEOUS)
+  {
+    printf("This test program is compiled with a limitation to max %d \n"
+           "simultaneos processes.\n", MAX_SIMULTANEOUS);
+    return -1;
+  }
+  
+  if (repeat > MAX_REPEAT)
+  {
+    printf("This test program is compiled with a limitation to max %d \n"
+           "repetitions.\n", MAX_REPEAT);
+    return -1;
+  }
+  
+  printf("Will try to start a total of %d processes in groups of %d\n",
+         simul * repeat, simul);
+  
+  for (j = 0; j < repeat; ++j)
+  {
+    for (i = 0; i < simul; ++i)
+    {
+      snprintf(cmd, 15, "dummy %i", j * simul + i);
+      pid[i] = exec(cmd);
+    }
+    
+    /* There will never be more than 'simul' processes running
+     * simultaneously, but in total there will be a lot of processes
+     * (repeat * simul). Just as you can expect in a real system.
+     */
+    for (i = 0; i < simul; ++i)
+    {
+      /* probably nothing left to wait for */
+      if (pid[i] == -1)
+      {
+        printf("ERROR: Aborting test. Some execution(s) failed\n");
+        return j+1;
+      }
+      wait(pid[i]);      
+    }
+  }
+  return 0;
+}
diff --git a/src/examples/ls.c b/src/examples/ls.c
new file mode 100644
index 0000000..fbe27a1
--- /dev/null
+++ b/src/examples/ls.c
@@ -0,0 +1,90 @@
+/* ls.c
+  
+   Lists the contents of the directory or directories named on
+   the command line, or of the current directory if none are
+   named.
+
+   By default, only the name of each file is printed.  If "-l" is
+   given as the first argument, the type, size, and inumber of
+   each file is also printed.  This won't work until project 4. */
+
+#include <syscall.h>
+#include <stdio.h>
+#include <string.h>
+
+static bool
+list_dir (const char *dir, bool verbose) 
+{
+  int dir_fd = open (dir);
+  if (dir_fd == -1) 
+    {
+      printf ("%s: not found\n", dir);
+      return false;
+    }
+
+  if (isdir (dir_fd))
+    {
+      char name[READDIR_MAX_LEN];
+
+      printf ("%s", dir);
+      if (verbose)
+        printf (" (inumber %d)", inumber (dir_fd));
+      printf (":\n");
+
+      while (readdir (dir_fd, name)) 
+        {
+          printf ("%s", name); 
+          if (verbose) 
+            {
+              char full_name[128];
+              int entry_fd;
+
+              snprintf (full_name, sizeof full_name, "%s/%s", dir, name);
+              entry_fd = open (full_name);
+
+              printf (": ");
+              if (entry_fd != -1)
+                {
+                  if (isdir (entry_fd))
+                    printf ("directory");
+                  else
+                    printf ("%d-byte file", filesize (entry_fd));
+                  printf (", inumber %d", inumber (entry_fd));
+                }
+              else
+                printf ("open failed");
+              close (entry_fd);
+            }
+          printf ("\n");
+        }
+    }
+  else 
+    printf ("%s: not a directory\n", dir);
+  close (dir_fd);
+  return true;
+}
+
+int
+main (int argc, char *argv[]) 
+{
+  bool success = true;
+  bool verbose = false;
+  
+  if (argc > 1 && !strcmp (argv[1], "-l")) 
+    {
+      verbose = true;
+      argv++;
+      argc--;
+    }
+  
+  if (argc <= 1)
+    success = list_dir (".", verbose);
+  else 
+    {
+      int i;
+      for (i = 1; i < argc; i++)
+        if (!list_dir (argv[i], verbose))
+          success = false;
+    }
+  return success ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/src/examples/matmult.c b/src/examples/matmult.c
new file mode 100644
index 0000000..4f0615f
--- /dev/null
+++ b/src/examples/matmult.c
@@ -0,0 +1,57 @@
+/* matmult.c 
+
+   Test program to do matrix multiplication on large arrays.
+ 
+   Intended to stress virtual memory system.
+   
+   Ideally, we could read the matrices off of the file system,
+   and store the result back to the file system!
+ */
+
+#include <stdio.h>
+#include <syscall.h>
+
+/* You should define DIM to be large enough that the arrays
+   don't fit in physical memory.
+
+    Dim       Memory
+ ------     --------
+     16         3 kB
+     64        48 kB
+    128       192 kB
+    256       768 kB
+    512     3,072 kB
+  1,024    12,288 kB
+  2,048    49,152 kB
+  4,096   196,608 kB
+  8,192   786,432 kB
+ 16,384 3,145,728 kB */
+#define DIM 128
+
+int A[DIM][DIM];
+int B[DIM][DIM];
+int C[DIM][DIM];
+
+int
+main (void)
+{
+  int i, j, k;
+
+  /* Initialize the matrices. */
+  for (i = 0; i < DIM; i++)
+    for (j = 0; j < DIM; j++)
+      {
+	A[i][j] = i;
+	B[i][j] = j;
+	C[i][j] = 0;
+      }
+
+  /* Multiply matrices. */
+  for (i = 0; i < DIM; i++)	
+    for (j = 0; j < DIM; j++)
+      for (k = 0; k < DIM; k++)
+	C[i][j] += A[i][k] * B[k][j];
+
+  /* Done. */
+  exit (C[DIM - 1][DIM - 1]);
+}
diff --git a/src/examples/mcat.c b/src/examples/mcat.c
new file mode 100644
index 0000000..7b39760
--- /dev/null
+++ b/src/examples/mcat.c
@@ -0,0 +1,45 @@
+/* mcat.c
+
+   Prints files specified on command line to the console, using
+   mmap. */
+
+#include <stdio.h>
+#include <syscall.h>
+
+int
+main (int argc, char *argv[]) 
+{
+  int i;
+  
+  for (i = 1; i < argc; i++) 
+    {
+      int fd;
+      mapid_t map;
+      void *data = (void *) 0x10000000;
+      int size;
+
+      /* Open input file. */
+      fd = open (argv[i]);
+      if (fd < 0) 
+        {
+          printf ("%s: open failed\n", argv[i]);
+          return EXIT_FAILURE;
+        }
+      size = filesize (fd);
+
+      /* Map files. */
+      map = mmap (fd, data);
+      if (map == MAP_FAILED) 
+        {
+          printf ("%s: mmap failed\n", argv[i]);
+          return EXIT_FAILURE;
+        }
+
+      /* Write file to console. */
+      write (STDOUT_FILENO, data, size);
+
+      /* Unmap files (optional). */
+      munmap (map);
+    }
+  return EXIT_SUCCESS;
+}
diff --git a/src/examples/mcp.c b/src/examples/mcp.c
new file mode 100644
index 0000000..6091dc8
--- /dev/null
+++ b/src/examples/mcp.c
@@ -0,0 +1,68 @@
+/* mcp.c
+
+   Copies one file to another, using mmap. */
+
+#include <stdio.h>
+#include <string.h>
+#include <syscall.h>
+
+int
+main (int argc, char *argv[]) 
+{
+  int in_fd, out_fd;
+  mapid_t in_map, out_map;
+  void *in_data = (void *) 0x10000000;
+  void *out_data = (void *) 0x20000000;
+  int size;
+
+  if (argc != 3) 
+    {
+      printf ("usage: cp OLD NEW\n");
+      return EXIT_FAILURE;
+    }
+
+  /* Open input file. */
+  in_fd = open (argv[1]);
+  if (in_fd < 0) 
+    {
+      printf ("%s: open failed\n", argv[1]);
+      return EXIT_FAILURE;
+    }
+  size = filesize (in_fd);
+
+  /* Create and open output file. */
+  if (!create (argv[2], size)) 
+    {
+      printf ("%s: create failed\n", argv[2]);
+      return EXIT_FAILURE;
+    }
+  out_fd = open (argv[2]);
+  if (out_fd < 0) 
+    {
+      printf ("%s: open failed\n", argv[2]);
+      return EXIT_FAILURE;
+    }
+
+  /* Map files. */
+  in_map = mmap (in_fd, in_data);
+  if (in_map == MAP_FAILED) 
+    {
+      printf ("%s: mmap failed\n", argv[1]);
+      return EXIT_FAILURE;
+    }
+  out_map = mmap (out_fd, out_data);
+  if (out_map == MAP_FAILED)
+    {
+      printf ("%s: mmap failed\n", argv[2]);
+      return EXIT_FAILURE;
+    }
+
+  /* Copy files. */
+  memcpy (out_data, in_data, size);
+
+  /* Unmap files (optional). */
+  munmap (in_map);
+  munmap (out_map);
+
+  return EXIT_SUCCESS;
+}
diff --git a/src/examples/mkdir.c b/src/examples/mkdir.c
new file mode 100644
index 0000000..7ddbc3f
--- /dev/null
+++ b/src/examples/mkdir.c
@@ -0,0 +1,24 @@
+/* mkdir.c
+
+   Creates a directory. */
+
+#include <stdio.h>
+#include <syscall.h>
+
+int
+main (int argc, char *argv[]) 
+{
+  if (argc != 2) 
+    {
+      printf ("usage: %s DIRECTORY\n", argv[0]);
+      return EXIT_FAILURE;
+    }
+
+  if (!mkdir (argv[1])) 
+    {
+      printf ("%s: mkdir failed\n", argv[1]);
+      return EXIT_FAILURE;
+    }
+  
+  return EXIT_SUCCESS;
+}
diff --git a/src/examples/parent.c b/src/examples/parent.c
new file mode 100644
index 0000000..7555b2b
--- /dev/null
+++ b/src/examples/parent.c
@@ -0,0 +1,41 @@
+/* parent.c
+ * A test program that calls itself recursively.
+ * In the last step of the recursion child.c is started.
+ * Do not use with large CHILDREN or DEPTH.
+ */
+#include <syscall.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define CHILDREN 4
+#define DEPTH 3
+
+int main(int argc, char* argv[])
+{
+  int i;
+  int pid[CHILDREN];
+  int depth = DEPTH - 1;
+  char cmd[10];
+
+  if (argc == 2)
+    depth = atoi(argv[1]) - 1;
+  
+  for(i = 0; i < CHILDREN; i++)
+  {
+    if (depth)
+      snprintf(cmd, 10, "parent %i", depth);
+    else
+      snprintf(cmd, 10, "child %i", i);
+
+    printf("%s\n", cmd);
+    pid[i] = exec(cmd);
+  }
+//  if (depth <= 1)
+  {
+    for(i = 0; i < CHILDREN; i++)
+    {
+      wait(pid[i]);
+    }
+  }
+  exit(0);
+}
diff --git a/src/examples/pfs.c b/src/examples/pfs.c
new file mode 100644
index 0000000..0d9cd52
--- /dev/null
+++ b/src/examples/pfs.c
@@ -0,0 +1,22 @@
+#include "syscall.h"
+
+int main(void)
+{
+  int i;
+  int pid[5];
+  
+  create("file.1", 50000);
+  create("messages", 5000);
+  
+  pid[0] = exec("pfs_writer a z");
+  pid[1] = exec("pfs_writer A Z");
+  pid[2] = exec("pfs_reader");
+  pid[3] = exec("pfs_reader");
+  pid[4] = exec("pfs_reader");
+  
+  for (i = 0; i < 5; i++)
+  {
+    wait(pid[i]);
+  }
+  exit(0);
+}
diff --git a/src/examples/pfs.h b/src/examples/pfs.h
new file mode 100644
index 0000000..2ba7fce
--- /dev/null
+++ b/src/examples/pfs.h
@@ -0,0 +1,2 @@
+#define BIG 3000
+#define TIMES 500
diff --git a/src/examples/pfs_reader.c b/src/examples/pfs_reader.c
new file mode 100644
index 0000000..583583a
--- /dev/null
+++ b/src/examples/pfs_reader.c
@@ -0,0 +1,48 @@
+/* Reads from the file and checks consistency.
+ * The buffer should all contain the same character!!
+ */
+
+#include <syscall.h>
+#include <stdio.h>
+#include "pfs.h"
+
+char buffer[BIG];
+
+int main(void)
+{
+  int bytes, i, j, inconsistency;
+  int id, messages;
+  
+  messages = open("messages");
+  
+  for (i = 0; i < TIMES; ++i)
+  {
+    id = open("file.1");
+    bytes = read(id, buffer, BIG);
+    close(id);
+    
+    if (bytes != BIG)
+    {
+      write(messages, "Buffer not filled!\n", 19);
+      continue;
+    }
+    /* now check for consistency */
+    for (j = 1, inconsistency = 0; j < BIG; ++j)
+    {
+      if (buffer[0] != buffer[j])
+      {
+        /* Ooops, inconsistency */
+	write(messages, "INCONSISTENCY.", 14);
+	printf("INCONSISTENCY\n");
+	inconsistency = 1;
+	break; /* no need to check further */
+      }
+    }
+    if (!inconsistency)
+    {
+      write(messages, "cool\n", 5);
+    }
+  }
+  close(messages);
+  exit(0);
+}
diff --git a/src/examples/pfs_writer.c b/src/examples/pfs_writer.c
new file mode 100644
index 0000000..0ebd772
--- /dev/null
+++ b/src/examples/pfs_writer.c
@@ -0,0 +1,47 @@
+/* Write on the disk.
+ * Each time the buffer is filled with same character.
+ * Different character every time!
+ */
+
+#include <syscall.h>
+#include <stdio.h>
+#include <string.h>
+#include "pfs.h"
+
+char buffer[BIG];
+
+int main(int argc, char* argv[])
+{
+  int i,j;
+  char c;
+  int id;
+  int write_count;
+  char start;
+  char end;
+
+  if (argc != 3 || strlen(argv[1]) != 1 || strlen(argv[2]) != 1)
+    exit(1);
+  
+  start = argv[1][0];
+  end   = argv[2][0];
+  
+  for (i = 0; i < TIMES / (end - start + 1) + 1; ++i)
+  {
+    for (c = start; c <= end; ++c)
+    {
+      for (j = 0; j < BIG; j++)
+        buffer[j] = c;
+      
+      id = open("file.1");
+      write_count = write(id, buffer, BIG);
+      
+      if ( write_count != BIG )
+      {
+        printf("TEST ERROR: write() wrote only %d bytes out of %d bytes\n",
+               write_count, BIG);
+      }
+      close(id);
+    }
+  }
+  exit(0);
+}
diff --git a/src/examples/pwd.c b/src/examples/pwd.c
new file mode 100644
index 0000000..d2305cf
--- /dev/null
+++ b/src/examples/pwd.c
@@ -0,0 +1,152 @@
+/* pwd.c
+   
+   Prints the absolute name of the present working directory. */
+
+#include <syscall.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+static bool getcwd (char *cwd, size_t cwd_size);
+
+int
+main (void) 
+{
+  char cwd[128];
+  if (getcwd (cwd, sizeof cwd)) 
+    {
+      printf ("%s\n", cwd);
+      return EXIT_SUCCESS;
+    }
+  else 
+    {
+      printf ("error\n");
+      return EXIT_FAILURE; 
+    }
+}
+
+/* Stores the inode number for FILE_NAME in *INUM.
+   Returns true if successful, false if the file could not be
+   opened. */
+static bool
+get_inumber (const char *file_name, int *inum) 
+{
+  int fd = open (file_name);
+  if (fd >= 0) 
+    {
+      *inum = inumber (fd);
+      close (fd);
+      return true;
+    }
+  else
+    return false;
+}
+
+/* Prepends PREFIX to the characters stored in the final *DST_LEN
+   bytes of the DST_SIZE-byte buffer that starts at DST.
+   Returns true if successful, false if adding that many
+   characters, plus a null terminator, would overflow the buffer.
+   (No null terminator is actually added or depended upon, but
+   its space is accounted for.) */
+static bool
+prepend (const char *prefix,
+         char *dst, size_t *dst_len, size_t dst_size) 
+{
+  size_t prefix_len = strlen (prefix);
+  if (prefix_len + *dst_len + 1 <= dst_size) 
+    {
+      *dst_len += prefix_len;
+      memcpy ((dst + dst_size) - *dst_len, prefix, prefix_len);
+      return true;
+    }
+  else
+    return false;
+}
+
+/* Stores the current working directory, as a null-terminated
+   string, in the CWD_SIZE bytes in CWD.
+   Returns true if successful, false on error.  Errors include
+   system errors, directory trees deeper than MAX_LEVEL levels,
+   and insufficient space in CWD. */
+static bool
+getcwd (char *cwd, size_t cwd_size) 
+{
+  size_t cwd_len = 0;   
+  
+#define MAX_LEVEL 20
+  char name[MAX_LEVEL * 3 + 1 + READDIR_MAX_LEN + 1];
+  char *namep;
+
+  int child_inum;
+
+  /* Make sure there's enough space for at least "/". */
+  if (cwd_size < 2)
+    return false;
+
+  /* Get inumber for current directory. */
+  if (!get_inumber (".", &child_inum))
+    return false;
+
+  namep = name;
+  for (;;)
+    {
+      int parent_inum, parent_fd;
+
+      /* Compose "../../../..", etc., in NAME. */
+      if ((namep - name) > MAX_LEVEL * 3)
+        return false;
+      *namep++ = '.';
+      *namep++ = '.';
+      *namep = '\0';
+
+      /* Open directory. */
+      parent_fd = open (name);
+      if (parent_fd < 0)
+        return false;
+      *namep++ = '/';
+
+      /* If parent and child have the same inumber,
+         then we've arrived at the root. */
+      parent_inum = inumber (parent_fd);
+      if (parent_inum == child_inum)
+        break;
+
+      /* Find name of file in parent directory with the child's
+         inumber. */
+      for (;;)
+        {
+          int test_inum;
+          if (!readdir (parent_fd, namep) || !get_inumber (name, &test_inum)) 
+            {
+              close (parent_fd);
+              return false; 
+            }
+          if (test_inum == child_inum)
+            break;
+        }
+      close (parent_fd);
+
+      /* Prepend "/name" to CWD. */
+      if (!prepend (namep - 1, cwd, &cwd_len, cwd_size))
+        return false;
+
+      /* Move up. */
+      child_inum = parent_inum;
+    }
+
+  /* Finalize CWD. */
+  if (cwd_len > 0) 
+    {
+      /* Move the string to the beginning of CWD,
+         and null-terminate it. */
+      memmove (cwd, (cwd + cwd_size) - cwd_len, cwd_len);
+      cwd[cwd_len] = '\0';
+    }
+  else 
+    {
+      /* Special case for the root. */
+      strlcpy (cwd, "/", cwd_size); 
+    }
+  
+  return true;
+}
diff --git a/src/examples/recursor.c b/src/examples/recursor.c
new file mode 100644
index 0000000..79c784a
--- /dev/null
+++ b/src/examples/recursor.c
@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <syscall.h>
+
+int
+main (int argc, char *argv[])
+{
+  char buffer[128];
+  pid_t pid;
+  int retval = 0;
+
+  if (argc != 4) 
+    {
+      printf ("usage: recursor <string> <depth> <waitp>\n");
+      exit (1);
+    }
+
+  /* Print args. */
+  printf ("%s %s %s %s\n", argv[0], argv[1], argv[2], argv[3]);
+
+  /* Execute child and wait for it to finish if requested. */
+  if (atoi (argv[2]) != 0) 
+    {
+      snprintf (buffer, sizeof buffer,
+                "recursor %s %d %s", argv[1], atoi (argv[2]) - 1, argv[3]);
+      pid = exec (buffer);
+      if (atoi (argv[3]))
+        retval = wait (pid);
+    }
+  
+  /* Done. */
+  printf ("%s %s: dying, retval=%d\n", argv[1], argv[2], retval);
+  exit (retval);
+}
diff --git a/src/examples/rm.c b/src/examples/rm.c
new file mode 100644
index 0000000..0db7f7b
--- /dev/null
+++ b/src/examples/rm.c
@@ -0,0 +1,21 @@
+/* rm.c
+
+   Removes files specified on command line. */
+
+#include <stdio.h>
+#include <syscall.h>
+
+int
+main (int argc, char *argv[]) 
+{
+  bool success = true;
+  int i;
+  
+  for (i = 1; i < argc; i++)
+    if (!remove (argv[i])) 
+      {
+        printf ("%s: remove failed\n", argv[i]);
+        success = false; 
+      }
+  return success ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/src/examples/shell.c b/src/examples/shell.c
new file mode 100644
index 0000000..93641b4
--- /dev/null
+++ b/src/examples/shell.c
@@ -0,0 +1,104 @@
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <syscall.h>
+
+static void read_line (char line[], size_t);
+static bool backspace (char **pos, char line[]);
+
+int
+main (void)
+{
+  printf ("Shell starting...\n");
+  for (;;) 
+    {
+      char command[80];
+
+      /* Read command. */
+      printf ("--");
+      read_line (command, sizeof command);
+      
+      /* Execute command. */
+      if (!strcmp (command, "exit"))
+        break;
+      else if (!memcmp (command, "cd ", 3)) 
+        {
+          if (!chdir (command + 3))
+            printf ("\"%s\": chdir failed\n", command + 3);
+        }
+      else if (command[0] == '\0') 
+        {
+          /* Empty command. */
+        }
+      else
+        {
+          pid_t pid = exec (command);
+          if (pid != PID_ERROR)
+            printf ("\"%s\": exit code %d\n", command, wait (pid));
+          else
+            printf ("exec failed\n");
+        }
+    }
+
+  printf ("Shell exiting.");
+  return EXIT_SUCCESS;
+}
+
+/* Reads a line of input from the user into LINE, which has room
+   for SIZE bytes.  Handles backspace and Ctrl+U in the ways
+   expected by Unix users.  On return, LINE will always be
+   null-terminated and will not end in a new-line character. */
+static void
+read_line (char line[], size_t size) 
+{
+  char *pos = line;
+  for (;;)
+    {
+      char c;
+      read (STDIN_FILENO, &c, 1);
+
+      switch (c) 
+        {
+        case '\r':
+          *pos = '\0';
+          putchar ('\n');
+          return;
+
+        case '\b':
+          backspace (&pos, line);
+          break;
+
+        case ('U' - 'A') + 1:       /* Ctrl+U. */
+          while (backspace (&pos, line))
+            continue;
+          break;
+
+        default:
+          /* Add character to line. */
+          if (pos < line + size - 1) 
+            {
+              putchar (c);
+              *pos++ = c;
+            }
+          break;
+        }
+    }
+}
+
+/* If *POS is past the beginning of LINE, backs up one character
+   position.  Returns true if successful, false if nothing was
+   done. */
+static bool
+backspace (char **pos, char line[]) 
+{
+  if (*pos > line)
+    {
+      /* Back up cursor, overwrite character, back up
+         again. */
+      printf ("\b \b");
+      (*pos)--;
+      return true;
+    }
+  else
+    return false;
+}
diff --git a/src/examples/sumargv.c b/src/examples/sumargv.c
new file mode 100644
index 0000000..06962f9
--- /dev/null
+++ b/src/examples/sumargv.c
@@ -0,0 +1,26 @@
+#include <stdlib.h>
+
+int
+main (int argc, char **argv)
+{
+  int i;
+  int sum = 0;
+  char* argv_me = "sumargv";
+  char* p;
+
+  for (p = argv_me, i = 0; *p; ++p, ++i)
+    sum += (*p - 'a') * i;
+
+  for (p = argv[0], i = 0; *p; ++p, ++i)
+    sum -= (*p - 'a') * i;
+
+  /* if program name is correctly set up sum should now be zero */
+  
+  for (i = 1; i < argc; i++)
+    sum += atoi(argv[i]);
+
+  /* if argv ends correctly with a null pointer this has no effect */
+  sum += argv[argc];
+  
+  return sum;
+}