es.h

/* es.h -- definitions for higher order shell ($Revision: 1.2 $) */

#ifndef __es_h
#define __es_h

#include "stdenv.h"

#define nil ((void *)0)
#define nelem(obj) (sizeof(obj) / sizeof((obj)[0]))

#define dprint(args...)                    \
	do {                                   \
		if(editor_debugfd > 0)             \
			dprintf(editor_debugfd, args); \
	} while(0)

/*
 * meta-information for exported environment strings
 */

#define ENV_SEPARATOR '\017' /* control-O */
#define ENV_ESCAPE '\016'	 /* control-N */

/* runflags */

enum {
	eval_inchild = (1 << 0),
	eval_exitonfalse = (1 << 1), /* e */
	eval_flags = (eval_inchild | eval_exitonfalse),

	/* basic runflags */
	run_interactive = (1 << 2), /* i or $0[0] = '-' */
	run_noexec = (1 << 3),		/* n */
	run_echoinput = (1 << 4),	/* v */
	run_printcmds = (1 << 5),	/* x */
	run_lisptrees = (1 << 6),	/* L */

	/* sandboxing flags */
	run_noforkexec = (1 << 7),	  /* X */
	run_noreadfile = (1 << 8),	  /* R */
	run_nowritefile = (1 << 9),	  /* W */
	run_nochdir = (1 << 10),	  /* C */
	run_fatalflagset = (1 << 11), /* F */

	run_sandbox =
		(run_noforkexec | run_noreadfile | run_nowritefile | run_nochdir | run_fatalflagset),
};

/*
 * the fundamental es data structures.
 */

typedef struct Tree Tree;
typedef struct Term Term;
typedef struct List List;
typedef struct Binding Binding;
typedef struct Closure Closure;
typedef struct Assoc Assoc;
typedef struct Dict Dict;
typedef struct Var Var;
typedef struct RegexStatus RegexStatus;
typedef struct AppendContext AppendContext;
typedef struct Root Root;
typedef struct Object Object;
typedef struct Buffer Buffer;
typedef struct SplitCtx SplitCtx;

typedef enum {
	tkBad = 0,
	tkString = 1,
	tkClosure = 2,
	tkDict = 3,
	tkRegex = 4,
	tkObject = 5,
} TermKind;

typedef enum {
	ttNone = 0,
	ttError = 1,
	ttBox = 2,
	ttRegex = 3,
} Termtag;

// clang-format off
typedef enum {
	HaahrHash,
	FNV1AHash,
	JenkinsOATHash
} HashFunction;
// clang-format on

struct Term {
	TermKind kind;
	Termtag tag;
	union {
		char *str;
		Closure *closure;
		Dict *dict;
		Object *obj;
		void *ptr;
	};
};

struct List {
	Term *term;
	List *next;
};

struct Binding {
	char *name;
	List *defn;
	Binding *next;
};

struct Closure {
	Binding *binding;
	Tree *tree;
};

/*
 * parse trees
 */

typedef enum {
	nAssign,
	nCall,
	nClosure,
	nConcat,
	nFor,
	nLambda,
	nLet,
	nList,
	nLocal,
	nLets,
	nMatch,
	nExtract,
	nPrim,
	nQword,
	nThunk,
	nVar,
	nVarsub,
	nWord,
	nRedir,
	nPipe,
	nAssoc,
	nDict,
	nRegex /* only appear during construction */
} NodeKind;

struct Tree {
	NodeKind kind;
	union {
		Tree *p;
		char *s;
		int i;
	} u[2];
};

struct Assoc {
	char *name;
	char *value;
};

struct Dict {
	int readonly;
	int size, remain;
	char *bloom;
	Assoc table[1];
};

/*
 * miscellaneous data structures
 */

typedef struct StrList StrList;
struct StrList {
	char *str;
	StrList *next;
};

typedef struct {
	int alloclen, count;
	char *vector[1];
} Vector; /* environment or arguments */

typedef struct WaitStatus WaitStatus;
struct WaitStatus {
	int pid;
	int status;
};

struct Var {
	List *defn;
	char *env;
	int flags;
};

struct Root {
	void **p;
	Root *next;
	Root *prev;
};

