pygments.rb 0.5.4 → 0.6.0

data/vendor/pygments-main/tests/examplefiles/hash_syntax.rb

@@ -0,0 +1,5 @@
+{ :old_syntax => 'ok' }
+{ 'stings as key' => 'should be ok' }
+{ new_syntax: 'broken until now' }
+{ withoutunderscore: 'should be ok' }
+{ _underscoreinfront: 'might be ok, if I understand the pygments code correct' }

data/vendor/pygments-main/tests/examplefiles/hello.at

@@ -0,0 +1,6 @@
+def me := object: {
+    def name := "Kevin";
+    def sayHello(peerName) {
+        system.println(peerName + " says hello!");
+    };
+};

data/vendor/pygments-main/tests/examplefiles/hello.golo

@@ -0,0 +1,5 @@
+module hello.World
+
+function main = |args| {
+  println("Hello world!")
+}

data/vendor/pygments-main/tests/examplefiles/hello.lsl

@@ -0,0 +1,12 @@
+default
+{
+    state_entry()
+    {
+        llSay(0, "Hello, Avatar!");
+    }
+ 
+    touch_start(integer total_number)
+    {
+        llSay(0, "Touched.");
+    }
+}

data/vendor/pygments-main/tests/examplefiles/iex_example

@@ -0,0 +1,23 @@
+iex> :" multi
+...>  line ' \s \123 \x20
+...> atom"
+:" multi\n line '   S  \natom"
+
+iex(1)> <<"hello"::binary, c :: utf8, x::[4, unit(2)]>> = "hello™1"
+"hello™1"
+
+iex(2)> c
+8482
+
+iex> 1 + :atom
+** (ArithmeticError) bad argument in arithmetic expression
+    :erlang.+(1, :atom)
+
+iex(3)> 1 +
+...(3)> 2 +
+...(3)> 3
+6
+
+iex> IO.puts "Hello world"
+Hello world
+:ok

data/vendor/pygments-main/tests/examplefiles/inet_pton6.dg

@@ -1,5 +1,5 @@
-re  = import!
-sys = import!
+import '/re'
+import '/sys'
 
 
 # IPv6address    =  hexpart [ ":" IPv4address ]
@@ -20,7 +20,7 @@ addrv6  = re.compile $ r'(?i)(?:{})(?::{})?$'.format hexpart addrv4
 #
 # :return: a decimal integer
 #
-base_n = (q digits) -> foldl (x y) -> (x * q + y) 0 digits
+base_n = q digits -> foldl (x y -> x * q + y) 0 digits
 
 
 # Parse a sequence of hexadecimal numbers
@@ -29,7 +29,7 @@ base_n = (q digits) -> foldl (x y) -> (x * q + y) 0 digits
 #
 # :return: an iterable of Python ints
 #
-unhex = q -> q and map p -> (int p 16) (q.split ':')
+unhex = q -> q and map (p -> int p 16) (q.split ':')
 
 
 # Parse an IPv6 address as specified in RFC 4291.
@@ -39,33 +39,33 @@ unhex = q -> q and map p -> (int p 16) (q.split ':')
 # :return: an integer which, written in binary form, points to the same node.
 #
 inet_pton6 = address ->
-  raise $ ValueError 'not a valid IPv6 address' if not (match = addrv6.match address)
+  not (match = addrv6.match address) => raise $ ValueError 'not a valid IPv6 address'
   start, end, *ipv4 = match.groups!
 
   is_ipv4 = not $ None in ipv4
   shift   = (7 - start.count ':' - 2 * is_ipv4) * 16
 
-  raise $ ValueError 'not a valid IPv6 address' if (end is None and shift) or shift < 0
+  (end is None and shift) or shift < 0 => raise $ ValueError 'not a valid IPv6 address'
   hexaddr = (base_n 0x10000 (unhex start) << shift) + base_n 0x10000 (unhex $ end or '')
