zig-pug 0.2.0

package/vendor/mujs/main.c

@@ -0,0 +1,396 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _MSC_VER
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+#include <errno.h>
+
+#include "mujs.h"
+
+static char *xoptarg; /* Global argument pointer. */
+static int xoptind = 0; /* Global argv index. */
+static int xgetopt(int argc, char *argv[], char *optstring)
+{
+	static char *scan = NULL; /* Private scan pointer. */
+
+	char c;
+	char *place;
+
+	xoptarg = NULL;
+
+	if (!scan || *scan == '\0') {
+		if (xoptind == 0)
+			xoptind++;
+
+		if (xoptind >= argc || argv[xoptind][0] != '-' || argv[xoptind][1] == '\0')
+			return EOF;
+		if (argv[xoptind][1] == '-' && argv[xoptind][2] == '\0') {
+			xoptind++;
+			return EOF;
+		}
+
+		scan = argv[xoptind]+1;
+		xoptind++;
+	}
+
+	c = *scan++;
+	place = strchr(optstring, c);
+
+	if (!place || c == ':') {
+		fprintf(stderr, "%s: unknown option -%c\n", argv[0], c);
+		return '?';
+	}
+
+	place++;
+	if (*place == ':') {
+		if (*scan != '\0') {
+			xoptarg = scan;
+			scan = NULL;
+		} else if (xoptind < argc) {
+			xoptarg = argv[xoptind];
+			xoptind++;
+		} else {
+			fprintf(stderr, "%s: option requires argument -%c\n", argv[0], c);
+			return ':';
+		}
+	}
+
+	return c;
+}
+
+#ifdef HAVE_READLINE
+#include <readline/readline.h>
+#include <readline/history.h>
+#else
+void using_history(void) { }
+void add_history(const char *string) { }
+void rl_bind_key(int key, void (*fun)(void)) { }
+void rl_insert(void) { }
+char *readline(const char *prompt)
+{
+	static char line[500], *p;
+	int n;
+	fputs(prompt, stdout);
+	p = fgets(line, sizeof line, stdin);
+	if (p) {
+		n = strlen(line);
+		if (n > 0 && line[n-1] == '\n')
+			line[--n] = 0;
+		p = malloc(n+1);
+		memcpy(p, line, n+1);
+		return p;
+	}
+	return NULL;
+}
+#endif
+
+#define PS1 "> "
+
+static void jsB_gc(js_State *J)
+{
+	int report = js_toboolean(J, 1);
+	js_gc(J, report);
+	js_pushundefined(J);
+}
+
+static void jsB_load(js_State *J)
+{
+	int i, n = js_gettop(J);
+	for (i = 1; i < n; ++i) {
+		js_loadfile(J, js_tostring(J, i));
+		js_pushundefined(J);
+		js_call(J, 0);
+		js_pop(J, 1);
+	}
+	js_pushundefined(J);
+}
+
+static void jsB_compile(js_State *J)
+{
+	const char *source = js_tostring(J, 1);
+	const char *filename = js_isdefined(J, 2) ? js_tostring(J, 2) : "[string]";
+	js_loadstring(J, filename, source);
+}
+
+static void jsB_print(js_State *J)
+{
+	int i, top = js_gettop(J);
+	for (i = 1; i < top; ++i) {
+		const char *s = js_tostring(J, i);
+		if (i > 1) putchar(' ');
+		fputs(s, stdout);
+	}
+	putchar('\n');
+	js_pushundefined(J);
+}
+
+static void jsB_write(js_State *J)
+{
+	int i, top = js_gettop(J);
+	for (i = 1; i < top; ++i) {
+		const char *s = js_tostring(J, i);
+		if (i > 1) putchar(' ');
+		fputs(s, stdout);
+	}
+	js_pushundefined(J);
+}
+
+static void jsB_read(js_State *J)
+{
+	const char *filename = js_tostring(J, 1);
+	FILE *f;
+	char *s;
+	int n, t;
+
+	f = fopen(filename, "rb");
+	if (!f) {
+		js_error(J, "cannot open file '%s': %s", filename, strerror(errno));
+	}
+
+	if (fseek(f, 0, SEEK_END) < 0) {
+		fclose(f);
+		js_error(J, "cannot seek in file '%s': %s", filename, strerror(errno));
+	}
+
+	n = ftell(f);
+	if (n < 0) {
+		fclose(f);
+		js_error(J, "cannot tell in file '%s': %s", filename, strerror(errno));
+	}
+
+	if (fseek(f, 0, SEEK_SET) < 0) {
+		fclose(f);
+		js_error(J, "cannot seek in file '%s': %s", filename, strerror(errno));
+	}
+
+	s = malloc(n + 1);
+	if (!s) {
+		fclose(f);
+		js_error(J, "out of memory");
+	}
+
+	t = fread(s, 1, n, f);
+	if (t != n) {
+		free(s);
+		fclose(f);
+		js_error(J, "cannot read data from file '%s': %s", filename, strerror(errno));
+	}
+	s[n] = 0;
+
+	js_pushstring(J, s);
+	free(s);
+	fclose(f);
+}
+
+static void jsB_readline(js_State *J)
+{
+	char *line = readline("");
+	if (!line) {
+		js_pushnull(J);
+		return;
+	}
+	js_pushstring(J, line);
+	if (*line)
+		add_history(line);
+	free(line);
+}
+
+static void jsB_quit(js_State *J)
+{
+	exit(js_tonumber(J, 1));
+}
+
+static void jsB_repr(js_State *J)
+{
+	js_repr(J, 1);
+}
+
+static const char *require_js =
+	"function require(name) {\n"
+	"var cache = require.cache;\n"
+	"if (name in cache) return cache[name];\n"
+	"var exports = {};\n"
+	"cache[name] = exports;\n"
+	"Function('exports', read(name+'.js'))(exports);\n"
+	"return exports;\n"
+	"}\n"
+	"require.cache = Object.create(null);\n"
+;
+
+
+static const char *stacktrace_js =
+	"Error.prototype.toString = function() { return this.stack }\n"
+;
+
+static const char *console_js =
+	"var console = { log: print, debug: print, warn: print, error: print };"
+;
+
+static int eval_print(js_State *J, const char *source)
+{
+	if (js_ploadstring(J, "[stdin]", source)) {
+		fprintf(stderr, "%s\n", js_trystring(J, -1, "Error"));
+		js_pop(J, 1);
+		return 1;
+	}
+	js_pushundefined(J);
+	if (js_pcall(J, 0)) {
+		fprintf(stderr, "%s\n", js_trystring(J, -1, "Error"));
+		js_pop(J, 1);
+		return 1;
+	}
+	if (js_isdefined(J, -1)) {
+		printf("%s\n", js_tryrepr(J, -1, "can't convert to string"));
+	}
+	js_pop(J, 1);
+	return 0;
+}
+
+static char *read_stdin(void)
+{
+	int n = 0;
+	int t = 512;
+	char *s = NULL;
+
+	for (;;) {
+		char *ss = realloc(s, t);
+		if (!ss) {
+			free(s);
+			fprintf(stderr, "cannot allocate storage for stdin contents\n");
+			return NULL;
+		}
+		s = ss;
+		n += fread(s + n, 1, t - n - 1, stdin);
+		if (n < t - 1)
+			break;
+		t *= 2;
+	}
+
+	if (ferror(stdin)) {
+		free(s);
+		fprintf(stderr, "error reading stdin\n");
+		return NULL;
+	}
+
+	s[n] = 0;
+	return s;
+}
+
+static void usage(void)
+{
+	fprintf(stderr, "Usage: mujs [options] [script [scriptArgs*]]\n");
+	fprintf(stderr, "\t-i: Enter interactive prompt after running code.\n");
+	fprintf(stderr, "\t-s: Check strictness.\n");
+	exit(1);
+}
+
+int
+main(int argc, char **argv)
+{
+	char *input;
+	js_State *J;
+	int status = 0;
+	int strict = 0;
+	int interactive = 0;
+	int runlimit = 0;
+	int memlimit = 0;
+	int i, c;
+
+	while ((c = xgetopt(argc, argv, "isR:M:")) != -1) {
+		switch (c) {
+		default: usage(); break;
+		case 'i': interactive = 1; break;
+		case 's': strict = 1; break;
+		case 'R': runlimit = atoi(xoptarg); break;
+		case 'M': memlimit = atoi(xoptarg); break;
+		}
+	}
+
+	J = js_newstate(NULL, NULL, strict ? JS_STRICT : 0);
+	if (!J) {
+		fprintf(stderr, "Could not initialize MuJS.\n");
+		exit(1);
+	}
+
+	js_newcfunction(J, jsB_gc, "gc", 0);
+	js_setglobal(J, "gc");
+
+	js_newcfunction(J, jsB_load, "load", 1);
+	js_setglobal(J, "load");
+
+	js_newcfunction(J, jsB_compile, "compile", 2);
+	js_setglobal(J, "compile");
+
+	js_newcfunction(J, jsB_print, "print", 0);
+	js_setglobal(J, "print");
+
+	js_newcfunction(J, jsB_write, "write", 0);
+	js_setglobal(J, "write");
+
+	js_newcfunction(J, jsB_read, "read", 1);
+	js_setglobal(J, "read");
+
+	js_newcfunction(J, jsB_readline, "readline", 0);
+	js_setglobal(J, "readline");
+
+	js_newcfunction(J, jsB_repr, "repr", 0);
+	js_setglobal(J, "repr");
+
+	js_newcfunction(J, jsB_quit, "quit", 1);
+	js_setglobal(J, "quit");
+
+	js_dostring(J, require_js);
+	js_dostring(J, stacktrace_js);
+	js_dostring(J, console_js);
+
+	if (xoptind == argc) {
+		interactive = 1;
+	} else {
+		c = xoptind++;
+
+		js_newarray(J);
+		i = 0;
+		while (xoptind < argc) {
+			js_pushstring(J, argv[xoptind++]);
+			js_setindex(J, -2, i++);
+		}
+		js_setglobal(J, "scriptArgs");
+
+		js_setlimit(J, runlimit, memlimit);
+		if (js_dofile(J, argv[c]))
+			status = 1;
+	}
+
+	if (interactive) {
+		printf("Welcome to MuJS %d.%d.%d.\n",
+			JS_VERSION_MAJOR, JS_VERSION_MINOR, JS_VERSION_PATCH);
+		if (isatty(0)) {
+			using_history();
+			rl_bind_key('\t', rl_insert);
+			input = readline(PS1);
+			while (input) {
+				js_setlimit(J, runlimit, memlimit);
+				eval_print(J, input);
+				if (*input)
+					add_history(input);
+				free(input);
+				input = readline(PS1);
+			}
+			putchar('\n');
+		} else {
+			input = read_stdin();
+			js_setlimit(J, runlimit, memlimit);
+			if (!input || !js_dostring(J, input))
+				status = 1;
+			free(input);
+		}
+	}
+
+	js_gc(J, 0);
+	js_freestate(J);
+
+	return status;
+}