struct AppendContext {
	int started;
	List *result; Root r_result;
	List *rlp; Root r_rlp;
};

/* regexes */

typedef enum {
	ReNil,
	ReMatch,
	ReExtract,
} RegexType;

struct RegexStatus {
	RegexType type;
	Boolean matched;
	int matchcode;
	int compcode;
	List *substrs;
	size_t nsubstr;
	char *errstr;
	size_t errstrsz;
};

/* objects */

enum {
	ObjectFreeWhenNoRefs = 1 << 0,
	ObjectGcManaged = 1 << 1,
	ObjectInitialized = 1 << 2,
	ObjectCloseOnFork = 1 << 3,
	ObjectCallbackOnFork = 1 << 4,

	ObjectErrorTypeInUse = -1,

	ObjectifyOk = 0,
	ObjectifyUnknownError = -127,
	ObjectifyInvalidObjectFormat = -1,
	ObjectifyInvalidType = -2,
	ObjectifyInvalidFormat = -3,
	ObjectifySyntaxError = -4,
};

struct Object {
	int32_t type;	   /* index of typedef */
	int32_t id;		   /* index in object array */
	uint16_t sysflags; /* system flags if needed */
	uint16_t flags;	   /* user flags if needed */
	size_t size;	   /* object payload size */
	int64_t refcount;
	void *data;
};

/* keymapping */

typedef enum {
	FnInvalid,
	FnEsFunction,
	FnEndInput,
	FnPassKey,
	FnBreak,
	FnDelete,
	FnDeleteOrEOF,
	FnEOF,
	FnBackspace,
	FnNextCompletion,
	FnPrevCompletion,
	FnCursorHome,
	FnCursorEnd,
	FnDeleteWord,
	FnDeleteToStart,
	FnDeleteToEnd,
	FnClearScreen,
	FnNextHistory,
	FnPrevHistory,
	FnCursorLeft,
	FnCursorRight,
	FnCursorWordLeft,
	FnCursorWordRight,
	FnJumpToParen,
	FnCancelCompletion,
} EditorFunction;

#define LastEditorFn FnCancelCompletion

typedef struct {
	char *name;
	Mapping map;
} EditorFnDef;

/* some gc stuff that needed moving */

struct Buffer {
	size_t len;
	size_t current;
	char str[1];
};

/* fsplit and friends */

struct SplitCtx {
	Boolean initialized;
	Boolean coalesce;
	Boolean splitchars;
	Buffer *buffer;
	List *value;
	Root r_value;
	Boolean ifsvalid;
	char ifs[10];
	char isifs[256];
};

/*
 * our programming environment
 */

/* main.c */

extern Boolean gcverbose;  /* -G */
extern Boolean gcinfo;	   /* -I */
extern Boolean assertions; /* -A */

/* initial.c (for es) or dump.c (for esdump) */

extern void runinitial(void);

/* fd.c */

extern void mvfd(int old, int new);
extern int newfd(void);

#define UNREGISTERED (-999)
extern void registerfd(int *fdp, Boolean closeonfork);
extern void unregisterfd(int *fdp);
extern void releasefd(int fd);
extern void closefds(void);

extern int fdmap(int fd);
extern int defer_mvfd(Boolean parent, int old, int new);
extern int defer_close(Boolean parent, int fd);
extern void undefer(int ticket);

/* term.c */

extern Term *mkterm(char *str, Closure *closure);
extern Term *mkstr(char *str);
extern Term *mkobject(Object *obj);
extern Term *mkdictterm(Dict *d);
extern char *getregex(Term *term);
extern char *getstr(Term *term);
extern Closure *getclosure(Term *term);
extern Dict *getdict(Term *term);
extern Object *getobject(Term *term);
extern Term *termcat(Term *t1, Term *t2);
extern Boolean termeq(Term *term, const char *s);
extern Boolean isclosure(Term *term);
extern Boolean isdict(Term *term);

/* list.c */

extern List *mklist(Term *term, List *next);
extern List *reverse(List *list);
extern void append_start(AppendContext *ctx);
extern List *append_end(AppendContext *ctx);
extern int partial_append(AppendContext *ctx, List *list0);
extern List *append(List *head, List *tail);
extern List *listcopy(List *list);
extern int length(List *list);
extern List *listify(int argc, char **argv);
extern Term *nth(List *list, int n);
extern List *sortlist(List *list);