-  (hexaddr << 32) + base_n 0x100 (map int ipv4) if is_ipv4 else hexaddr
+  if (is_ipv4 => (hexaddr << 32) + base_n 0x100 (map int ipv4)) (otherwise => hexaddr)
 
 
-inet6_type = q -> switch
-  not q = 'unspecified'
-  q == 1 = 'loopback'
-  (q >>  32)              == 0x000000000000ffff = 'IPv4-mapped'
-  (q >>  64)              == 0xfe80000000000000 = 'link-local'
-  (q >> 120)              != 0x00000000000000ff = 'general unicast'
-  (q >> 112) % (1 << 4)   == 0x0000000000000000 = 'multicast w/ reserved scope value'
-  (q >> 112) % (1 << 4)   == 0x000000000000000f = 'multicast w/ reserved scope value'
-  (q >> 112) % (1 << 4)   == 0x0000000000000001 = 'interface-local multicast'
-  (q >> 112) % (1 << 4)   == 0x0000000000000004 = 'admin-local multicast'
-  (q >> 112) % (1 << 4)   == 0x0000000000000005 = 'site-local multicast'
-  (q >> 112) % (1 << 4)   == 0x0000000000000008 = 'organization-local multicast'
-  (q >> 112) % (1 << 4)   == 0x000000000000000e = 'global multicast'
-  (q >> 112) % (1 << 4)   != 0x0000000000000002 = 'multicast w/ unknown scope value'
-  (q >>  24) % (1 << 112) == 0x00000000000001ff = 'solicited-node multicast'
-  True = 'link-local multicast'
+inet6_type = q -> if
+  q == 0 => 'unspecified'
+  q == 1 => 'loopback'
+  (q >>  32)              == 0x000000000000ffff => 'IPv4-mapped'
+  (q >>  64)              == 0xfe80000000000000 => 'link-local'
+  (q >> 120)              != 0x00000000000000ff => 'general unicast'
+  (q >> 112) % (1 << 4)   == 0x0000000000000000 => 'multicast w/ reserved scope value'
+  (q >> 112) % (1 << 4)   == 0x000000000000000f => 'multicast w/ reserved scope value'
+  (q >> 112) % (1 << 4)   == 0x0000000000000001 => 'interface-local multicast'
+  (q >> 112) % (1 << 4)   == 0x0000000000000004 => 'admin-local multicast'
+  (q >> 112) % (1 << 4)   == 0x0000000000000005 => 'site-local multicast'
+  (q >> 112) % (1 << 4)   == 0x0000000000000008 => 'organization-local multicast'
+  (q >> 112) % (1 << 4)   == 0x000000000000000e => 'global multicast'
+  (q >> 112) % (1 << 4)   != 0x0000000000000002 => 'multicast w/ unknown scope value'
+  (q >>  24) % (1 << 112) == 0x00000000000001ff => 'solicited-node multicast'
+  otherwise => 'link-local multicast'
 
 
-print $ (x -> (inet6_type x, hex x)) $ inet_pton6 $ sys.stdin.read!.strip!
+print $ (x -> inet6_type x, hex x) $ inet_pton6 $ sys.stdin.read!.strip!

data/vendor/pygments-main/tests/examplefiles/language.hy

