Finished code assignment 5 of Operating Systems.

os/ass5/Makefile

+CC =	gcc
+
+CFLAGS = -Wall -W -Wstrict-prototypes -O2 -ansi -g -D_XOPEN_SOURCE=500
+
+ifdef OPTIMISED
+	CFLAGS +=-DOPTIMISED
+endif
+
+LIBS = -lm
+
+all: isam_bench isam_test
+
+isam_bench:	isam_bench.o isam.o index.o
+	$(CC) $(CFLAGS) -o isam_bench isam_bench.o isam.o index.o $(LIBS)
+
+isam_test:	isam_test.o isam.o index.o
+	$(CC) $(CFLAGS) -o isam_test isam_test.o isam.o index.o $(LIBS)
+
+isam_bench.o:	isam_bench.c isam.h
+	$(CC) $(CFLAGS) -c isam_bench.c
+
+isam_test.o:	isam_test.c isam.h
+	$(CC) $(CFLAGS) -c isam_test.c
+
+isam.o:	isam.c isam.h index.h
+	$(CC) $(CFLAGS) -c isam.c
+
+index.o:	index.c index.h
+	$(CC) $(CFLAGS) -c index.c
+
+clean:
+	rm -f *.o *~ isam_bench isam_test

os/ass5/Makefile.GCC

+CC =	gcc
+
+CFLAGS = -Wall -Wstrict-prototypes -ansi -O2 
+
+LIBS = -lm
+
+isam_bench:	isam_bench.o isam.o index.o
+	$(CC) $(CFLAGS) -o isam_bench isam_bench.o isam.o index.o $(LIBS)
+
+isam_test:	isam_test.o isam.o index.o
+	$(CC) $(CFLAGS) -o isam_test isam_test.o isam.o index.o $(LIBS)
+
+isam_bench.o:	isam_bench.c isam.h
+	$(CC) $(CFLAGS) -c isam_bench.c
+
+isam_test.o:	isam_test.c isam.h
+	$(CC) $(CFLAGS) -c isam_test.c
+
+isam.o:	isam.c isam.h index.h
+	$(CC) $(CFLAGS) -c isam.c
+
+index.o:	index.c index.h
+	$(CC) $(CFLAGS) -c index.c
+
+clean:
+	rm -f *.o *~ isam_bench isam_test core

os/ass5/Makefile.SUN

+CC =	cc
+
+CFLAGS = -fast
+
+LIBS = -lm
+
+isam_bench:	isam_bench.o isam.o index.o
+	$(CC) $(CFLAGS) -o isam_bench isam_bench.o isam.o index.o $(LIBS)
+
+isam_test:	isam_test.o isam.o index.o
+	$(CC) $(CFLAGS) -o isam_test isam_test.o isam.o index.o $(LIBS)
+
+isam_bench.o:	isam_bench.c isam.h
+	$(CC) $(CFLAGS) -c isam_bench.c
+
+isam_test.o:	isam_test.c isam.h
+	$(CC) $(CFLAGS) -c isam_test.c
+
+isam.o:	isam.c isam.h index.h
+	$(CC) $(CFLAGS) -c isam.c
+
+index.o:	index.c index.h
+	$(CC) $(CFLAGS) -c index.c
+
+clean:
+	rm -f *.o *~ isam_bench isam_test core

os/ass5/README

+Een korte beschrijving van de beschikbare bestanden:
+README -	dit readme bestand
+isam.c -	de sources voor de isam bibliotheek routines
+isam.h -	de bijbehorende header file
+index.c -	de sources voor de routines die de index voor de isam file
+		verzorgen.
+index.h -	de bijbehorende header file.
+isam_bench.c -  een testprogramma voor de isam routines, ook bedoeld als
+		benchmark.
+namen, initialen, titles - drie invoerfiles voor gebruik met isam_bench
+		Gebruik:
+		isam_bench namen initialen titels
+		isam_bench namen initialen titels debug
+isam_test.c -   een ander testprogramma
+tele - 		invoer voor isam_test, te gebruiken als
+		isam_test tele.isam < tele
+		hiermee kan een eerste vulling voor tele.isam worden aangemaakt.
+Makefile.GCC	Makefile voor gebruik met de GNU C compiler. Gebruik b.v.:
+		make -f Makefile.GCC isam_bench
+Makefile.SUN	Makefile voor gebruik met de SUN C compiler. Gebruik b.v.:
+		make -f Makefile.SUN isam_bench

os/ass5/index.h