/* tree.c */

extern Tree *gcmk(NodeKind, ...);
extern Tree *mk(NodeKind, ...);
extern char *treekind(Tree *);

/* closure.c */

extern Closure *mkclosure(Tree *tree, Binding *binding);
extern Closure *extractbindings(Tree *tree);
extern Binding *mkbinding(char *name, List *defn, Binding *next);
extern Binding *reversebindings(Binding *binding);

/* eval.c */

extern Binding *bindargs(Tree *params, List *args, Binding *binding);
extern List *forkexec(char *file, List *list, int flags);
extern List *walk(Tree *tree, Binding *binding, int flags);
extern List *eval(List *list, Binding *binding, int flags);
extern List *eval1(Term *term, int flags);
extern List *pathsearch(Term *term);

extern unsigned long evaldepth, maxevaldepth;
#define MINmaxevaldepth 100
#define MAXmaxevaldepth 0xffffffffU

/* glom.c */

extern List *glom(Tree *tree, Binding *binding, int flags, Boolean globit);
extern List *glom1(Tree *tree, Binding *binding, int flags);
extern List *glom2(Tree *tree, Binding *binding, int flags, StrList **quotep);

/* glob.c */

extern char QUOTED[], UNQUOTED[];
extern List *glob(List *list, StrList *quote, Binding *binding);
extern Boolean haswild(const char *pattern, const char *quoting);

/* match.c */
extern Boolean match(const char *subject, const char *pattern, const char *quote);
extern Boolean listmatch(List *subject, List *pattern, StrList *quote);
extern List *extractmatches(List *subjects, List *patterns, StrList *quotes);
extern RegexStatus *regexmatch(RegexStatus *status, Term *subject0, Term *pattern0);
extern RegexStatus *regexextract(RegexStatus *status, Term *subject0, Term *pattern0);

/* var.c */

#define var_hasbindings 1
#define var_isinternal 2

extern Dict *vars;
extern void initvars(void);
extern void initenv(char **envp, Boolean protected);
extern void hidevariables(void);
extern void validatevar(const char *var);
extern List *varlookup(char *name, Binding *binding);
extern List *varlookup2(char *name1, char *name2, Binding *binding);
extern Var *varobjlookup(char *name);
extern void varhide(Var *v);
extern void varunhide(Var *v);
extern Boolean varishidden(Var *v);
extern void vardef(char *, Binding *, List *);
extern Vector *mkenv(void);
extern void setnoexport(List *list);
extern void addtolist(void *arg, char *key, void *value);
extern List *listvars(Boolean internal);

typedef struct Push Push;
extern Push *pushlist;
extern void varpush(Push *, char *, List *);
extern void varpop(Push *);

/* status.c */

extern List *list_true, *list_false;
extern Boolean istrue(List *status);
extern int exitstatus(List *status);
extern char *mkstatus(int status);
extern void printstatus(int pid, int status);

/* access.c */

extern char *checkexecutable(char *file);

/* proc.c */

extern Boolean hasforked;
extern int efork(Boolean parent, Boolean background);
extern WaitStatus ewait(int pid, Boolean interruptible, void *rusage);
extern int ewaitfor(int pid);
/* #define	ewaitfor(pid)	ewait(pid, FALSE, NULL) */

/* dict.c */

extern HashFunction hashfunction;
extern uint64_t strhash2(const char *, const char *);
extern uint64_t strhash(const char *);
extern Dict *mkdict(void);
extern void dictforall(Dict *dict, void (*proc)(void *, char *, void *), void *arg);
extern void *dictget(Dict *dict, const char *name);
extern Dict *dictput(Dict *dict, char *name, void *value);
extern void *dictget2(Dict *dict, const char *name1, const char *name2);
extern Dict *dictcopy(Dict *oda);
extern Dict *dictappend(Dict *dest, Dict *src, Boolean overwrite);
extern Dict *parsedict(Tree *tree0, Binding *binding0, int flags);

