Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/std/util/rand-glfsr.c b/std/util/rand-glfsr.c
new file mode 100644
index 0000000..8bd624c
--- /dev/null
+++ b/std/util/rand-glfsr.c
@@ -0,0 +1,155 @@
+/* Dieses File implementiert einen Pseudo-Zufallszahlengenerator mit einem
+ * Linear Feedback Shift Register in der Galois-Variante.
+ * Dieses PRNG ist schlechter und viel ineffizienter als der im Driver
+ * eingebaute.
+ * Die einzige sinnvolle Anwendung ist, wenn man aus irgendeinem Grund das
+ * seed selber waehlen muss, damit man die Sequenz von Pseudozufall immer
+ * wieder reproduzieren kann.
+ *
+ * Das Seed von der Blueprint wird vermutlich staendig veraendert (d.h.
+ * verlasst euch nicht drauf, dass es konstant bleibt), wollt ihr eine
+ * 'private' Instanz mit eurem Seed, clont das Objekt (aber verliert den Clone
+ * nicht).
+ *
+ * Es wird standardmaessig ein Polynom fuer eine Periodenlaenge von 2^32 - 1
+ * verwendet.
+ *
+ * Im Netz finden sich Infos ueber LFSRs und Tabellen fuer maximum-length
+ * feedback polynomials (M-Sequence Feedback Taps), falls jemand braucht.
+ *
+*/
+#pragma strong_types,rtt_checks,pedantic
+
+#include <tls.h>
+
+// Default-Polynom ist das:
+// x^32 + x^31 + x^28 + x^27 + x^24 + x^23 + x^20 + x^19 + x^16 + x^15 + x^12
+// + x^11 + x^8 + x^7 + x^5 + x^3 + 1
+// Taps: 32, 31, 28, 27, 24, 23, 20, 19, 16, 15, 12, 11, 8, 7, 5, 3
+// Binary: 110011001100110011001100110101000
+#define DEFAULTP 0x1999999a8
+// Andere gebraeuchliche:
+// x^32 + x^30 + x^26 + x^25 + 1,
+// Taps 32, 30, 26, 25
+// Binary: 101000110000000000000000000000000
+//#define DEFAULTP 0x146000000
+// x^16 + x^14 + x^13 + x^11 + 1
+// Taps 16, 14, 13, 11
+// Binary: 1011010000000000
+//#define DEFAULTP 0xB400
+
+private int polynom = DEFAULTP;
+private int state = 2553647223;
+//private int period;
+
+public varargs void init(int seed, int newp)
+{
+ if (!seed)
+ raise_error("Illegal seed 0\n");
+ // Es darf nur ein 32 bit breiter Seed verwendet werden. Die oberen 32 bit
+ // werden mit den unteren 32 bit XOR-rt (also, einmal die oberen 32 shiften
+ // und einmal die oberen 32 wegmaskieren.
+ seed = ((seed>>32) & 0xffffffff) ^ (seed & 0xffffffff);
+ //printf("Seed: %064b - 0x%x\n",seed,seed);
+
+ if (!seed)
+ raise_error("Illegal reduced seed: 0\n");
+
+ state = seed;
+ polynom = newp || DEFAULTP;
+}
+
+public void InitWithUUID(string uuid)
+{
+ string md5hash = hash(TLS_HASH_MD5, uuid);
+ int seed;
+ // 8 Bytes aus dem Hash ermitteln
+ foreach(int b: 16)
+ {
+ // Jeweils zwei Zeichen herausschneiden und als Hexadezimalzahl
+ // interpretieren, was jeweils ein byte (8 bit) gibt.
+ int tmp = to_int("0x"+md5hash[b*2..b*2+1]);
+ // diese werden dann in eine 64 bit breite Zahl zusammengefasst. Das
+ // gerade ermittelte Byte wird nach links geshiftet und mit dem, was da
+ // ggf. schon steht, XORred. Ist der int voll, faengt man wegen Modulo 64
+ // wieder rechts an.
+ //printf("S: %064b - %08b\n",seed,tmp);
+ seed = seed ^ (tmp << ((b*8)%64));
+ //printf("S: %064b - 0x%x\n",seed, seed);
+ }
+ //printf("Seed: 0x%x - %b\n",seed,seed);
+ init(seed);
+}
+
+public int nextbit()
+{
+ // Get LSB (i.e., the output bit).
+ int lsb = state & 1;
+ // Shift register by one bit
+ state >>= 1;
+ // Apply a toggle mask, which flips all the tap bits, _if_ the output bit is
+ // 1. The mask has 1 at bits corresponding to taps, 0 elsewhere. In other
+ // words, the polynom from above.
+ if (lsb)
+ state ^= polynom;
+ // debug check ;-)
+ if (!state)
+ raise_error("State must not be zero, but it is.\n");
+ //++period;
+ //printf("State: %032b (Period: %d)\n",state,period);
+ return lsb;
+}
+
+public int nextbits(int count)
+{
+ int result;
+ if (count>64)
+ raise_error(sprintf("Count is %d, but must be <= 64.\n",count));
+ foreach(int i: count)
+ result = (result << 1) | nextbit();
+ return result;
+}
+
+public int nextbyte()
+{
+ return nextbits(8);
+}
+
+public int random(int n)
+{
+ int rnd = nextbits(32);
+ //generates a random number on [0,1)-real-interval
+ float tmp = rnd * (1.0/4294967296.0);
+ // Skalieren auf [0,n)
+ return to_int(tmp * n);
+}
+
+// Just skip some bits and discard them.
+public void skipbits(int count)
+{
+ foreach(int i: count)
+ nextbit();
+}
+
+
+public void dumpstream(string file, int bytes)
+{
+ int *stream = allocate(bytes);
+ foreach(int i: bytes)
+ {
+ stream[i] = nextbits(8);
+ }
+ write_file(file, sprintf("%@c",stream));
+}
+
+public int Configure(int data)
+{
+ if (!data)
+ return state;
+
+ if (!intp(data))
+ return 0;
+ state = data;
+ return 1;
+}
+