+#ifndef INDEX_H
+#define INDEX_H
+
+/* -------------------------------------------------------------------------
+   Author: G.D. van Albada
+   University of Amsterdam
+   Faculty of Science
+   Informatics Institute
+   Copyright (C) Universiteit van Amsterdam
+   dick at science.uva.nl
+   Version: 0.1
+   Date: December 2001 / January 2002 / November 2004
+   Goal: Part of an assignment on file system structure for the operating
+         systems course. It demonstrates many of the administrative and 
+         layering structures that are also used in normal file systems.
+----------------------------------------------------------------------------*/
+
+extern int index_error;
+
+#define INDEX_FULL			(100)
+#define INDEX_ALLOCATION_FAILURE	(101)
+#define INDEX_INDEXING_ERROR		(102)
+#define INDEX_KEY_NOT_LARGER		(103)
+#define INDEX_WEIRD_ERROR		(104)
+#define INDEX_READ_ERROR		(105)
+#define INDEX_INVALID_HANDLE		(106)
+#define INDEX_BAD_KEYLENGTH		(107)
+#define INDEX_WRITE_FAIL		(108)
+
+typedef struct INDEX_IN_CORE *index_handle;
+
+/*
+ * index_makeNew will construct a new index (in memory only),
+ * characterised by Nblocks (the maximum number if entries in the index)
+ * and KeyLength (the length of the key strings).
+ */
+index_handle index_makeNew(unsigned long Nblocks, unsigned long KeyLength);
+
+/*
+ * The following routine writes the index to disk. It assumes that the
+ * file is already correctly positioned. It returns the file position
+ * after the write. Required input: The index handle, The file handle.
+ */
+long index_writeToDisk(index_handle in, int fid);
+
+/*
+ * index_readFromDisk will read an index from disk. This is a three step
+ * process. First the header is read to determine the size of the index,
+ * then index_makeNew is called to reserve and initialise the required
+ * memory, and finally, the actual index records are retrieved. The
+ * required input is the integer identifier of the (correctly positioned)
+ * file.
+ */
+index_handle index_readFromDisk(int fid);
+
+/*
+ * The following routine will use a complete index to look for a given
+ * key. The value it should return is the number of the data block where
+ * the key-search should continue. It needs as input: The index handle for
+ * the index. The key sought
+ */
+long index_keyToBlock(index_handle in, const char *key);
+
+/*
+ * The following routine must add a key at the end of an index. It needs
+ * as input: The index handle for the index. A poiner to the key string
+ * The integer index value to be associated with this key
+ */
+int index_addKey(index_handle in, const char *key, int index);
+
+/*
+ * Call this function to free the memory used by the index
+ */
+int index_free(index_handle in);
+
+#endif

os/ass5/initialen

+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.
+A.A.
+A.D.
+A.G.
+A.G.
+A.H.
+A.H.L.
+A.H.M.
+A.J.
+A.M.
+A.M.M.
+A.P.
+A.S.
+A.S.Z.
+A.W.
+B.
+B.
+B.
+B.
+B.
+B.
+B.A.
+B.A.A.
+B.D.
+B.G.
+B.J.
+B.J.A.
+B.M.
+C.
+C.
+C.A.
+C.E.
+C.E.
+C.G.
+C.J.H.
+C.J.K.
+C.P.
+C.W.J.
+D.
+D.
+D.
+D.
+D.
+D.
+D.
+D.
+D.
+D.
+D.C.
+D.E.
+D.H.J.
+D.J.M.
+D.L.
+D.S.
+E.
+E.
+E.
+E.
+E.
+E.
+E.
+E.
+E.
+E.
+E.
+E.-J.
+E.-J.
+E.H.M.
+E.J.
+E.J.
+E.J.H.
+E.P.J.
+F.
+F.
+F.
+F.
+F.
+F.
+F.
+F.
+F.
+F.
+F.C.A.
+F.F.M.
+G.
+G.
+G.
+G.
+G.
+G.
+G.
+G.
+G.
+G.
+G.
+G.
+G.
+G.
+G.A.
+G.D.
+G.G.
+G.J.
+G.J.L.
+G.R.
+H-.M.
+H-.P.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.
+H.A.
+H.E.
+H.G.
+H.J.
+H.J.
+H.J.
+H.U.
+H.V.
+H.Z.
+I.
+I.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.
+J.-B.
+J.A.
+J.A.
+J.A.
+J.B.
+J.C.
+J.C.
+J.E.
+J.E.
+J.E.J.
+J.F.
+J.F.
+J.F.M.
+J.G.
+J.I.
+J.J.
+J.J.
+J.J.B.
+J.J.J.
+J.L.
+J.L.
+J.M.
+J.M.
+J.M.
+J.M.
+J.M.
+J.M.
+J.M.
+J.M.
+J.M.M.
+J.P.
+J.P.
+J.R.
+J.W.
+J.W.
+J.W.J.
+Jr.
+K.
+K.
+K.
+K.
+K.
+K.
+K.
+K.
+K.
+K.
+K.
+K.
+K.
+K.A.
+K.E.I.
+L.
+L.
+L.
+L.
+L.
+L.
+L.
+L.
+L.B.F.M.
+L.D.
+L.H.
+L.J.
+L.M.
+L.O.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.
+M.A.
+M.A.
+M.D.
+M.G.
+M.H.
+M.H.
+M.H.F.
+M.I.
+M.J.
+M.J.
+M.J.
+M.M.
+M.O.
+M.O.
+M.O.
+M.T.
+M.W.
+M.Y.
+N.
+N.
+N.
+N.
+N.C.
+O.
+O.J.G.
+P.
+P.
+P.
+P.
+P.
+P.
+P.
+P.
+P.
+P.
+P.
+P.
+P.
+P.
+P.
+P.C.
+P.D.
+P.F.
+P.J.
+P.J.H.
+P.K.A.
+P.M.A.
+P.M.G.
+P.M.W.
+P.P.
+P.R.
+P.U.
+P.V.
+Q.
+Q.
+R.
+R.
+R.
+R.
+R.
+R.
+R.
+R.
+R.
+R.
+R.
+R.
+R.
+R.
+R.
+R.
+R.
+R.
+R.A.
+R.A.
+R.A.F.
+R.D.
+R.D.
+R.F.H.
+R.G.
+R.H.
+R.L.
+R.M.
+R.M.H.
+R.M.P.
+R.N.
+R.S.
+R.W.M.
+S.
+S.
+S.
+S.
+S.
+S.
+S.
+S.
+S.
+S.G.
+S.L.
+T.
+T.
+T.
+T.
+T.
+T.
+T.
+T.
+T.
+T.
+T.G.B.W.
+T.J.
+Th.M.G.
+Tj.R.
+U.
+U.
+V.
+V.
+V.
+V.
+V.N.
+W.
+W.
+W.
+W.
+W.
+W.
+W.
+W.
+W.
+W.
+W.J.
+W.J.
+W.J.A.
+W.W.
+Z.
+Z.
+Z.W.