/* conv.c */

extern void initconv(void);

/* print.c -- see print.h for more */

extern int print(const char *fmt, ...);
extern int eprint(const char *fmt, ...);
extern int fprint(int fd, const char *fmt, ...);
extern noreturn panic(const char *fmt, ...) __attribute__((noreturn));

/* str.c */

extern char *str(const char *fmt, ...);	   /* create a gc space string by printing */
extern char *astr(const char *fmt, ...);   /* same as above but in the parser arena */
extern char *mprint(const char *fmt, ...); /* create an ealloc space string by printing */
extern StrList *mkstrlist(char *, StrList *);

/* vec.c */

extern Vector *mkvector(int n);
extern Vector *vectorize(List *list);
extern void sortvector(Vector *v);

/* util.c */

extern void *used(void *);
extern void noop(void);
extern void esabort(void) __attribute__((noreturn));
extern char *esstrerror(int err);
extern void uerror(char *msg);
extern void *ealloc(size_t n);
extern void *erealloc(void *p, size_t n);
extern char *estrdup(char *str);
extern char *estrndup(char *str, size_t len);
extern void efree(void *p);
extern void ewrite(int fd, const char *s, size_t n);
extern long eread(int fd, char *buf, size_t n);
extern Boolean isabsolute(char *path);
extern Boolean streq2(const char *s, const char *t1, const char *t2);
extern void esexit(int status) __attribute__((noreturn));
extern int eisatty(int fd);
extern int status(Result r);
extern void *ok(Result r);
extern int64_t ok_int(Result r);
extern double ok_float(Result r);
extern char *ok_str(Result r);
extern Result result(void *ptr, int status);
extern Result sresult(void *ptr, char *errstr);
extern Result result_int(int64_t i, int status);
extern Result result_float(double f, int status);
extern Result result_str(char *str, int status);

/* input.c */

extern char *lastcmd;
extern int editor_debugfd;
extern int prompt;
extern char *prompt1, *prompt2;
extern Boolean resetterminal;
extern EditorState *editor;
extern void setnextlastcmd(char *str);
extern char *getnextlastcmd(void);
extern Tree *parse(char *esprompt1, char *esprompt2);
extern Tree *parsestring(const char *str);
extern Boolean isinteractive(void);
extern int getrunflags(char *, size_t);
extern int setrunflags(char *, size_t);
extern void initinput(void);
extern void resetparser(void);
extern List *runfd(int fd, const char *name, int flags);
extern List *runstring(const char *str, const char *name, int flags);
extern int bind_es_function(char *keyname, char *function);
extern int unbind_es_function(char *keyname);
extern int map_as_key(char *keyname, char *srckeyname);
extern int clear_key_mapping(char *keyname);
extern void exit_rawmode(void);
extern EditorFunction name2edfn(char *name);
extern char *edfn2name(EditorFunction edfn);
extern Mapping edfn2mapping(EditorFunction edfn);
extern EditorFunction mapping2edfn(Mapping map);
extern char *mapping2name(Mapping map);
extern Mapping name2mapping(char *name);
extern int bind_base_function(char *keyname, char *function);
extern int configure_word_start(char *str);
extern char *get_word_start(void);

/* opt.c */

extern void esoptbegin(List *list, const char *caller, const char *usage);
extern int esopt(const char *options);
extern Term *esoptarg(void);
extern List *esoptend(void);

/* prim.c */

extern List *prim(char *s, List *list, Binding *binding, int evalflags);
extern void initprims(void);

/* split.c */

typedef struct SplitCtx SplitCtx;

extern void initsplitctx(SplitCtx *ctx);
extern void startsplit(SplitCtx *ctx, const char *sep, Boolean coalesce);
extern void splitstring(SplitCtx *ctx, char *in, size_t len, Boolean endword);
extern List *endsplit(SplitCtx *ctx);
extern List *fsplit(const char *sep, List *list, Boolean coalesce);

/* signal.c */

extern int signumber(const char *name);
extern char *signame(int sig);
extern char *sigmessage(int sig);

typedef enum {
	sig_nochange,
	sig_catch,
	sig_default,
	sig_ignore,
	sig_noop,
	sig_special,
} Sigeffect;