@@ -0,0 +1,165 @@
+;;;; This contains some of the core Hy functions used
+;;;; to make functional programming slightly easier.
+;;;;
+
+
+(defn _numeric-check [x]
+  (if (not (numeric? x))
+    (raise (TypeError (.format "{0!r} is not a number" x)))))
+
+(defn cycle [coll]
+  "Yield an infinite repetition of the items in coll"
+  (setv seen [])
+  (for [x coll]
+    (yield x)
+    (.append seen x))
+  (while seen
+    (for [x seen]
+      (yield x))))
+
+(defn dec [n]
+  "Decrement n by 1"
+  (_numeric-check n)
+  (- n 1))
+
+(defn distinct [coll]
+  "Return a generator from the original collection with duplicates
+   removed"
+  (let [[seen []] [citer (iter coll)]]
+    (for [val citer]
+      (if (not_in val seen)
+        (do
+         (yield val)
+         (.append seen val))))))
+
+(defn drop [count coll]
+  "Drop `count` elements from `coll` and yield back the rest"
+  (let [[citer (iter coll)]]
+    (try (for [i (range count)]
+           (next citer))
+         (catch [StopIteration]))
+    citer))
+
+(defn even? [n]
+  "Return true if n is an even number"
+  (_numeric-check n)
+  (= (% n 2) 0))
+
+(defn filter [pred coll]
+  "Return all elements from `coll` that pass `pred`"
+  (let [[citer (iter coll)]]
+    (for [val citer]
+      (if (pred val)
+        (yield val)))))
+
+(defn inc [n]
+  "Increment n by 1"
+  (_numeric-check n)
+  (+ n 1))
+
+(defn instance? [klass x]
+  (isinstance x klass))
+
+(defn iterable? [x]
+  "Return true if x is iterable"
+  (try (do (iter x) true)
+       (catch [Exception] false)))
+
+(defn iterate [f x]
+  (setv val x)
+  (while true
+    (yield val)
+    (setv val (f val))))
+
+(defn iterator? [x]
+  "Return true if x is an iterator"
+  (try (= x (iter x))
+       (catch [TypeError] false)))
+
+(defn neg? [n]
+  "Return true if n is < 0"
+  (_numeric-check n)
+  (< n 0))
+
+(defn none? [x]
+  "Return true if x is None"
+  (is x None))
+
+(defn numeric? [x]
+  (import numbers)
+  (instance? numbers.Number x))
+
+(defn nth [coll index]
+  "Return nth item in collection or sequence, counting from 0"
+  (if (not (neg? index))
+    (if (iterable? coll)
+      (try (first (list (take 1 (drop index coll))))
+           (catch [IndexError] None))
+      (try (get coll index)
+           (catch [IndexError] None)))
+    None))
+
+(defn odd? [n]
+  "Return true if n is an odd number"
+  (_numeric-check n)
+  (= (% n 2) 1))
+
+(defn pos? [n]
+  "Return true if n is > 0"
+  (_numeric_check n)
+  (> n 0))
+
+(defn remove [pred coll]
+  "Return coll with elements removed that pass `pred`"
+  (let [[citer (iter coll)]]
+    (for [val citer]
+      (if (not (pred val))
+        (yield val)))))
+
+(defn repeat [x &optional n]
+  "Yield x forever or optionally n times"
+  (if (none? n)
+    (setv dispatch (fn [] (while true (yield x))))
+    (setv dispatch (fn [] (for [_ (range n)] (yield x)))))
+  (dispatch))
+
+(defn repeatedly [func]
+  "Yield result of running func repeatedly"
+  (while true
+    (yield (func))))
+
+(defn take [count coll]
+  "Take `count` elements from `coll`, or the whole set if the total
+    number of entries in `coll` is less than `count`."
+  (let [[citer (iter coll)]]
+    (for [_ (range count)]
+      (yield (next citer)))))
+
+(defn take-nth [n coll]
+  "Return every nth member of coll
+     raises ValueError for (not (pos? n))"
+  (if (pos? n)
+    (let [[citer (iter coll)] [skip (dec n)]]
+      (for [val citer]
+        (yield val)
+        (for [_ (range skip)]
+          (next citer))))
+    (raise (ValueError "n must be positive"))))
+
+(defn take-while [pred coll]
+  "Take all elements while `pred` is true"
+  (let [[citer (iter coll)]]
+    (for [val citer]
+      (if (pred val)
+        (yield val)
+        (break)))))
+
+(defn zero? [n]
+  "Return true if n is 0"
+  (_numeric_check n)
+  (= n 0))
+
+(def *exports* ["cycle" "dec" "distinct" "drop" "even?" "filter" "inc"
+                "instance?" "iterable?" "iterate" "iterator?" "neg?"
+                "none?" "nth" "numeric?" "odd?" "pos?" "remove" "repeat"
+                "repeatedly" "take" "take_nth" "take_while" "zero?"])