os/ass5/isam.h

+#ifndef ISAM_H
+#define ISAM_H
+
+/* -------------------------------------------------------------------------
+    Author: G.D. van Albada
+    University of Amsterdam
+    Faculty of Science
+    Informatics Institute
+    Copyright (C) Universiteit van Amsterdam
+    dick at science.uva.nl
+    Version: 0.1
+    Date: December 2001 / January 2002 / November 2004
+    Goal: Part of an assignment on file system structure for the operating
+        systems course. It demonstrates many of the administrative and layering
+        structures that are also used in normal file systems.
+--------------------------------------------------------------------------*/
+
+typedef struct ISAM *isamPtr;
+struct ISAM_FILE_STATS;
+struct ISAM_CACHE_STATS;
+
+
+/* isam_create will create an isam_file, but only if a file of that name
+   does not yet exist.
+   The parameters are:
+   name:     name of the file, possibly including directory information
+   key_len:  maximum length of the (character string) key.
+   data_len: length of the data field
+   NrecPB:   number of records that should be put into one block (including
+         one overflow record per block).
+   Nblocks:  The number of regular data blocks = number of entries in the
+         index
+   isam_create will return an isamPtr on success, NULL on failure
+ */
+
+isamPtr isam_create(const char *name, unsigned long key_len,
+    unsigned long data_len, unsigned long NrecPB, unsigned long Nblocks);
+
+/* isam_open will open an existing isam file.
+   The parameters are:
+   name:     name of the file, possibly including directory information
+   update:   (not used) when != 0 the file is opened for reading and writing
+             (it actually always is).
+   isam_open will return an isamPtr on success, NULL on failure
+ */
+
+isamPtr isam_open(const char *name, int update);
+
+/* isam_close will close a previously opened/created isam_file
+   The parameters are:
+   isam_ident: the isamPtr for the file.
+   isam_close will return 0 on success, -1 on failure.
+ */
+
+int isam_close(isamPtr isam_ident);
+
+/* isam_setKey will position an isam file on the last valid record with
+   a key smaller than the requested key, such that the next call to
+   isam_readNext will return the record with the given key, if it exists.
+   If no such record exists, the first record with a larger key will
+   be returned, if that exists.
+   The parameters are:
+   isam_ident: the isamPtr for the file.
+   key:        a string containing the requested key.
+   isam_setKey will return 0 on success, -1 on failure.
+ */
+
+int isam_setKey(isamPtr isam_ident, const char *key);
+
+/* isam_readNext will read the next valid record, if that exists.
+   The parameters are:
+   isam_ident: the isamPtr for the file.
+   key:        a character array where the key will be stored.
+   data:       pointer to the location where the data are to be stored.
+   isam_readNext will return 0 on success, -1 on failure.
+ */
+int isam_readNext(isamPtr isam_ident, char *key, void *data);
+
+/* isam_readPrev will read the current record, if that exists and is valid and
+   afterwards position the file at the preceding valid record, if that exists.
+   The parameters are:
+   isam_ident: the isamPtr for the file.
+   key:        a character array where the key will be stored.
+   data:       pointer to the location where the data are to be stored.
+   isam_readPrev will return 0 on success, -1 on failure.
+ */
+
+int isam_readPrev(isamPtr isam_ident, char *key, void *data);
+
+/* isam_readByKey will try to read a record with the requested key. It behaves
+   like an isam_setKey followed by an isam_readNext plus a check that the
+   requested key and the retrieved key are the same.
+   The parameters are:
+   isam_ident: the isamPtr for the file.
+   key:        a string containing the requested key.
+   data:       pointer to the location where the data are to be stored.
+   isam_readByKey will return 0 on success, -1 on failure.
+ */
+
+int isam_readByKey(isamPtr isam_ident, const char *key, void *data);
+
+/* isam_update will replace the data field for a record with the given key,
+   if such a record exists. As a security measure, it will verify that the
+   user has the correct original data.
+   The parameters are:
+   isam_ident: the isamPtr for the file.
+   key:        a string containing the requested key.
+   old_data:   a pointer to a location containing a copy of the data that
+           the record should contain before modification.
+   new_data:   the new data to be stored in the record.
+   isam_update will return 0 on success, -1 on failure.
+ */
+
+int isam_update(isamPtr isam_ident, const char *key, const void *old_data,
+    const void *new_data);
+
+/* isam_writeNew will write a new record to the file, but only if the key is
+   not yet in use.
+   The parameters are:
+   isam_ident: the isamPtr for the file.
+   key:        a string containing the new key.
+   data:       the data to be stored in the new record.
+   isam_writeNew will return 0 on success, -1 on failure.
+ */
+
+int isam_writeNew(isamPtr isam_ident, const char *key, const void *data);
+
+/* isam_delete will delete the record with the given key. As a security
+   measure, it will verify that the user has the correct original data.
+   The parameters are:
+   isam_ident: the isamPtr for the file.
+   key:        a string containing the key of the record to be deleted.
+   data:       a pointer to a location containing a copy of the data that
+           the record should contain before deletion.
+   isam_delete will return 0 on success, -1 on failure.
+ */
+
+int isam_delete(isamPtr isam_ident, const char *key, const void *data);
+
+/* isam_fileStats will collect statistics about a given ISAM file.
+   The parameters are:
+   isam_ident: the isamPtr for the file.
+   stats:      the structure to fill in with statistics.
+   isam_fileStats will return 0 on success, -1 on failure.
+ */
+
+int isam_fileStats(isamPtr isam_ident, struct ISAM_FILE_STATS* stats);
+
+/*
+ * isam_cacheStats will return statistics collected throughout the usage
+ * of the ISAM library. These statistics are not collected per file, but
+ * rather give you a summary of the overall performance of the ISAM library
+ * cache. All statistics are per process and start at zero at process start
+ * time
+ *
+ * The parameters are:
+ *    stats: A pointer to an ISAM_CACHE_STATS structure to receive the
+ *           collected statistics.
+ */
+
+int isam_cacheStats(struct ISAM_CACHE_STATS *stats);
+
+/* All above routines will set the global variable isam_error when an
+   error occurs. Like the standard routine perror, isam_perror should
+   print a suitable error message to stderr, optionally preceded by the
+   message mess provided by the user */
+int isam_perror(const char *mess);
+
+/*
+ * Not all of the following errors are actually used .... 
+ */
+enum isam_error
+{
+	ISAM_NO_ERROR = (0),
+	ISAM_WRITE_FAIL,
+	ISAM_KEY_LEN,
+	ISAM_FILE_EXISTS,
+	ISAM_LINK_EXISTS,
+	ISAM_OPEN_FAIL,
+	ISAM_NO_SUCH_FILE,
+	ISAM_OPEN_COUNT,
+	ISAM_INDEX_ERROR,
+	ISAM_READ_ERROR,
+	ISAM_BAD_MAGIC,
+	ISAM_BAD_VERSION,
+	ISAM_HEADER_ERROR,
+	ISAM_OPEN_FOR_UPDATE,
+	ISAM_IDENT_INVALID,
+	ISAM_NO_SUCH_KEY,
+	ISAM_NULL_KEY,
+	ISAM_DATA_MISMATCH,
+	ISAM_RECORD_EXISTS,
+	ISAM_SEEK_ERROR,
+	ISAM_SOF,
+	ISAM_EOF
+};
+
+extern enum isam_error isam_error;
+
+/*
+ * Statistics obtained using isam_fileStats.
+ */
+struct ISAM_FILE_STATS
+{
+    /* Statistics for regular (sequential) blocks.  */
+    unsigned long blocksRegularNEmpty;       /* # of totally empty blocks    */
+    unsigned long blocksRegularNPartial;     /* # of partially occupied blocks.  */
+    unsigned long blocksRegularNFull;        /* # of fully occupied blocks.  */
+    unsigned long blocksRegularUsedMin;      /* Smallest observed number of
+                                                used records in a block.     */
+    unsigned long blocksRegularUsedMax;      /* Largest observed number of
+                                                used records in a block.     */
+    unsigned long blocksRegularUsedAverage;  /* Average number of used records
+                                                in a block (floor).          */
+
+    unsigned long recordsRegularNEmpty;      /* # of empty records.          */
+    unsigned long recordsRegularNUsed;       /* # of used records.           */
+
+    /* Same as above, but for overflow blocks.  */
+    unsigned long blocksOverflowNEmpty;
+    unsigned long blocksOverflowNPartial;
+    unsigned long blocksOverflowNFull;
+    unsigned long blocksOverflowUsedMin;
+    unsigned long blocksOverflowUsedMax;
+    unsigned long blocksOverflowUsedAverage;
+
+    unsigned long recordsOverflowNEmpty;
+    unsigned long recordsOverflowNUsed;
+
+    /* Statistics for key length.  */
+    int keyMin;                              /* Smallest observed key length */
+    int keyMax;                              /* Largest observed key length  */
+    int keyAverage;                          /* Average key length (floor)   */
+};
+
+/*
+ * Cache statistics obtained through isam_cacheStats()
+ */
+struct ISAM_CACHE_STATS
+{
+	int
+		calls,   /* Times the cache got called */
+		reads,   /* Times we needed to read from disk */
+		writes,  /* Times we wrote to it */
+		hwrites; /* Times we wrote a header */
+};
+
+#endif