extern Sigeffect esignal(int sig, Sigeffect effect);
extern void setsigeffects(const Sigeffect effects[]);
extern void getsigeffects(Sigeffect effects[]);
extern List *mksiglist(void);
extern void initsignals(Boolean interactive, Boolean allowdumps);
extern Atomic slow, interrupted;
extern jmp_buf slowlabel;
extern Boolean sigint_newline;
extern void sigchk(void);
extern Boolean issilentsignal(List *e);
extern void setsigdefaults(void);
extern void blocksignals(void);
extern void unblocksignals(void);

/* open.c */

typedef enum {
	oOpen = 0,
	oCreate = 1,
	oAppend = 2,
	oReadWrite = 3,
	oReadCreate = 4,
	oReadAppend = 5,
	ceOpen = 6,
	ceCreate = 7,
	ceAppend = 8,
	ceReadWrite = 9,
	ceReadCreate = 10,
	ceReadAppend = 11,
} OpenKind;

extern int eopen(char *name, OpenKind k);

/* version.c */

extern const char *const version;
extern const char *const buildstring;

/* objects.c */

extern void init_typedefs(void);
extern void init_objects(void);

extern char *gettypename(int32_t index);
extern int define_type(char *name, int (*deallocate)(Object *), int (*refdeps)(Object *));
extern int define_stringifier(char *name, char *(*stringify)(Object *));
extern int define_objectifier(char *name, Result (*objectify)(char *));
extern int define_onfork_callback(char *name, int (*onfork)(Object *));
extern int define_allocator(char *name, Object *(*allocator)(void));
extern int define_deallocator(char *name, void (*deallocator)(Object *));
extern int undefine_type(char *name);
extern Object *allocate_object(char *type, size_t size);
extern void deallocate_object(Object *obj);
extern void assert_type(Object *obj, char *name);
extern int object_is_type(Object *obj, char *name);
extern char *stringify(Object *obj);
extern Result result_obj(Object *obj, int status);
extern Object *ok_obj(Result r);
extern Result objectify(char *type, char *str);
extern Object *newobject(char *);

/* gc api */
extern void refobject(Object *obj);
extern void derefobject(Object *obj);
extern void gcmanageobj(Object *obj);
extern void gcunmanageobj(Object *obj);
extern int64_t object_refs(Object *obj);
extern void derefallobjects(void);
extern void dealloc_unrefed_objects(void);
extern void deallocate_all_objects(void);
extern void all_objects_onfork_ops(void);

/* gc.c, ms_gc.c, gc_common.c -- see gc.h for more */

enum {
	tNil,
	tClosure,
	tBinding,
	tDict,
	tString,
	tList,
	tStrList,
	tTerm,
	tTree1,
	tTree2,
	tVar,
	tVector,
	tAnonymous,
};

typedef struct Tag Tag;
#define gcnew(type) ((type *)gcalloc(sizeof(type), (CONCAT(t, type))))

extern void *gcalloc(size_t n, int t);		  /* allocate n with collection tag t */
extern char *gcdup(const char *s);			  /* copy a 0-terminated string into gc space */
extern char *gcndup(const char *s, size_t n); /* copy a counted string into gc space */
extern void *gcmalloc(size_t sz);			  /* garbage collected malloc */
/* these are same as the above but work with the parser arena */
extern void *aalloc(size_t sz, int tag);
extern char *andup(const char *str, size_t n);
extern char *adup(const char *str);

extern void initgc(void);			  /* must be called at the dawn of time */
extern void gc(void);				  /* provoke a collection, if enabled */
extern void gcreserve(size_t nbytes); /* provoke a collection, if enabled and not enough space */
extern void gcenable(void);			  /* enable collections */
extern void gcdisable(void);		  /* disable collections */
extern Boolean gcisblocked();		  /* is collection disabled? */

/*
 * garbage collector tags
 */

extern Root *rootlist;

#define Ref(t, v, init) \
	if(0)               \
		;               \
	else {              \
		t v = init; \
		Root (CONCAT(v,__root__));   \
		gcref(&(CONCAT(v, __root__)), (void **)&v);
#define RefPop(v) gcderef(&(CONCAT(v, __root__)), (void **)&v);
#define RefEnd(v) \
	RefPop(v);    \
	}