package/vendor/mujs/mujs.h

@@ -0,0 +1,253 @@
+#ifndef mujs_h
+#define mujs_h
+
+#include <setjmp.h> /* required for setjmp in fz_try macro */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define JS_VERSION_MAJOR 1
+#define JS_VERSION_MINOR 3
+#define JS_VERSION_PATCH 8
+
+#define JS_VERSION (JS_VERSION_MAJOR * 10000 + JS_VERSION_MINOR * 100 + JS_VERSION_PATCH)
+#define JS_CHECKVERSION(x,y,z) (JS_VERSION >= ((x) * 10000 + (y) * 100 + (z)))
+
+/* noreturn is a GCC extension */
+#ifdef __GNUC__
+#define JS_NORETURN __attribute__((noreturn))
+#else
+#ifdef _MSC_VER
+#define JS_NORETURN __declspec(noreturn)
+#else
+#define JS_NORETURN
+#endif
+#endif
+
+/* GCC can do type checking of printf strings */
+#ifdef __printflike
+#define JS_PRINTFLIKE __printflike
+#else
+#if __GNUC__ > 2 || __GNUC__ == 2 && __GNUC_MINOR__ >= 7
+#define JS_PRINTFLIKE(fmtarg, firstvararg) \
+	__attribute__((__format__ (__printf__, fmtarg, firstvararg)))
+#else
+#define JS_PRINTFLIKE(fmtarg, firstvararg)
+#endif
+#endif
+
+typedef struct js_State js_State;
+
+typedef void *(*js_Alloc)(void *memctx, void *ptr, int size);
+typedef void (*js_Panic)(js_State *J);
+typedef void (*js_CFunction)(js_State *J);
+typedef void (*js_Finalize)(js_State *J, void *p);
+typedef int (*js_HasProperty)(js_State *J, void *p, const char *name);
+typedef int (*js_Put)(js_State *J, void *p, const char *name);
+typedef int (*js_Delete)(js_State *J, void *p, const char *name);
+typedef void (*js_Report)(js_State *J, const char *message);
+
+/* Basic functions */
+js_State *js_newstate(js_Alloc alloc, void *actx, int flags);
+void js_setcontext(js_State *J, void *uctx);
+void *js_getcontext(js_State *J);
+void js_setreport(js_State *J, js_Report report);
+js_Panic js_atpanic(js_State *J, js_Panic panic);
+void js_freestate(js_State *J);
+void js_gc(js_State *J, int report);
+void js_setlimit(js_State *J, int runlimit, int memlimit);
+
+int js_dostring(js_State *J, const char *source);
+int js_dofile(js_State *J, const char *filename);
+int js_ploadstring(js_State *J, const char *filename, const char *source);
+int js_ploadfile(js_State *J, const char *filename);
+int js_pcall(js_State *J, int n);
+int js_pconstruct(js_State *J, int n);
+
+/* Exception handling */
+
+void *js_savetry(js_State *J); /* returns a jmp_buf */
+
+#define js_try(J) \
+	setjmp(js_savetry(J))
+
+void js_endtry(js_State *J);
+
+/* State constructor flags */
+enum {
+	JS_STRICT = 1,
+};
+
+/* RegExp flags */
+enum {
+	JS_REGEXP_G = 1,
+	JS_REGEXP_I = 2,
+	JS_REGEXP_M = 4,
+};
+
+/* Property attribute flags */
+enum {
+	JS_READONLY = 1,
+	JS_DONTENUM = 2,
+	JS_DONTCONF = 4,
+};
+
+/* enum for js_type() */
+enum {
+	JS_ISUNDEFINED,
+	JS_ISNULL,
+	JS_ISBOOLEAN,
+	JS_ISNUMBER,
+	JS_ISSTRING,
+	JS_ISFUNCTION,
+	JS_ISOBJECT
+};
+
+void js_report(js_State *J, const char *message);
+
+void js_newerror(js_State *J, const char *message);
+void js_newevalerror(js_State *J, const char *message);
+void js_newrangeerror(js_State *J, const char *message);
+void js_newreferenceerror(js_State *J, const char *message);
+void js_newsyntaxerror(js_State *J, const char *message);
+void js_newtypeerror(js_State *J, const char *message);
+void js_newurierror(js_State *J, const char *message);
+
+JS_NORETURN void js_error(js_State *J, const char *fmt, ...) JS_PRINTFLIKE(2,3);
+JS_NORETURN void js_evalerror(js_State *J, const char *fmt, ...) JS_PRINTFLIKE(2,3);
+JS_NORETURN void js_rangeerror(js_State *J, const char *fmt, ...) JS_PRINTFLIKE(2,3);
+JS_NORETURN void js_referenceerror(js_State *J, const char *fmt, ...) JS_PRINTFLIKE(2,3);
+JS_NORETURN void js_syntaxerror(js_State *J, const char *fmt, ...) JS_PRINTFLIKE(2,3);
+JS_NORETURN void js_typeerror(js_State *J, const char *fmt, ...) JS_PRINTFLIKE(2,3);
+JS_NORETURN void js_urierror(js_State *J, const char *fmt, ...) JS_PRINTFLIKE(2,3);
+JS_NORETURN void js_throw(js_State *J);
+
+void js_loadstring(js_State *J, const char *filename, const char *source);
+void js_loadfile(js_State *J, const char *filename);
+
+void js_eval(js_State *J);
+void js_call(js_State *J, int n);
+void js_construct(js_State *J, int n);
+
+const char *js_ref(js_State *J);
+void js_unref(js_State *J, const char *ref);
+
+void js_getregistry(js_State *J, const char *name);
+void js_setregistry(js_State *J, const char *name);
+void js_delregistry(js_State *J, const char *name);
+
+void js_getglobal(js_State *J, const char *name);
+void js_setglobal(js_State *J, const char *name);
+void js_defglobal(js_State *J, const char *name, int atts);
+void js_delglobal(js_State *J, const char *name);
+
+int js_hasproperty(js_State *J, int idx, const char *name);
+void js_getproperty(js_State *J, int idx, const char *name);
+void js_setproperty(js_State *J, int idx, const char *name);
+void js_defproperty(js_State *J, int idx, const char *name, int atts);
+void js_delproperty(js_State *J, int idx, const char *name);
+void js_defaccessor(js_State *J, int idx, const char *name, int atts);
+
+int js_getlength(js_State *J, int idx);
+void js_setlength(js_State *J, int idx, int len);
+int js_hasindex(js_State *J, int idx, int i);
+void js_getindex(js_State *J, int idx, int i);
+void js_setindex(js_State *J, int idx, int i);
+void js_delindex(js_State *J, int idx, int i);
+
+void js_currentfunction(js_State *J);
+void *js_currentfunctiondata(js_State *J);
+void js_pushglobal(js_State *J);
+void js_pushundefined(js_State *J);
+void js_pushnull(js_State *J);
+void js_pushboolean(js_State *J, int v);
+void js_pushnumber(js_State *J, double v);
+void js_pushstring(js_State *J, const char *v);
+void js_pushlstring(js_State *J, const char *v, int n);
+void js_pushliteral(js_State *J, const char *v);
+
+void js_newobjectx(js_State *J);
+void js_newobject(js_State *J);
+void js_newarray(js_State *J);
+void js_newboolean(js_State *J, int v);
+void js_newnumber(js_State *J, double v);
+void js_newstring(js_State *J, const char *v);
+void js_newcfunction(js_State *J, js_CFunction fun, const char *name, int length);
+void js_newcfunctionx(js_State *J, js_CFunction fun, const char *name, int length, void *data, js_Finalize finalize);
+void js_newcconstructor(js_State *J, js_CFunction fun, js_CFunction con, const char *name, int length);
+void js_newuserdata(js_State *J, const char *tag, void *data, js_Finalize finalize);
+void js_newuserdatax(js_State *J, const char *tag, void *data, js_HasProperty has, js_Put put, js_Delete del, js_Finalize finalize);
+void js_newregexp(js_State *J, const char *pattern, int flags);
+
+void js_pushiterator(js_State *J, int idx, int own);
+const char *js_nextiterator(js_State *J, int idx);
+
+int js_isdefined(js_State *J, int idx);
+int js_isundefined(js_State *J, int idx);
+int js_isnull(js_State *J, int idx);
+int js_isboolean(js_State *J, int idx);
+int js_isnumber(js_State *J, int idx);
+int js_isstring(js_State *J, int idx);
+int js_isprimitive(js_State *J, int idx);
+int js_isobject(js_State *J, int idx);
+int js_isarray(js_State *J, int idx);
+int js_isregexp(js_State *J, int idx);
+int js_iscoercible(js_State *J, int idx);
+int js_iscallable(js_State *J, int idx);
+int js_isuserdata(js_State *J, int idx, const char *tag);
+int js_iserror(js_State *J, int idx);
+int js_isnumberobject(js_State *J, int idx);
+int js_isstringobject(js_State *J, int idx);
+int js_isbooleanobject(js_State *J, int idx);
+int js_isdateobject(js_State *J, int idx);
+
+int js_toboolean(js_State *J, int idx);
+double js_tonumber(js_State *J, int idx);
+const char *js_tostring(js_State *J, int idx);
+void *js_touserdata(js_State *J, int idx, const char *tag);
+
+const char *js_trystring(js_State *J, int idx, const char *error);
+double js_trynumber(js_State *J, int idx, double error);
+int js_tryinteger(js_State *J, int idx, int error);
+int js_tryboolean(js_State *J, int idx, int error);
+
+int js_tointeger(js_State *J, int idx);
+int js_toint32(js_State *J, int idx);
+unsigned int js_touint32(js_State *J, int idx);
+short js_toint16(js_State *J, int idx);
+unsigned short js_touint16(js_State *J, int idx);
+
+int js_gettop(js_State *J);
+void js_pop(js_State *J, int n);
+void js_rot(js_State *J, int n);
+void js_copy(js_State *J, int idx);
+void js_remove(js_State *J, int idx);
+void js_insert(js_State *J, int idx);
+void js_replace(js_State* J, int idx);
+
+void js_dup(js_State *J);
+void js_dup2(js_State *J);
+void js_rot2(js_State *J);
+void js_rot3(js_State *J);
+void js_rot4(js_State *J);
+void js_rot2pop1(js_State *J);
+void js_rot3pop2(js_State *J);
+
+void js_concat(js_State *J);
+int js_compare(js_State *J, int *okay);
+int js_equal(js_State *J);
+int js_strictequal(js_State *J);
+int js_instanceof(js_State *J);
+const char *js_typeof(js_State *J, int idx);
+int js_type(js_State *J, int idx);
+
+void js_repr(js_State *J, int idx);
+const char *js_torepr(js_State *J, int idx);
+const char *js_tryrepr(js_State *J, int idx, const char *error);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/vendor/mujs/one.c

@@ -0,0 +1,25 @@
+#include "jsarray.c"
+#include "jsboolean.c"
+#include "jsbuiltin.c"
+#include "jscompile.c"
+#include "jsdate.c"
+#include "jsdtoa.c"
+#include "jserror.c"
+#include "jsfunction.c"
+#include "jsgc.c"
+#include "jsintern.c"
+#include "jslex.c"
+#include "jsmath.c"
+#include "jsnumber.c"
+#include "jsobject.c"
+#include "json.c"
+#include "jsparse.c"
+#include "jsproperty.c"
+#include "jsregexp.c"
+#include "jsrepr.c"
+#include "jsrun.c"
+#include "jsstate.c"
+#include "jsstring.c"
+#include "jsvalue.c"
+#include "regexp.c"
+#include "utf.c"