os/ass5/isam_test.c

+/* This file contains the source for a very basic program to test the
+   isam library.
+   The program should be linked with the isam.o and index.o files.
+   To run it, give it one parameter: the isam file. If no such file
+   exists, it will be created.
+   The program will ask for a key; if no record with that key exists,
+   you will be allowed to create it, otherwise you are offered several
+   possibilities.
+   -------------------------------------------------------------------------
+Author: G.D. van Albada
+University of Amsterdam
+Faculty of Science
+Informatics Institute
+dick at science.uva.nl
+Version: 0.0
+Date: December 2001 / January 2002
+-------------------------------------------------------------------------
+The program should not be considered to be a good example of production
+code - it lacks comments, naming is ad-hoc, etc.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "isam.h"
+
+void
+instruct(void)
+{
+    char str[256];
+
+    printf("Do you want instuctions? (y/n) [y]\n");
+
+    if (!fgets(str, 256, stdin)) {
+        printf("Stopping program\n");
+        exit(0);
+    }
+
+    if (str[0] != 'y' && str[0] != 'Y' && str[0] != 'j' && str[0] != 'J')
+        return;
+    printf("This program allows you to test your isam routines.\n");
+    printf("Run it as\n");
+    printf("isam_test file_name\n");
+    printf("If a file file_name exists, isam_test will open it.\n");
+    printf("    (if the format and magic number is correct)\n");
+    printf("If it does not exist, isam_test will try to create a \n");
+    printf("file of that name.\n");
+    printf("Next, isam_test will enter a loop in which it\n");
+    printf("1. asks for a key value.\n");
+    printf("2. attempts to read a record with that key from the file.\n");
+    printf
+        ("3. if it succeeds, it will ask you if you want to delete or\n");
+    printf("   modify the record.\n");
+    printf
+        ("4. if it fails, isam_test will allow you to create a new record.\n");
+    printf
+        ("Isam_test leaves the loop only at the end of the input file.\n");
+    printf("Type a [ctrl]D to generate such an EOF from your keyboard.\n");
+    printf("The program can be made to execute illegal actions, like\n");
+    printf("creating a record with an existing key, or deleting a\n");
+    printf("non-existent record by specifying a second command-line\n");
+    printf("parameter. If this parameter is numerical with value N,\n");
+    printf("an illegal command will be generated every 1 in N\n");
+    printf("commands; otherwise N will be set to 4\n");
+    printf("\n");
+}
+
+int
+main(int argc, char *argv[])
+{
+    int     rv, i;
+    char    key[17], data[68], dat[68], str[256];
+    char    keyx[17];
+    int     N_illegal = 4, count;
+    isamPtr fd;
+
+    instruct();
+
+    if (argc < 2) {
+        printf("isam_test needs one (file) argument\n");
+        exit(23);
+    }
+
+    printf("Calling isam_open for %s\n", argv[1]);
+    fd = isam_open(argv[1], 1);
+    printf("Isam_open returned %p\n", fd);
+
+    if (fd == NULL) {
+        isam_perror("I.e.");
+        if (isam_error == ISAM_NO_SUCH_FILE
+                || isam_error == ISAM_OPEN_FAIL) {
+            printf("Now attempting to use isam_create\n");
+            fd = isam_create(argv[1], 17, 68, 12, 160);
+            printf("Isam_create returned %p\n", fd);
+            if (fd == NULL) {
+                isam_perror("I.e.");
+                printf("Stopping program\n");
+                exit(-3);
+            }
+        }
+        else {
+            printf("Stopping program\n");
+            exit(-3);
+        }
+    }
+    if (argc == 3) {
+        sscanf(argv[2], "%d", &N_illegal);
+        N_illegal = (N_illegal < 2) ? 2 : N_illegal;
+        printf("Attempting an illegal action every 1 out of %d times\n",
+                N_illegal);
+    }
+    else {
+        N_illegal = 1 << 30;
+    }
+    printf("Give key >");
+    count = 1;
+    while (fgets(str, 256, stdin)) {
+        i = strlen(str);
+        while (i && str[i] < ' ') {
+            str[i] = '\0';
+            i--;
+        }
+        str[16] = '\0';
+        strcpy(key, str);
+        rv = isam_readByKey(fd, key, data);
+        if (rv) {
+            isam_perror("Not found");
+            printf("No record with key '%s' found\n", key);
+        }
+        else {
+            printf("Key: '%s'\nData: '%s'\n", key, data);
+        }
+        if (count++ >= N_illegal) {
+            count = 1;
+            rv = (rv) ? 0 : -1;
+            printf("Attempting illegal action - beware!\n");
+        }
+        if (rv) {
+            printf("Create a record with key '%s' ?\n", key);
+            if (!fgets(str, 256, stdin)) {
+                printf("Stopping program\n");
+                if (isam_close(fd)) {
+                    isam_perror("Isam_closed failed miserably");
+                }
+                exit(0);
+            }
+            if (str[0] == 'y' || str[0] == 'Y') {
+                for (i = 0; i < 68; i++)
+                    data[i] = '#';
+                printf("Give data >");
+                if (!fgets(str, 256, stdin)) {
+                    printf("Stopping program\n");
+                    if (isam_close(fd)) {
+                        isam_perror("Isam_closed failed miserably");
+                    }
+                    exit(0);
+                }
+                i = strlen(str);
+                while (i && str[i] < ' ') {
+                    str[i] = '\0';
+                    i--;
+                }
+                str[67] = '\0';
+                for (i = 0; i < 68; i++)
+                    data[i] = '#';
+                strcpy(data, str);
+                if (isam_writeNew(fd, key, data))
+                    isam_perror("Error in isam_writeNew");
+            }
+            else {
+                strcpy(keyx, key);
+                isam_setKey(fd, key);
+                rv = isam_readNext(fd, key, data);
+                printf("Next record:");
+                if (rv) {
+                    isam_perror("Not found");
+                    printf("No record with key > '%s' found\n", key);
+                } else {
+                    printf("Key: '%s'\nData: '%s'\n", key, data);
+                }
+                isam_setKey(fd, keyx);
+                rv = isam_readPrev(fd, key, data);
+                printf("Preceding record:");
+                if (rv) {
+                    isam_perror("Not found");
+                    printf("No record with key < '%s' found\n", keyx);
+                }
+                else {
+                    printf("Key: '%s'\nData: '%s'\n", key, data);
+                }
+            }
+        }
+        else {
+nogeens:
+            printf
+                ("[N]ext, [P]revious, [D]elete or [U]pdate record with this key?\n");
+            if (!fgets(str, 256, stdin)) {
+                printf("Stopping program\n");
+                if (isam_close(fd)) {
+                    isam_perror("Isam_closed failed miserably");
+                }
+                exit(0);
+            }
+            if (count++ >= N_illegal) {
+                count = 1;
+                data[0]++;
+                data[17] = '\0';
+                printf("Attempting illegal action - beware!\n");
+            }
+            switch (str[0]) {
+                case 'd':
+                case 'D':
+                    if (isam_delete(fd, key, data))
+                        isam_perror("Error in isam_delete");
+                    break;
+                case 'u':
+                case 'U':
+                    printf("Give data >");
+                    if (!fgets(str, 256, stdin)) {
+                        printf("Stopping program\n");
+                        if (isam_close(fd)) {
+                            isam_perror("Isam_closed failed miserably");
+                        }
+                        exit(0);
+                    }
+                    i = strlen(str);
+                    while (i && str[i] < ' ') {
+                        str[i] = '\0';
+                        i--;
+                    }
+                    str[67] = '\0';
+                    for (i = 0; i < 68; i++)
+                        dat[i] = '#';
+                    strcpy(dat, str);
+                    if (isam_update(fd, key, data, dat))
+                        isam_perror("Error in isam_update");
+                    break;
+                case 'n':
+                case 'N':
+                    rv = isam_readNext(fd, key, data);
+                    printf("Next record:");
+                    if (rv) {
+                        isam_perror("Not found");
+                        printf("No record with key > '%s' found\n", key);
+                        break;
+                    }
+                    else {
+                        printf("Key: '%s'\nData: '%s'\n", key, data);
+                    }
+                    goto nogeens;
+                case 'p':
+                case 'P':
+                    rv = isam_readPrev(fd, key, data);
+                    printf("Preceding record:");
+                    if (rv) {
+                        isam_perror("Not found");
+                        printf("No record with key < '%s' found\n", key);
+                        break;
+                    }
+                    else {
+                        printf("Key: '%s'\nData: '%s'\n", key, data);
+                    }
+                    goto nogeens;
+            }
+        }
+        printf("Give key >");
+    }
+
+    printf("Normal end of programme\n");
+    isam_close(fd);
+
+    return 0;
+}

os/ass5/namen

+Aarnoudse; ;
+Afsarmanesh; ;
+Akker;van den ;
+Al-Dabass; ;
+Alava; ;
+Albada;van ;
+Albright; ;
+Alexandrov; ;
+Allen; ;
+Amersfoort;van ;
+Apers; ;
+Arlabosse; ;
+Artoli; ;
+Aten; ;
+Athanassoula; ;
+Atherton; ;
+Baerends; ;
+Baggio; ;
+Bajaja; ;
+Baker; ;
+Bal; ;
+Ballintijn; ;
+Bartosek; ;
+Bauckhage; ;
+Baud; ;
+Beemster; ;
+Belleman; ;
+Belloum; ;
+Bergman; ;
+Bernhardt; ;
+Bhoedjang; ;
+Binder; ;
+Blaak; ;
+Blom; ;
+Blume; ;
+Boasson; ;
+Bode; ;
+Boer;den ;
+Bontekoe; ;
+Boonand; ;
+Boulanger; ;
+Bouten; ;
+Braan; ;
+Braekman; ;
+Brebbia; ;
+Breeman; ;
+Brinkhorst; ;
+Brummen;van ;
+Bubak; ;
+Buchner; ;
+Buyya; ;
+Capasso; ;
+Carbone; ;
+Carels; ;
+Chen; ;
+Cheng; ;
+Chylek; ;
+Clague; ;
+Clinckemaillie; ;
+Coccia; ;
+Colbrook; ;
+Corperaal; ;
+Coveney; ;
+Crilly; ;
+Cuesta; ;
+Dantzig;van ;
+Davier; ;
+Davies; ;
+Dekker; ;
+Dekker; ;
+Demongeot; ;
+Deurloo; ;
+Dijkman; ;
+Dikken; ;
+Dillman; ;
+Doi; ;
+Dongarra; ;
+Donk;van der ;
+Doornbos; ;
+Doornbos; ;
+Dorst; ;
+Driel;van ;
+Dubbeldam; ;
+Dubois; ;
+Earnshaw; ;
+Ebeling; ;
+Elout; ;
+Emmen; ;
+Epema; ;
+Ercal; ;
+Evans; ;
+Fafone; ;
+Farman; ;
+Figdor; ;
+Finmo; ;
+Flokstra; ;
+Floros; ;
+Freijlink; ;
+Frenkel; ;
+Friedrich; ;
+Frijlink; ;
+Fritzon; ;
+Frossati; ;
+Fu; ;
+Fuchs; ;
+Funika; ;
+Garcia-Ruiz; ;
+Gaussens; ;
+Gehring; ;
+Gemund;van ;
+Gentzsch; ;
+Germans; ;
+Gershon; ;
+Gillet; ;
+Gisbergen;van ;
+Graaf;van der ;
+Graaff; ;
+Grandinetti; ;
+Grethlein; ;
+Greve; ;
+Grimminck; ;
+Groen; ;
+Gromov; ;
+Grondelle;van ;
+Groot;de ;
+Grooth;de ;
+Gruber; ;
+Gueron; ;
+Guravage; ;
+Haan; ;
+Habing; ;
+Halderen;van ;
+Hamza; ;
+Hanegraaff; ;
+Hannema; ;
+Harms; ;
+Hartel; ;
+Heederik; ;
+Heethaar; ;
+Heijboer; ;
+Heijboer; ;
+Heijnsdijk; ;
+Heinz; ;
+Hello; ;
+Hendrikse; ;
+Hertzberger; ;
+Heuvel;van den ;
+Hirleman; ;
+Hirose; ;
+Hoefsloot; ;
+Hoekstra; ;
+Hoffmann; ;
+Hofman; ;
+Holten;van ;
+Holtslag; ;
+Hossfeld; ;
+Hovenier; ;
+Witt-Huberts;de;
+Hulst;van der ;
+Hummel; ;
+Huntley; ;
+Huot; ;
+Hussaini; ;
+Hllen; ;
+Iedema; ;
+Inamura; ;
+Ingber; ;
+Iskra; ;
+Jacobs; ;
+Jane; ;
+Jones; ;
+Jonker; ;
+Juliano; ;
+Kaandorp; ;
+Kacsuk; ;
+Kaiser; ;
+Kanade; ;
+Kandhai; ;
+Kanter;de ;
+Karsch; ;
+Kartawidjaja; ;
+Karyadi; ;
+Kasdorp; ;
+Kataja; ;
+Kate;ten ;
+Kauranne; ;
+Kempen;van ;
+Kerckhoffs; ;
+Kester; ;
+Kielmann; ;
+Kluijver;de ;
+Knijnenburg; ;
+Koburg; ;
+Koelink; ;
+Koelma; ;
+Kolk;van der ;
+Kommers; ;
+Kong; ;
+Koponen; ;
+Kruit;van der ;
+Krse; ;
+Kuz; ;
+Laak;ter ;
+Laan;van der ;
+Lagendijk; ;
+Lagerberg; ;
+Laitinen; ;
+Lapiks; ;
+Larriba; ;
+Lauwerier; ;
+LePage; ;
+Leer;van ;
+Lees; ;
+Leeuwen;van ;
+Lehmann; ;
+Lemke; ;
+Lew; ;
+Liddell; ;
+Liet;van de ;
+Linden;van der ;
+Lisounkin; ;
+Livny; ;
+Lonsdale; ;
+Louis; ;
+Lowe; ;
+Lumme; ;
+Luque; ;
+Maaskant; ;
+Maassen; ;
+Machi'; ;
+Maeda; ;
+Marechal; ;
+Margalef; ;
+Marsh; ;
+Maruszewski; ;
+Matsushita; ;
+Mazzitelli; ;
+McEvoy; ;
+Meakin; ;
+Meijer; ;
+Mergel; ;
+Merks; ;
+Mes;de ;
+Metzler; ;
+Meyer; ;
+Michalewicz; ;
+Mishchenko; ;
+Mocinski; ;
+Mochnacki; ;
+Monien; ;
+Mourabit;al ;
+Muinonen; ;
+Muiswinkel;van ;
+Mul;de ;
+Nadrachal; ;
+Nazief; ;
+Nieuwpoort;van ;
+Nijhof; ;
+Nijs;de ;
+Niskanen; ;
+Noga; ;
+Noordmans; ;
+Nooren; ;
+Noteboom; ;
+Obelleiro; ;
+Oberski; ;
+Olariu; ;
+Onate; ;
+Overeinder; ;
+Pagter;de ;
+Pallottino; ;
+Pandolfi; ;
+Papathanassiadis; ;
+Pavelka; ;
+Pedlar; ;
+Peek; ;
+Petersen; ;
+Piech; ;
+Pierre; ;
+Pimentel; ;
+Piskunov; ;
+Pizzella; ;
+Podhorszki; ;
+Pol; ;
+Potma; ;
+Powers; ;
+Pronk; ;
+Prusinkiewicz; ;
+Quinten; ;
+Radulescu; ;
+Rahola; ;
+Rechenberg; ;
+Reeuwijk;van ;
+Reeve; ;
+Reinefeld; ;
+Rembold; ;
+Renambot; ;
+Renes; ;
+Renner; ;
+Roberts; ;
+Rodriguez; ;
+Rogalla; ;
+Roller; ;
+Romein; ;
+Haar Romeny;ter;
+Ronde;de ;
+Ronga; ;
+Boer Rookhuizen; ;
+Rosendale;van ;
+Rozemeijer; ;
+Rue;de ;
+Ruiter;de ;
+Rhl; ;
+Sander; ;
+Sanders; ;
+Santoso; ;
+Satz; ;
+Schaeffer; ;
+Schimmel; ;
+Schoneveld; ;
+Schrer; ;
+Schwefel; ;
+Serazzi; ;
+Shane; ;
+Shlesinger; ;
+Silfhout;van ;
+Simon; ;
+Sips; ;
+Sloot; ;
+Sluijk; ;
+Sluiter; ;
+Smit; ;
+Smyth; ;
+Soest;van ;
+Soliman; ;
+Soll; ;
+Somsen; ;
+Sowa-Pieklo; ;
+Spijk; ;
+Spinnato; ;
+Spitzer; ;
+Spoelder; ;
+Steen;van der ;
+Steen;van ;
+Steman; ;
+Stolk; ;
+Streekstra; ;
+Suarez; ;
+Succi; ;
+Swart;de ;
+Szopa; ;
+Talia; ;
+Tan; ;
+Tanenbaum; ;
+Tel; ;
+Tensen; ;
+Teuben; ;
+Thevenon; ;
+Thorpe; ;
+Timonen; ;
+Tolxdorff; ;
+Tomassini; ;
+Tonino; ;
+Travis; ;
+Trenning; ;
+Trip; ;
+Trizac; ;
+Tzafestas; ;
+Valero; ;
+Vandoni; ;
+Vannier; ;
+Veldema; ;
+Venema; ;
+Veneziano; ;
+Verbraeck; ;
+Verstoep; ;
+Vesseur; ;
+Vicsek; ;
+Vidal; ;
+Videen; ;
+Visser; ;
+Vlachoutsis; ;
+Vliet;van ;
+Voigt; ;
+Voogd; ;
+Vosselman; ;
+Vossepoel; ;
+Vries;de ;
+Vries;de ;
+Waele;de ;
+Wals; ;
+Wang; ;
+Wasniewsky; ;
+Wassmuth; ;
+Waters; ;
+Weerts; ;
+Wesselius; ;
+Westerhoff; ;
+Wijker; ;
+Wilkinson; ;
+Williams; ;
+Wismller; ;
+Withagen; ;
+Woerden;van ;
+Wolters; ;
+Wolters; ;
+Wriedt; ;
+Wyrzykowski; ;
+Wrn; ;
+Yakali; ;
+Zaremba; ;
+Zbik; ;
+Zhang; ;
+Zhang; ;
+Zhao; ;
+ZhongWei; ;
+Zhou; ;
+Zijp; ;
+Zomaya; ;
+Zuidervaart; ;

os/ass5/titels

+De heer
+Mevrouw
+De heer
+Mevrouw
+De heer
+Mevrouw
+De heer
+Mevrouw
+De heer
+Mevrouw
+Mw. dr.
+Mw. drs.
+dra.
+dr.
+drs.