data/vendor/pygments-main/tests/examplefiles/limbo.b

@@ -0,0 +1,456 @@
+implement Ninewin;
+include "sys.m";
+	sys: Sys;
+include "draw.m";
+	draw: Draw;
+	Image, Display, Pointer: import draw;
+include "arg.m";
+include "keyboard.m";
+include "tk.m";
+include "wmclient.m";
+	wmclient: Wmclient;
+	Window: import wmclient;
+include "sh.m";
+	sh: Sh;
+
+# run a p9 graphics program (default rio) under inferno wm,
+# making available to it:
+# /dev/winname - naming the current inferno window (changing on resize)
+# /dev/mouse - pointer file + resize events; write to change position
+# /dev/cursor - change appearance of cursor.
+# /dev/draw - inferno draw device
+# /dev/cons - read keyboard events, write to 9win stdout.
+
+Ninewin: module {
+	init: fn(ctxt: ref Draw->Context, argv: list of string);
+};
+winname: string;
+
+init(ctxt: ref Draw->Context, argv: list of string)
+{
+	size := Draw->Point(500, 500);
+	sys = load Sys Sys->PATH;
+	draw = load Draw Draw->PATH;
+	wmclient = load Wmclient Wmclient->PATH;
+	wmclient->init();
+	sh = load Sh Sh->PATH;
+
+	buts := Wmclient->Resize;
+	if(ctxt == nil){
+		ctxt = wmclient->makedrawcontext();
+		buts = Wmclient->Plain;
+	}
+	arg := load Arg Arg->PATH;
+	arg->init(argv);
+	arg->setusage("9win [-s] [-x width] [-y height]");
+	exportonly := 0;
+	while(((opt := arg->opt())) != 0){
+		case opt {
+		's' =>
+			exportonly = 1;
+		'x' =>
+			size.x = int arg->earg();
+		'y' =>
+			size.y = int arg->earg();
+		* =>
+			arg->usage();
+		}
+	}
+	if(size.x < 1 || size.y < 1)
+		arg->usage();
+	argv = arg->argv();
+	if(argv != nil && hd argv == "-s"){
+		exportonly = 1;
+		argv = tl argv;
+	}
+	if(argv == nil && !exportonly)
+		argv = "rio" :: nil;
+	if(argv != nil && exportonly){
+		sys->fprint(sys->fildes(2), "9win: no command allowed with -s flag\n");
+		raise "fail:usage";
+	}
+	title := "9win";
+	if(!exportonly)
+		title += " " + hd argv;
+	w := wmclient->window(ctxt, title, buts);
+	w.reshape(((0, 0), size));
+	w.onscreen(nil);
+	if(w.image == nil){
+		sys->fprint(sys->fildes(2), "9win: cannot get image to draw on\n");
+		raise "fail:no window";
+	}
+
+	sys->pctl(Sys->FORKNS|Sys->NEWPGRP, nil);
+	ld := "/n/9win";
+	if(sys->bind("#s", ld, Sys->MREPL) == -1 &&
+			sys->bind("#s", ld = "/n/local", Sys->MREPL) == -1){
+		sys->fprint(sys->fildes(2), "9win: cannot bind files: %r\n");
+		raise "fail:error";
+	}
+	w.startinput("kbd" :: "ptr" :: nil);
+	spawn ptrproc(rq := chan of Sys->Rread, ptr := chan[10] of ref Pointer, reshape := chan[1] of int);
+
+		
+	fwinname := sys->file2chan(ld, "winname");
+	fconsctl := sys->file2chan(ld, "consctl");
+	fcons := sys->file2chan(ld, "cons");
+	fmouse := sys->file2chan(ld, "mouse");
+	fcursor := sys->file2chan(ld, "cursor");
+	if(!exportonly){
+		spawn run(sync := chan of string, w.ctl, ld, argv);
+		if((e := <-sync) != nil){
+			sys->fprint(sys->fildes(2), "9win: %s", e);
+			raise "fail:error";
+		}
+	}
+	spawn serveproc(w, rq, fwinname, fconsctl, fcons, fmouse, fcursor);
+	if(!exportonly){
+		# handle events synchronously so that we don't get a "killed" message
+		# from the shell.
+		handleevents(w, ptr, reshape);
+	}else{
+		spawn handleevents(w, ptr, reshape);
+		sys->bind(ld, "/dev", Sys->MBEFORE);
+		export(sys->fildes(0), w.ctl);
+	}
+}
+
+handleevents(w: ref Window, ptr: chan of ref Pointer, reshape: chan of int)
+{
+	for(;;)alt{
+	c := <-w.ctxt.ctl or
+	c = <-w.ctl =>
+		e := w.wmctl(c);
+		if(e != nil)
+			sys->fprint(sys->fildes(2), "9win: ctl error: %s\n", e);
+		if(e == nil && c != nil && c[0] == '!'){
+			alt{
+			reshape <-= 1 =>
+				;
+			* =>
+				;
+			}
+			winname = nil;
+		}
+	p := <-w.ctxt.ptr =>
+		if(w.pointer(*p) == 0){
+			# XXX would block here if client isn't reading mouse... but we do want to
+			# extert back-pressure, which conflicts.
+			alt{
+			ptr <-= p =>
+				;
+			* =>
+				; # sys->fprint(sys->fildes(2), "9win: discarding mouse event\n");
+			}
+		}
+	}
+}
+
+serveproc(w: ref Window, mouserq: chan of Sys->Rread, fwinname, fconsctl, fcons, fmouse, fcursor: ref Sys->FileIO)
+{
+	winid := 0;
+	krc: list of Sys->Rread;
+	ks: string;
+
+	for(;;)alt {
+	c := <-w.ctxt.kbd =>
+		ks[len ks] = inf2p9key(c);
+		if(krc != nil){
+			hd krc <-= (array of byte ks, nil);
+			ks = nil;
+			krc = tl krc;
+		}
+	(nil, d, nil, wc) := <-fcons.write =>
+		if(wc != nil){
+			sys->write(sys->fildes(1), d, len d);
+			wc <-= (len d, nil);
+		}
+	(nil, nil, nil, rc) := <-fcons.read =>
+		if(rc != nil){
+			if(ks != nil){
+				rc <-= (array of byte ks, nil);
+				ks = nil;
+			}else
+				krc = rc :: krc;
+		}
+	(offset, nil, nil, rc) := <-fwinname.read =>
+		if(rc != nil){
+			if(winname == nil){
+				winname = sys->sprint("noborder.9win.%d", winid++);
+				if(w.image.name(winname, 1) == -1){
+					sys->fprint(sys->fildes(2), "9win: namewin %q failed: %r", winname);
+					rc <-= (nil, "namewin failure");
+					break;
+				}
+			}
+			d := array of byte winname;
+			if(offset < len d)
+				d = d[offset:];
+			else
+				d = nil;
+			rc <-= (d, nil);
+		}
+	(nil, nil, nil, wc) := <-fwinname.write =>
+		if(wc != nil)
+			wc <-= (-1, "permission denied");
+	(nil, nil, nil, rc) := <-fconsctl.read =>
+		if(rc != nil)
+			rc <-= (nil, "permission denied");
+	(nil, d, nil, wc) := <-fconsctl.write =>
+		if(wc != nil){
+			if(string d != "rawon")
+				wc <-= (-1, "cannot change console mode");
+			else
+				wc <-= (len d, nil);
+		}
+	(nil, nil, nil, rc) := <-fmouse.read =>
+		if(rc != nil)
+			mouserq <-= rc;
+	(nil, d, nil, wc) := <-fmouse.write =>
+		if(wc != nil){
+			e := cursorset(w, string d);
+			if(e == nil)
+				wc <-= (len d, nil);
+			else
+				wc <-= (-1, e);
+		}
+	(nil, nil, nil, rc) := <-fcursor.read =>
+		if(rc != nil)
+			rc <-= (nil, "permission denied");
+	(nil, d, nil, wc) := <-fcursor.write =>
+		if(wc != nil){
+			e := cursorswitch(w, d);
+			if(e == nil)
+				wc <-= (len d, nil);
+			else
+				wc <-= (-1, e);
+		}
+	}
+}
+
+ptrproc(rq: chan of Sys->Rread, ptr: chan of ref Pointer, reshape: chan of int)
+{
+	rl: list of Sys->Rread;
+	c := ref Pointer(0, (0, 0), 0);
+	for(;;){
+		ch: int;
+		alt{
+		p := <-ptr =>
+			ch = 'm';
+			c = p;
+		<-reshape =>
+			ch = 'r';
+		rc := <-rq =>
+			rl  = rc :: rl;
+			continue;
+		}
+		if(rl == nil)
+			rl = <-rq :: rl;
+		hd rl <-= (sys->aprint("%c%11d %11d %11d %11d ", ch, c.xy.x, c.xy.y, c.buttons, c.msec), nil);
+		rl = tl rl;
+	}
+}
+
+cursorset(w: ref Window, m: string): string
+{
+	if(m == nil || m[0] != 'm')
+		return "invalid mouse message";
+	x := int m[1:];
+	for(i := 1; i < len m; i++)
+		if(m[i] == ' '){
+			while(m[i] == ' ')
+				i++;
+			break;
+		}
+	if(i == len m)
+		return "invalid mouse message";
+	y := int m[i:];
+	return w.wmctl(sys->sprint("ptr %d %d", x, y));
+}
+
+cursorswitch(w: ref Window, d: array of byte): string
+{
+	Hex: con "0123456789abcdef";
+	if(len d != 2*4+64)
+		return w.wmctl("cursor");
+	hot := Draw->Point(bglong(d, 0*4), bglong(d, 1*4));
+	s := sys->sprint("cursor %d %d 16 32 ", hot.x, hot.y);
+	for(i := 2*4; i < len d; i++){
+		c := int d[i];
+		s[len s] = Hex[c >> 4];
+		s[len s] = Hex[c & 16rf];
+	}
+	return w.wmctl(s);
+}
+
+run(sync, ctl: chan of string, ld: string, argv: list of string)
+{
+	Rcmeta: con "|<>&^*[]?();";
+	sys->pctl(Sys->FORKNS, nil);
+	if(sys->bind("#₪", "/srv", Sys->MCREATE) == -1){
+		sync <-= sys->sprint("cannot bind srv device: %r");
+		exit;
+	}
+	srvname := "/srv/9win."+string sys->pctl(0, nil);	# XXX do better.
+	fd := sys->create(srvname, Sys->ORDWR, 8r600);
+	if(fd == nil){
+		sync <-= sys->sprint("cannot create %s: %r", srvname);
+		exit;
+	}
+	sync <-= nil;
+	spawn export(fd, ctl);
+	sh->run(nil, "os" ::
+		"rc" :: "-c" ::
+			"mount "+srvname+" /mnt/term;"+
+			"rm "+srvname+";"+
+			"bind -b /mnt/term"+ld+" /dev;"+
+			"bind /mnt/term/dev/draw /dev/draw ||"+
+				"bind -a /mnt/term/dev /dev;"+
+			quotedc("cd"::"/mnt/term"+cwd()::nil, Rcmeta)+";"+
+			quotedc(argv, Rcmeta)+";"::
+			nil
+		);
+}
+
+export(fd: ref Sys->FD, ctl: chan of string)
+{
+	sys->export(fd, "/", Sys->EXPWAIT);
+	ctl <-= "exit";
+}
+
+inf2p9key(c: int): int
+{
+	KF: import Keyboard;
+
+	P9KF: con	16rF000;
+	Spec: con	16rF800;
+	Khome: con	P9KF|16r0D;
+	Kup: con	P9KF|16r0E;
+	Kpgup: con	P9KF|16r0F;
+	Kprint: con	P9KF|16r10;
+	Kleft: con	P9KF|16r11;
+	Kright: con	P9KF|16r12;
+	Kdown: con	Spec|16r00;
+	Kview: con	Spec|16r00;
+	Kpgdown: con	P9KF|16r13;
+	Kins: con	P9KF|16r14;
+	Kend: con	P9KF|16r18;
+	Kalt: con		P9KF|16r15;
+	Kshift: con	P9KF|16r16;
+	Kctl: con		P9KF|16r17;
+
+	case c {
+	Keyboard->LShift =>
+		return Kshift;
+	Keyboard->LCtrl =>
+		return Kctl;
+	Keyboard->LAlt =>
+		return Kalt;
+	Keyboard->Home =>
+		return Khome;
+	Keyboard->End =>
+		return Kend;
+	Keyboard->Up =>
+		return Kup;
+	Keyboard->Down =>
+		return Kdown;
+	Keyboard->Left =>
+		return Kleft;
+	Keyboard->Right =>
+		return Kright;
+	Keyboard->Pgup =>
+		return Kpgup;
+	Keyboard->Pgdown =>
+		return Kpgdown;
+	Keyboard->Ins =>
+		return Kins;
+
+	# function keys
+	KF|1 or
+	KF|2 or
+	KF|3 or
+	KF|4 or
+	KF|5 or
+	KF|6 or
+	KF|7 or
+	KF|8 or
+	KF|9 or
+	KF|10 or
+	KF|11 or
+	KF|12 =>
+		return (c - KF) + P9KF;
+	}
+	return c;
+}
+
+cwd(): string
+{
+	return sys->fd2path(sys->open(".", Sys->OREAD));
+}
+
+# from string.b, waiting for declaration to be uncommented.
+quotedc(argv: list of string, cl: string): string
+{
+	s := "";
+	while (argv != nil) {
+		arg := hd argv;
+		for (i := 0; i < len arg; i++) {
+			c := arg[i];
+			if (c == ' ' || c == '\t' || c == '\n' || c == '\'' || in(c, cl))
+				break;
+		}
+		if (i < len arg || arg == nil) {
+			s += "'" + arg[0:i];
+			for (; i < len arg; i++) {
+				if (arg[i] == '\'')
+					s[len s] = '\'';
+				s[len s] = arg[i];
+			}
+			s[len s] = '\'';
+		} else
+			s += arg;
+		if (tl argv != nil)
+			s[len s] = ' ';
+		argv = tl argv;
+	}
+	return s;
+}
+
+in(c: int, s: string): int
+{
+	n := len s;
+	if(n == 0)
+		return 0;
+	ans := 0;
+	negate := 0;
+	if(s[0] == '^') {
+		negate = 1;
+		s = s[1:];
+		n--;
+	}
+	for(i := 0; i < n; i++) {
+		if(s[i] == '-' && i > 0 && i < n-1)  {
+			if(c >= s[i-1] && c <= s[i+1]) {
+				ans = 1;
+				break;
+			}
+			i++;
+		}
+		else
+		if(c == s[i]) {
+			ans = 1;
+			break;
+		}
+	}
+	if(negate)
+		ans = !ans;
+
+	# just to showcase labels
+skip:
+	return ans;
+}
+
+bglong(d: array of byte, i: int): int
+{
+	return int d[i] | (int d[i+1]<<8) | (int d[i+2]<<16) | (int d[i+3]<<24);
+}