#define RefReturn(v) \
	RefPop(v);       \
	return v;        \
	}

#define RefAdd(e) \
	if(0)         \
		;         \
	else { \
		Root __root__;      \
		gcref(&__root__, (void **)&e);
#define RefRemove(e)                 \
	gcderef(&__root__, (void **)&e); \
	}

#define RefEnd2(v1, v2) \
	RefEnd(v1);         \
	RefEnd(v2)
#define RefEnd3(v1, v2, v3) \
	RefEnd(v1);             \
	RefEnd2(v2, v3)
#define RefEnd4(v1, v2, v3, v4) \
	RefEnd(v1);                 \
	RefEnd3(v2, v3, v4)

#define RefPop2(v1, v2) \
	RefPop(v1);         \
	RefPop(v2)
#define RefPop3(v1, v2, v3) \
	RefPop(v1);             \
	RefPop2(v2, v3)
#define RefPop4(v1, v2, v3, v4) \
	RefPop(v1);                 \
	RefPop3(v2, v3, v4)

#define RefAdd2(v1, v2) \
	RefAdd(v1);         \
	RefAdd(v2)
#define RefAdd3(v1, v2, v3) \
	RefAdd(v1);             \
	RefAdd2(v2, v3)
#define RefAdd4(v1, v2, v3, v4) \
	RefAdd(v1);                 \
	RefAdd3(v2, v3, v4)

#define RefRemove2(v1, v2) \
	RefRemove(v1);         \
	RefRemove(v2)
#define RefRemove3(v1, v2, v3) \
	RefRemove(v1);             \
	RefRemove2(v2, v3)
#define RefRemove4(v1, v2, v3, v4) \
	RefRemove(v1);                 \
	RefRemove3(v2, v3, v4)

extern void gcref(Root*, void**);
extern void gcderef(Root*, void**);
extern void gcrderef(Root*);
extern int64_t incref(void *);
extern int64_t decref(void *);
/* extern void derefmany(Root*); */
extern void globalroot(void *addr);
extern void exceptionroot(Root*, List**);
extern void exceptionunroot(void);

/* struct Push -- varpush() placeholder */

struct Push {
	Push *next;
	char *name;
	List *defn;
	int flags;
	Root nameroot, defnroot;
};

/*
 * exception handling
 *
 *	ExceptionHandler
 *		... body ...
 *	CatchException (e)
 *		... catching code using e ...
 *	EndExceptionHandler
 *
 */

extern Boolean debug_exceptions;

typedef struct Handler Handler;
struct Handler {
	Handler *up;
	Root *rootlist;
	Push *pushlist;
	unsigned long evaldepth;
	jmp_buf label;
};

extern Handler *tophandler, *roothandler;
extern List *exception;
extern void pophandler(Handler *handler);
extern void throw(List *exc) __attribute__((noreturn));
extern void fail(const char *from, const char *name, ...) __attribute__((noreturn));
extern void newchildcatcher(void);
extern List *raised(List *e);

#define ExceptionHandler                \
	{                                        \
		Handler _localhandler;               \
		_localhandler.rootlist = rootlist;   \
		_localhandler.pushlist = pushlist;   \
		_localhandler.evaldepth = evaldepth; \
		_localhandler.up = tophandler;       \
		tophandler = &_localhandler;         \
		if(!setjmp(_localhandler.label)) {

#define CatchException(e)   \
	pophandler(&_localhandler);              \
	}                                        \
	else                                     \
	{                                        \
		List *e = raised(exception);

#define CatchExceptionIf(condition, e)         \
	if(condition)                            \
		pophandler(&_localhandler);          \
	}                                        \
	else                                     \
	{                                        \
		List *e = raised(exception);

#define EndExceptionHandler         \
	}                                        \
	}

#if __has_attribute(__fallthrough__)
#define fallthrough __attribute__((__fallthrough__))
#else
#define fallthrough \
	do {            \
	} while(0) /* fallthrough */
#endif

#ifndef unreachable
#define unreachable() STMT(assert(UNREACHABLE));
#endif

#endif