summaryrefslogtreecommitdiff
path: root/Src/zsh.h
diff options
context:
space:
mode:
Diffstat (limited to 'Src/zsh.h')
-rw-r--r--Src/zsh.h1293
1 files changed, 1293 insertions, 0 deletions
diff --git a/Src/zsh.h b/Src/zsh.h
new file mode 100644
index 000000000..e96fc6e86
--- /dev/null
+++ b/Src/zsh.h
@@ -0,0 +1,1293 @@
+/*
+ * zsh.h - standard header file
+ *
+ * This file is part of zsh, the Z shell.
+ *
+ * Copyright (c) 1992-1997 Paul Falstad
+ * All rights reserved.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and to distribute modified versions of this software for any
+ * purpose, provided that the above copyright notice and the following
+ * two paragraphs appear in all copies of this software.
+ *
+ * In no event shall Paul Falstad or the Zsh Development Group be liable
+ * to any party for direct, indirect, special, incidental, or consequential
+ * damages arising out of the use of this software and its documentation,
+ * even if Paul Falstad and the Zsh Development Group have been advised of
+ * the possibility of such damage.
+ *
+ * Paul Falstad and the Zsh Development Group specifically disclaim any
+ * warranties, including, but not limited to, the implied warranties of
+ * merchantability and fitness for a particular purpose. The software
+ * provided hereunder is on an "as is" basis, and Paul Falstad and the
+ * Zsh Development Group have no obligation to provide maintenance,
+ * support, updates, enhancements, or modifications.
+ *
+ */
+
+#define trashzle() trashzleptr()
+#define zleread(X,Y,H) zlereadptr(X,Y,H)
+#define spaceinline(X) spaceinlineptr(X)
+#define gotword() gotwordptr()
+#define refresh() refreshptr()
+
+#define compctlread(N,A,O,R) compctlreadptr(N,A,O,R)
+
+/* A few typical macros */
+#define minimum(a,b) ((a) < (b) ? (a) : (b))
+
+/* math.c */
+typedef int LV;
+
+/* Character tokens are sometimes casted to (unsigned char)'s. *
+ * Unfortunately, some compilers don't correctly cast signed to *
+ * unsigned promotions; i.e. (int)(unsigned char)((char) -1) evaluates *
+ * to -1, instead of 255 like it should. We circumvent the troubles *
+ * of such shameful delinquency by casting to a larger unsigned type *
+ * then back down to unsigned char. */
+
+#ifdef BROKEN_SIGNED_TO_UNSIGNED_CASTING
+# define STOUC(X) ((unsigned char)(unsigned short)(X))
+#else
+# define STOUC(X) ((unsigned char)(X))
+#endif
+
+/* Meta together with the character following Meta denotes the character *
+ * which is the exclusive or of 32 and the character following Meta. *
+ * This is used to represent characters which otherwise has special *
+ * meaning for zsh. These are the characters for which the imeta() test *
+ * is true: the null character, and the characters from Meta to Marker. */
+
+#define Meta ((char) 0x83)
+
+/* Note that the fourth character in DEFAULT_IFS is Meta *
+ * followed by a space which denotes the null character. */
+
+#define DEFAULT_IFS " \t\n\203 "
+
+/* Character tokens */
+#define Pound ((char) 0x84)
+#define String ((char) 0x85)
+#define Hat ((char) 0x86)
+#define Star ((char) 0x87)
+#define Inpar ((char) 0x88)
+#define Outpar ((char) 0x89)
+#define Qstring ((char) 0x8a)
+#define Equals ((char) 0x8b)
+#define Bar ((char) 0x8c)
+#define Inbrace ((char) 0x8d)
+#define Outbrace ((char) 0x8e)
+#define Inbrack ((char) 0x8f)
+#define Outbrack ((char) 0x90)
+#define Tick ((char) 0x91)
+#define Inang ((char) 0x92)
+#define Outang ((char) 0x93)
+#define Quest ((char) 0x94)
+#define Tilde ((char) 0x95)
+#define Qtick ((char) 0x96)
+#define Comma ((char) 0x97)
+#define Snull ((char) 0x98)
+#define Dnull ((char) 0x99)
+#define Bnull ((char) 0x9a)
+#define Nularg ((char) 0x9b)
+
+#define INULL(x) (((x) & 0xfc) == 0x98)
+
+/* Marker used in paramsubst for rc_expand_param */
+#define Marker ((char) 0x9c)
+
+/* chars that need to be quoted if meant literally */
+
+#define SPECCHARS "#$^*()=|{}[]`<>?~;&\n\t \\\'\""
+
+enum {
+ NULLTOK, /* 0 */
+ SEPER,
+ NEWLIN,
+ SEMI,
+ DSEMI,
+ AMPER, /* 5 */
+ INPAR,
+ OUTPAR,
+ DBAR,
+ DAMPER,
+ OUTANG, /* 10 */
+ OUTANGBANG,
+ DOUTANG,
+ DOUTANGBANG,
+ INANG,
+ INOUTANG, /* 15 */
+ DINANG,
+ DINANGDASH,
+ INANGAMP,
+ OUTANGAMP,
+ AMPOUTANG, /* 20 */
+ OUTANGAMPBANG,
+ DOUTANGAMP,
+ DOUTANGAMPBANG,
+ TRINANG,
+ BAR, /* 25 */
+ BARAMP,
+ INOUTPAR,
+ DINPAR,
+ DOUTPAR,
+ AMPERBANG, /* 30 */
+ SEMIAMP,
+ DOUTBRACK,
+ STRING,
+ ENVSTRING,
+ ENVARRAY, /* 35 */
+ ENDINPUT,
+ LEXERR,
+
+ /* Tokens for reserved words */
+ BANG, /* ! */
+ DINBRACK, /* [[ */
+ INBRACE, /* { */ /* 40 */
+ OUTBRACE, /* } */
+ CASE, /* case */
+ COPROC, /* coproc */
+ DO, /* do */
+ DONE, /* done */ /* 45 */
+ ELIF, /* elif */
+ ELSE, /* else */
+ ZEND, /* end */
+ ESAC, /* esac */
+ FI, /* fi */ /* 50 */
+ FOR, /* for */
+ FOREACH, /* foreach */
+ FUNC, /* function */
+ IF, /* if */
+ NOCORRECT, /* nocorrect */ /* 55 */
+ REPEAT, /* repeat */
+ SELECT, /* select */
+ THEN, /* then */
+ TIME, /* time */
+ UNTIL, /* until */ /* 60 */
+ WHILE /* while */
+};
+
+/* Redirection types. If you modify this, you may also have to modify *
+ * redirtab in parse.c and getredirs() in text.c and the IS_* macros *
+ * below. */
+
+enum {
+ WRITE, /* > */
+ WRITENOW, /* >| */
+ APP, /* >> */
+ APPNOW, /* >>| */
+ ERRWRITE, /* &>, >& */
+ ERRWRITENOW, /* >&| */
+ ERRAPP, /* >>& */
+ ERRAPPNOW, /* >>&| */
+ READWRITE, /* <> */
+ READ, /* < */
+ HEREDOC, /* << */
+ HEREDOCDASH, /* <<- */
+ HERESTR, /* <<< */
+ MERGEIN, /* <&n */
+ MERGEOUT, /* >&n */
+ CLOSE, /* >&-, <&- */
+ INPIPE, /* < <(...) */
+ OUTPIPE /* > >(...) */
+};
+
+#define IS_WRITE_FILE(X) ((X)>=WRITE && (X)<=READWRITE)
+#define IS_APPEND_REDIR(X) (IS_WRITE_FILE(X) && ((X) & 2))
+#define IS_CLOBBER_REDIR(X) (IS_WRITE_FILE(X) && ((X) & 1))
+#define IS_ERROR_REDIR(X) ((X)>=ERRWRITE && (X)<=ERRAPPNOW)
+#define IS_READFD(X) (((X)>=READWRITE && (X)<=MERGEIN) || (X)==INPIPE)
+#define IS_REDIROP(X) ((X)>=OUTANG && (X)<=TRINANG)
+
+/* Flags for input stack */
+#define INP_FREE (1<<0) /* current buffer can be free'd */
+#define INP_ALIAS (1<<1) /* expanding alias or history */
+#define INP_HIST (1<<2) /* expanding history */
+#define INP_CONT (1<<3) /* continue onto previously stacked input */
+#define INP_ALCONT (1<<4) /* stack is continued from alias expn. */
+
+/* Flags for metafy */
+#define META_REALLOC 0
+#define META_USEHEAP 1
+#define META_STATIC 2
+#define META_DUP 3
+#define META_ALLOC 4
+#define META_NOALLOC 5
+#define META_HEAPDUP 6
+#define META_HREALLOC 7
+
+
+/**************************/
+/* Abstract types for zsh */
+/**************************/
+
+typedef struct linknode *LinkNode;
+typedef struct linklist *LinkList;
+typedef struct hashnode *HashNode;
+typedef struct hashtable *HashTable;
+
+typedef struct reswd *Reswd;
+typedef struct alias *Alias;
+typedef struct param *Param;
+typedef struct cmdnam *Cmdnam;
+typedef struct shfunc *Shfunc;
+typedef struct builtin *Builtin;
+typedef struct nameddir *Nameddir;
+typedef struct module *Module;
+
+typedef struct process *Process;
+typedef struct job *Job;
+typedef struct value *Value;
+typedef struct varasg *Varasg;
+typedef struct cond *Cond;
+typedef struct cmd *Cmd;
+typedef struct pline *Pline;
+typedef struct sublist *Sublist;
+typedef struct list *List;
+typedef struct comp *Comp;
+typedef struct redir *Redir;
+typedef struct complist *Complist;
+typedef struct heap *Heap;
+typedef struct heapstack *Heapstack;
+typedef struct histent *Histent;
+typedef struct forcmd *Forcmd;
+typedef struct autofn *AutoFn;
+
+typedef struct asgment *Asgment;
+
+
+/********************************/
+/* Definitions for linked lists */
+/********************************/
+
+/* linked list abstract data type */
+
+struct linknode {
+ LinkNode next;
+ LinkNode last;
+ void *dat;
+};
+
+struct linklist {
+ LinkNode first;
+ LinkNode last;
+};
+
+/* Macros for manipulating link lists */
+
+#define addlinknode(X,Y) insertlinknode(X,(X)->last,Y)
+#define uaddlinknode(X,Y) uinsertlinknode(X,(X)->last,Y)
+#define empty(X) ((X)->first == NULL)
+#define nonempty(X) ((X)->first != NULL)
+#define firstnode(X) ((X)->first)
+#define getaddrdata(X) (&((X)->dat))
+#define getdata(X) ((X)->dat)
+#define setdata(X,Y) ((X)->dat = (Y))
+#define lastnode(X) ((X)->last)
+#define nextnode(X) ((X)->next)
+#define prevnode(X) ((X)->last)
+#define peekfirst(X) ((X)->first->dat)
+#define pushnode(X,Y) insertlinknode(X,(LinkNode) X,Y)
+#define incnode(X) (X = nextnode(X))
+#define gethistent(X) (histentarr+((X)%histentct))
+
+
+/********************************/
+/* Definitions for syntax trees */
+/********************************/
+
+/* struct list, struct sublist, struct pline, etc. all fit the form *
+ * of this structure and are used interchangably. The ptrs may hold *
+ * integers or pointers, depending on the type of the node. */
+
+/* Generic node structure for syntax trees */
+struct node {
+ int ntype; /* node type */
+};
+
+#define N_LIST 0
+#define N_SUBLIST 1
+#define N_PLINE 2
+#define N_CMD 3
+#define N_REDIR 4
+#define N_COND 5
+#define N_FOR 6
+#define N_CASE 7
+#define N_IF 8
+#define N_WHILE 9
+#define N_VARASG 10
+#define N_AUTOFN 11
+#define N_COUNT 12
+
+/* values for types[4] */
+
+#define NT_EMPTY 0
+#define NT_NODE 1
+#define NT_STR 2
+#define NT_LIST 4
+#define NT_ARR 8
+
+#define NT_TYPE(T) ((T) & 0xff)
+#define NT_N(T, N) (((T) >> (8 + (N) * 4)) & 0xf)
+#define NT_SET(T0, T1, T2, T3, T4) \
+ ((T0) | ((T1) << 8) | ((T2) << 12) | ((T3) << 16) | ((T4) << 20))
+#define NT_HEAP (1 << 30)
+
+/* tree element for lists */
+
+struct list {
+ int ntype; /* node type */
+ int type;
+ Sublist left;
+ List right;
+};
+
+/* These are control flags that are passed *
+ * down the execution pipeline. */
+#define Z_TIMED (1<<0) /* pipeline is being timed */
+#define Z_SYNC (1<<1) /* run this sublist synchronously (;) */
+#define Z_ASYNC (1<<2) /* run this sublist asynchronously (&) */
+#define Z_DISOWN (1<<3) /* run this sublist without job control (&|) */
+
+/* tree element for sublists */
+
+struct sublist {
+ int ntype; /* node type */
+ int type;
+ int flags; /* see PFLAGs below */
+ Pline left;
+ Sublist right;
+};
+
+#define ORNEXT 10 /* || */
+#define ANDNEXT 11 /* && */
+
+#define PFLAG_NOT 1 /* ! ... */
+#define PFLAG_COPROC 32 /* coproc ... */
+
+/* tree element for pipes */
+
+struct pline {
+ int ntype; /* node type */
+ int type;
+ Cmd left;
+ Pline right;
+};
+
+#define END 0 /* pnode *right is null */
+#define PIPE 1 /* pnode *right is the rest of the pipeline */
+
+/* tree element for commands */
+
+struct cmd {
+ int ntype; /* node type */
+ int type;
+ int flags; /* see CFLAGs below */
+ int lineno; /* lineno of script for command */
+ union {
+ List list; /* for SUBSH/CURSH/SHFUNC */
+ Forcmd forcmd;
+ struct casecmd *casecmd;
+ struct ifcmd *ifcmd;
+ struct whilecmd *whilecmd;
+ Sublist pline;
+ Cond cond;
+ AutoFn autofn;
+ void *generic;
+ } u;
+ LinkList args; /* command & argmument List (char *'s) */
+ LinkList redir; /* i/o redirections (struct redir *'s) */
+ LinkList vars; /* param assignments (struct varasg *'s) */
+};
+
+/* cmd types */
+#define SIMPLE 0
+#define SUBSH 1
+#define CURSH 2
+#define ZCTIME 3
+#define FUNCDEF 4
+#define CFOR 5
+#define CWHILE 6
+#define CREPEAT 7
+#define CIF 8
+#define CCASE 9
+#define CSELECT 10
+#define COND 11
+#define CARITH 12
+#define AUTOFN 13
+
+/* flags for command modifiers */
+#define CFLAG_EXEC (1<<0) /* exec ... */
+
+/* tree element for redirection lists */
+
+struct redir {
+ int ntype; /* node type */
+ int type;
+ int fd1, fd2;
+ char *name;
+};
+
+/* tree element for conditionals */
+
+struct cond {
+ int ntype; /* node type */
+ int type; /* can be cond_type, or a single */
+ /* letter (-a, -b, ...) */
+ void *left, *right;
+};
+
+#define COND_NOT 0
+#define COND_AND 1
+#define COND_OR 2
+#define COND_STREQ 3
+#define COND_STRNEQ 4
+#define COND_STRLT 5
+#define COND_STRGTR 6
+#define COND_NT 7
+#define COND_OT 8
+#define COND_EF 9
+#define COND_EQ 10
+#define COND_NE 11
+#define COND_LT 12
+#define COND_GT 13
+#define COND_LE 14
+#define COND_GE 15
+
+struct forcmd { /* for/select */
+/* Cmd->args contains list of words to loop thru */
+ int ntype; /* node type */
+ int inflag; /* if there is an in ... clause */
+ char *name; /* initializer or parameter name */
+ char *condition; /* arithmetic terminating condition */
+ char *advance; /* evaluated after each loop */
+ List list; /* list to look through for each name */
+};
+
+struct casecmd {
+/* Cmd->args contains word to test */
+ int ntype; /* node type */
+ char **pats;
+ List *lists; /* list to execute */
+};
+
+
+/* A command like "if foo then bar elif baz then fubar else fooble" */
+/* generates a tree like: */
+/* */
+/* struct ifcmd a = { next = &b, ifl = "foo", thenl = "bar" } */
+/* struct ifcmd b = { next = &c, ifl = "baz", thenl = "fubar" } */
+/* struct ifcmd c = { next = NULL, ifl = NULL, thenl = "fooble" } */
+
+struct ifcmd {
+ int ntype; /* node type */
+ List *ifls;
+ List *thenls;
+};
+
+struct whilecmd {
+ int ntype; /* node type */
+ int cond; /* 0 for while, 1 for until */
+ List cont; /* condition */
+ List loop; /* list to execute until condition met */
+};
+
+/* node for autoloading functions */
+
+struct autofn {
+ int ntype; /* node type */
+ Shfunc shf; /* the shell function to define */
+};
+
+/* The number of fds space is allocated for *
+ * each time a multio must increase in size. */
+#define MULTIOUNIT 8
+
+/* A multio is a list of fds associated with a certain fd. *
+ * Thus if you do "foo >bar >ble", the multio for fd 1 will have *
+ * two fds, the result of open("bar",...), and the result of *
+ * open("ble",....). */
+
+/* structure used for multiple i/o redirection */
+/* one for each fd open */
+
+struct multio {
+ int ct; /* # of redirections on this fd */
+ int rflag; /* 0 if open for reading, 1 if open for writing */
+ int pipe; /* fd of pipe if ct > 1 */
+ int fds[MULTIOUNIT]; /* list of src/dests redirected to/from this fd */
+};
+
+/* variable assignment tree element */
+
+struct varasg {
+ int ntype; /* node type */
+ int type; /* nonzero means array */
+ char *name;
+ char *str; /* should've been a union here. oh well */
+ LinkList arr;
+};
+
+/* lvalue for variable assignment/expansion */
+
+struct value {
+ int isarr;
+ Param pm; /* parameter node */
+ int inv; /* should we return the index ? */
+ int a; /* first element of array slice, or -1 */
+ int b; /* last element of array slice, or -1 */
+};
+
+/* structure for foo=bar assignments */
+
+struct asgment {
+ struct asgment *next;
+ char *name;
+ char *value;
+};
+
+#define MAX_ARRLEN 262144
+
+
+/********************************************/
+/* Defintions for job table and job control */
+/********************************************/
+
+/* size of job table */
+#define MAXJOB 50
+
+/* entry in the job table */
+
+struct job {
+ pid_t gleader; /* process group leader of this job */
+ pid_t other; /* subjob id or subshell pid */
+ int stat; /* see STATs below */
+ char *pwd; /* current working dir of shell when *
+ * this job was spawned */
+ struct process *procs; /* list of processes */
+ LinkList filelist; /* list of files to delete when done */
+ int stty_in_env; /* if STTY=... is present */
+ struct ttyinfo *ty; /* the modes specified by STTY */
+};
+
+#define STAT_CHANGED (1<<0) /* status changed and not reported */
+#define STAT_STOPPED (1<<1) /* all procs stopped or exited */
+#define STAT_TIMED (1<<2) /* job is being timed */
+#define STAT_DONE (1<<3) /* job is done */
+#define STAT_LOCKED (1<<4) /* shell is finished creating this job, */
+ /* may be deleted from job table */
+#define STAT_NOPRINT (1<<5) /* job was killed internally, */
+ /* we don't want to show that */
+#define STAT_INUSE (1<<6) /* this job entry is in use */
+#define STAT_SUPERJOB (1<<7) /* job has a subjob */
+#define STAT_SUBJOB (1<<8) /* job is a subjob */
+#define STAT_CURSH (1<<9) /* last command is in current shell */
+#define STAT_NOSTTY (1<<10) /* the tty settings are not inherited */
+ /* from this job when it exits. */
+
+#define SP_RUNNING -1 /* fake status for jobs currently running */
+
+struct timeinfo {
+ long ut; /* user space time */
+ long st; /* system space time */
+};
+
+#define JOBTEXTSIZE 80
+
+/* node in job process lists */
+
+struct process {
+ struct process *next;
+ pid_t pid; /* process id */
+ char text[JOBTEXTSIZE]; /* text to print when 'jobs' is run */
+ int status; /* return code from waitpid/wait3() */
+ struct timeinfo ti;
+ struct timeval bgtime; /* time job was spawned */
+ struct timeval endtime; /* time job exited */
+};
+
+struct execstack {
+ struct execstack *next;
+
+ LinkList args;
+ pid_t list_pipe_pid;
+ int nowait;
+ int pline_level;
+ int list_pipe_child;
+ int list_pipe_job;
+ char list_pipe_text[JOBTEXTSIZE];
+ int lastval;
+ int noeval;
+ int badcshglob;
+ pid_t cmdoutpid;
+ int cmdoutval;
+ int trapreturn;
+ int noerrs;
+ int subsh_close;
+ char *underscore;
+};
+
+struct heredocs {
+ struct heredocs *next;
+ Redir rd;
+};
+
+struct dirsav {
+ int dirfd, level;
+ char *dirname;
+ dev_t dev;
+ ino_t ino;
+};
+
+/*******************************/
+/* Definitions for Hash Tables */
+/*******************************/
+
+typedef void *(*VFunc) _((void *));
+typedef void (*FreeFunc) _((void *));
+
+typedef unsigned (*HashFunc) _((char *));
+typedef void (*TableFunc) _((HashTable));
+typedef void (*AddNodeFunc) _((HashTable, char *, void *));
+typedef HashNode (*GetNodeFunc) _((HashTable, char *));
+typedef HashNode (*RemoveNodeFunc) _((HashTable, char *));
+typedef void (*FreeNodeFunc) _((HashNode));
+
+/* type of function that is passed to *
+ * scanhashtable or scanmatchtable */
+typedef void (*ScanFunc) _((HashNode, int));
+
+typedef void (*PrintTableStats) _((HashTable));
+
+/* hash table for standard open hashing */
+
+struct hashtable {
+ /* HASHTABLE DATA */
+ int hsize; /* size of nodes[] (number of hash values) */
+ int ct; /* number of elements */
+ HashNode *nodes; /* array of size hsize */
+
+ /* HASHTABLE METHODS */
+ HashFunc hash; /* pointer to hash function for this table */
+ TableFunc emptytable; /* pointer to function to empty table */
+ TableFunc filltable; /* pointer to function to fill table */
+ AddNodeFunc addnode; /* pointer to function to add new node */
+ GetNodeFunc getnode; /* pointer to function to get an enabled node */
+ GetNodeFunc getnode2; /* pointer to function to get node */
+ /* (getnode2 will ignore DISABLED flag) */
+ RemoveNodeFunc removenode; /* pointer to function to delete a node */
+ ScanFunc disablenode; /* pointer to function to disable a node */
+ ScanFunc enablenode; /* pointer to function to enable a node */
+ FreeNodeFunc freenode; /* pointer to function to free a node */
+ ScanFunc printnode; /* pointer to function to print a node */
+
+#ifdef HASHTABLE_INTERNAL_MEMBERS
+ HASHTABLE_INTERNAL_MEMBERS /* internal use in hashtable.c */
+#endif
+};
+
+/* generic hash table node */
+
+struct hashnode {
+ HashNode next; /* next in hash chain */
+ char *nam; /* hash key */
+ int flags; /* various flags */
+};
+
+/* The flag to disable nodes in a hash table. Currently *
+ * you can disable builtins, shell functions, aliases and *
+ * reserved words. */
+#define DISABLED (1<<0)
+
+/* node in shell reserved word hash table (reswdtab) */
+
+struct reswd {
+ HashNode next; /* next in hash chain */
+ char *nam; /* name of reserved word */
+ int flags; /* flags */
+ int token; /* corresponding lexer token */
+};
+
+/* node in alias hash table (aliastab) */
+
+struct alias {
+ HashNode next; /* next in hash chain */
+ char *nam; /* hash data */
+ int flags; /* flags for alias types */
+ char *text; /* expansion of alias */
+ int inuse; /* alias is being expanded */
+};
+
+/* is this alias global */
+#define ALIAS_GLOBAL (1<<1)
+
+/* node in command path hash table (cmdnamtab) */
+
+struct cmdnam {
+ HashNode next; /* next in hash chain */
+ char *nam; /* hash data */
+ int flags;
+ union {
+ char **name; /* full pathname for external commands */
+ char *cmd; /* file name for hashed commands */
+ }
+ u;
+};
+
+/* flag for nodes explicitly added to *
+ * cmdnamtab with hash builtin */
+#define HASHED (1<<1)
+
+/* node in shell function hash table (shfunctab) */
+
+struct shfunc {
+ HashNode next; /* next in hash chain */
+ char *nam; /* name of shell function */
+ int flags; /* various flags */
+ List funcdef; /* function definition */
+};
+
+/* node in builtin command hash table (builtintab) */
+
+typedef int (*HandlerFunc) _((char *, char **, char *, int));
+#define NULLBINCMD ((HandlerFunc) 0)
+
+struct builtin {
+ HashNode next; /* next in hash chain */
+ char *nam; /* name of builtin */
+ int flags; /* various flags */
+ HandlerFunc handlerfunc; /* pointer to function that executes this builtin */
+ int minargs; /* minimum number of arguments */
+ int maxargs; /* maximum number of arguments, or -1 for no limit */
+ int funcid; /* xbins (see above) for overloaded handlerfuncs */
+ char *optstr; /* string of legal options */
+ char *defopts; /* options set by default for overloaded handlerfuncs */
+};
+
+#define BUILTIN(name, flags, handler, min, max, funcid, optstr, defopts) \
+ { NULL, name, flags, handler, min, max, funcid, optstr, defopts }
+#define BIN_PREFIX(name, flags) \
+ BUILTIN(name, flags | BINF_PREFIX, NULLBINCMD, 0, 0, 0, NULL, NULL)
+
+/* builtin flags */
+/* DISABLE IS DEFINED AS (1<<0) */
+#define BINF_PLUSOPTS (1<<1) /* +xyz legal */
+#define BINF_R (1<<2) /* this is the builtin `r' (fc -e -) */
+#define BINF_PRINTOPTS (1<<3)
+#define BINF_ADDED (1<<4) /* is in the builtins hash table */
+#define BINF_FCOPTS (1<<5)
+#define BINF_TYPEOPT (1<<6)
+#define BINF_ECHOPTS (1<<7)
+#define BINF_MAGICEQUALS (1<<8) /* needs automatic MAGIC_EQUAL_SUBST substitution */
+#define BINF_PREFIX (1<<9)
+#define BINF_DASH (1<<10)
+#define BINF_BUILTIN (1<<11)
+#define BINF_COMMAND (1<<12)
+#define BINF_EXEC (1<<13)
+#define BINF_NOGLOB (1<<14)
+#define BINF_PSPECIAL (1<<15)
+
+#define BINF_TYPEOPTS (BINF_TYPEOPT|BINF_PLUSOPTS)
+
+struct module {
+ char *nam;
+ int flags;
+ void *handle;
+ LinkList deps;
+};
+
+#define MOD_BUSY (1<<0)
+
+/* node used in parameter hash table (paramtab) */
+
+struct param {
+ HashNode next; /* next in hash chain */
+ char *nam; /* hash data */
+ int flags; /* PM_* flags */
+
+ /* the value of this parameter */
+ union {
+ void *data; /* used by special parameter functions */
+ char **arr; /* value if declared array (PM_ARRAY) */
+ char *str; /* value if declared string (PM_SCALAR) */
+ long val; /* value if declared integer (PM_INTEGER) */
+ } u;
+
+ /* pointer to function to set value of this parameter */
+ union {
+ void (*cfn) _((Param, char *));
+ void (*ifn) _((Param, long));
+ void (*afn) _((Param, char **));
+ } sets;
+
+ /* pointer to function to get value of this parameter */
+ union {
+ char *(*cfn) _((Param));
+ long (*ifn) _((Param));
+ char **(*afn) _((Param));
+ } gets;
+
+ /* pointer to function to unset this parameter */
+ void (*unsetfn) _((Param, int));
+
+ int ct; /* output base or field width */
+ char *env; /* location in environment, if exported */
+ char *ename; /* name of corresponding environment var */
+ Param old; /* old struct for use with local */
+ int level; /* if (old != NULL), level of localness */
+};
+
+/* flags for parameters */
+
+/* parameter types */
+#define PM_SCALAR 0 /* scalar */
+#define PM_ARRAY (1<<0) /* array */
+#define PM_INTEGER (1<<1) /* integer */
+
+#define PM_TYPE(X) (X & (PM_SCALAR|PM_INTEGER|PM_ARRAY))
+
+#define PM_LEFT (1<<2) /* left justify and remove leading blanks */
+#define PM_RIGHT_B (1<<3) /* right justify and fill with leading blanks */
+#define PM_RIGHT_Z (1<<4) /* right justify and fill with leading zeros */
+#define PM_LOWER (1<<5) /* all lower case */
+
+/* The following are the same since they *
+ * both represent -u option to typeset */
+#define PM_UPPER (1<<6) /* all upper case */
+#define PM_UNDEFINED (1<<6) /* undefined (autoloaded) shell function */
+
+#define PM_READONLY (1<<7) /* readonly */
+#define PM_TAGGED (1<<8) /* tagged */
+#define PM_EXPORTED (1<<9) /* exported */
+#define PM_UNIQUE (1<<10) /* remove duplicates */
+#define PM_SPECIAL (1<<11) /* special builtin parameter */
+#define PM_DONTIMPORT (1<<12) /* do not import this variable */
+#define PM_RESTRICTED (1<<13) /* cannot be changed in restricted mode */
+#define PM_UNSET (1<<14) /* has null value */
+
+/* node for named directory hash table (nameddirtab) */
+
+struct nameddir {
+ HashNode next; /* next in hash chain */
+ char *nam; /* directory name */
+ int flags; /* see below */
+ char *dir; /* the directory in full */
+ int diff; /* strlen(.dir) - strlen(.nam) */
+};
+
+/* flags for named directories */
+/* DISABLED is defined (1<<0) */
+#define ND_USERNAME (1<<1) /* nam is actually a username */
+
+
+/* flags for controlling printing of hash table nodes */
+#define PRINT_NAMEONLY (1<<0)
+#define PRINT_TYPE (1<<1)
+#define PRINT_LIST (1<<2)
+
+/* flags for printing for the whence builtin */
+#define PRINT_WHENCE_CSH (1<<3)
+#define PRINT_WHENCE_VERBOSE (1<<4)
+#define PRINT_WHENCE_SIMPLE (1<<5)
+#define PRINT_WHENCE_FUNCDEF (1<<6)
+#define PRINT_WHENCE_WORD (1<<7)
+
+/***********************************/
+/* Definitions for history control */
+/***********************************/
+
+/* history entry */
+
+struct histent {
+ char *text; /* the history line itself */
+ char *zle_text; /* the edited history line */
+ time_t stim; /* command started time (datestamp) */
+ time_t ftim; /* command finished time */
+ short *words; /* Position of words in history */
+ /* line: as pairs of start, end */
+ int nwords; /* Number of words in history line */
+ int flags; /* Misc flags */
+};
+
+#define HIST_OLD 0x00000001 /* Command is already written to disk*/
+#define HIST_READ 0x00000002 /* Command was read back from disk*/
+
+/* Parts of the code where history expansion is disabled *
+ * should be within a pair of STOPHIST ... ALLOWHIST */
+
+#define STOPHIST (stophist += 4);
+#define ALLOWHIST (stophist -= 4);
+
+#define HISTFLAG_DONE 1
+#define HISTFLAG_NOEXEC 2
+#define HISTFLAG_RECALL 4
+
+
+/******************************************/
+/* Definitions for programable completion */
+/******************************************/
+
+/* Nothing special. */
+#define IN_NOTHING 0
+/* In command position. */
+#define IN_CMD 1
+/* In a mathematical environment. */
+#define IN_MATH 2
+/* In a condition. */
+#define IN_COND 3
+/* In a parameter assignment (e.g. `foo=bar'). */
+#define IN_ENV 4
+
+
+/******************************/
+/* Definition for zsh options */
+/******************************/
+
+/* Possible values of emulation */
+
+#define EMULATE_CSH (1<<1) /* C shell */
+#define EMULATE_KSH (1<<2) /* Korn shell */
+#define EMULATE_SH (1<<3) /* Bourne shell */
+#define EMULATE_ZSH (1<<4) /* `native' mode */
+
+/* option indices */
+
+enum {
+ OPT_INVALID,
+ ALLEXPORT,
+ ALWAYSLASTPROMPT,
+ ALWAYSTOEND,
+ APPENDHISTORY,
+ AUTOCD,
+ AUTOLIST,
+ AUTOMENU,
+ AUTONAMEDIRS,
+ AUTOPARAMKEYS,
+ AUTOPARAMSLASH,
+ AUTOPUSHD,
+ AUTOREMOVESLASH,
+ AUTORESUME,
+ BADPATTERN,
+ BANGHIST,
+ BAREGLOBQUAL,
+ BEEP,
+ BGNICE,
+ BRACECCL,
+ BSDECHO,
+ CDABLEVARS,
+ CHASELINKS,
+ CLOBBER,
+ COMPLETEALIASES,
+ COMPLETEINWORD,
+ CORRECT,
+ CORRECTALL,
+ CSHJUNKIEHISTORY,
+ CSHJUNKIELOOPS,
+ CSHJUNKIEQUOTES,
+ CSHNULLGLOB,
+ EQUALS,
+ ERREXIT,
+ EXECOPT,
+ EXTENDEDGLOB,
+ EXTENDEDHISTORY,
+ FLOWCONTROL,
+ FUNCTIONARGZERO,
+ GLOBOPT,
+ GLOBASSIGN,
+ GLOBCOMPLETE,
+ GLOBDOTS,
+ GLOBSUBST,
+ HASHCMDS,
+ HASHDIRS,
+ HASHLISTALL,
+ HISTALLOWCLOBBER,
+ HISTBEEP,
+ HISTIGNOREDUPS,
+ HISTIGNORESPACE,
+ HISTNOFUNCTIONS,
+ HISTNOSTORE,
+ HISTREDUCEBLANKS,
+ HISTVERIFY,
+ HUP,
+ IGNOREBRACES,
+ IGNOREEOF,
+ INTERACTIVE,
+ INTERACTIVECOMMENTS,
+ KSHARRAYS,
+ KSHAUTOLOAD,
+ KSHGLOB,
+ KSHOPTIONPRINT,
+ LISTAMBIGUOUS,
+ LISTBEEP,
+ LISTTYPES,
+ LOCALOPTIONS,
+ LOGINSHELL,
+ LONGLISTJOBS,
+ MAGICEQUALSUBST,
+ MAILWARNING,
+ MARKDIRS,
+ MENUCOMPLETE,
+ MONITOR,
+ MULTIOS,
+ NOMATCH,
+ NOTIFY,
+ NULLGLOB,
+ NUMERICGLOBSORT,
+ OVERSTRIKE,
+ PATHDIRS,
+ POSIXBUILTINS,
+ PRINTEIGHTBIT,
+ PRINTEXITVALUE,
+ PRIVILEGED,
+ PROMPTBANG,
+ PROMPTCR,
+ PROMPTPERCENT,
+ PROMPTSUBST,
+ PUSHDIGNOREDUPS,
+ PUSHDMINUS,
+ PUSHDSILENT,
+ PUSHDTOHOME,
+ RCEXPANDPARAM,
+ RCQUOTES,
+ RCS,
+ RECEXACT,
+ RESTRICTED,
+ RMSTARSILENT,
+ RMSTARWAIT,
+ SHFILEEXPANSION,
+ SHGLOB,
+ SHINSTDIN,
+ SHOPTIONLETTERS,
+ SHORTLOOPS,
+ SHWORDSPLIT,
+ SINGLECOMMAND,
+ SINGLELINEZLE,
+ SUNKEYBOARDHACK,
+ UNSET,
+ VERBOSE,
+ XTRACE,
+ USEZLE,
+ OPT_SIZE
+};
+
+#undef isset
+#define isset(X) (opts[X])
+#define unset(X) (!opts[X])
+
+#define interact (isset(INTERACTIVE))
+#define jobbing (isset(MONITOR))
+#define islogin (isset(LOGINSHELL))
+
+/***********************************************/
+/* Defintions for terminal and display control */
+/***********************************************/
+
+/* tty state structure */
+
+struct ttyinfo {
+#ifdef HAVE_TERMIOS_H
+ struct termios tio;
+#else
+# ifdef HAVE_TERMIO_H
+ struct termio tio;
+# else
+ struct sgttyb sgttyb;
+ int lmodes;
+ struct tchars tchars;
+ struct ltchars ltchars;
+# endif
+#endif
+#ifdef TIOCGWINSZ
+ struct winsize winsize;
+#endif
+};
+
+/* defines for whether tabs expand to spaces */
+#if defined(HAVE_TERMIOS_H) || defined(HAVE_TERMIO_H)
+#define SGTTYFLAG shttyinfo.tio.c_oflag
+#else /* we're using sgtty */
+#define SGTTYFLAG shttyinfo.sgttyb.sg_flags
+#endif
+# ifdef TAB3
+#define SGTABTYPE TAB3
+# else
+# ifdef OXTABS
+#define SGTABTYPE OXTABS
+# else
+#define SGTABTYPE XTABS
+# endif
+# endif
+
+/* flags for termflags */
+
+#define TERM_BAD 0x01 /* terminal has extremely basic capabilities */
+#define TERM_UNKNOWN 0x02 /* unknown terminal type */
+#define TERM_NOUP 0x04 /* terminal has no up capability */
+#define TERM_SHORT 0x08 /* terminal is < 3 lines high */
+#define TERM_NARROW 0x10 /* terminal is < 3 columns wide */
+
+/* interesting termcap strings */
+
+#define TCCLEARSCREEN 0
+#define TCLEFT 1
+#define TCMULTLEFT 2
+#define TCRIGHT 3
+#define TCMULTRIGHT 4
+#define TCUP 5
+#define TCMULTUP 6
+#define TCDOWN 7
+#define TCMULTDOWN 8
+#define TCDEL 9
+#define TCMULTDEL 10
+#define TCINS 11
+#define TCMULTINS 12
+#define TCCLEAREOD 13
+#define TCCLEAREOL 14
+#define TCINSLINE 15
+#define TCDELLINE 16
+#define TCNEXTTAB 17
+#define TCBOLDFACEBEG 18
+#define TCSTANDOUTBEG 19
+#define TCUNDERLINEBEG 20
+#define TCALLATTRSOFF 21
+#define TCSTANDOUTEND 22
+#define TCUNDERLINEEND 23
+#define TC_COUNT 24
+
+#define tccan(X) (tclen[X])
+
+#define TXTBOLDFACE 0x01
+#define TXTSTANDOUT 0x02
+#define TXTUNDERLINE 0x04
+#define TXTDIRTY 0x80
+
+#define txtisset(X) (txtattrmask & (X))
+#define txtset(X) (txtattrmask |= (X))
+#define txtunset(X) (txtattrmask &= ~(X))
+
+#define TXTNOBOLDFACE 0x10
+#define TXTNOSTANDOUT 0x20
+#define TXTNOUNDERLINE 0x40
+
+#define txtchangeisset(X) (txtchange & (X))
+#define txtchangeset(X, Y) (txtchange |= (X), txtchange &= ~(Y))
+
+/****************************************/
+/* Definitions for the %_ prompt escape */
+/****************************************/
+
+#define cmdpush(X) if (!(cmdsp >= 0 && cmdsp < 256)) {;} else cmdstack[cmdsp++]=(X)
+#ifdef DEBUG
+# define cmdpop() if (cmdsp <= 0) { \
+ fputs("BUG: cmdstack empty\n", stderr); \
+ fflush(stderr); \
+ } else cmdsp--
+#else
+# define cmdpop() if (cmdsp <= 0) {;} else cmdsp--
+#endif
+
+#define CS_FOR 0
+#define CS_WHILE 1
+#define CS_REPEAT 2
+#define CS_SELECT 3
+#define CS_UNTIL 4
+#define CS_IF 5
+#define CS_IFTHEN 6
+#define CS_ELSE 7
+#define CS_ELIF 8
+#define CS_MATH 9
+#define CS_COND 10
+#define CS_CMDOR 11
+#define CS_CMDAND 12
+#define CS_PIPE 13
+#define CS_ERRPIPE 14
+#define CS_FOREACH 15
+#define CS_CASE 16
+#define CS_FUNCDEF 17
+#define CS_SUBSH 18
+#define CS_CURSH 19
+#define CS_ARRAY 20
+#define CS_QUOTE 21
+#define CS_DQUOTE 22
+#define CS_BQUOTE 23
+#define CS_CMDSUBST 24
+#define CS_MATHSUBST 25
+#define CS_ELIFTHEN 26
+#define CS_HEREDOC 27
+#define CS_HEREDOCD 28
+#define CS_BRACE 29
+#define CS_BRACEPAR 30
+
+/*********************
+ * Memory management *
+ *********************/
+
+#ifndef DEBUG
+# define HEAPALLOC do { int nonlocal_useheap = global_heapalloc(); do
+
+# define PERMALLOC do { int nonlocal_useheap = global_permalloc(); do
+
+# define LASTALLOC while (0); \
+ if (nonlocal_useheap) global_heapalloc(); \
+ else global_permalloc(); \
+ } while(0)
+
+# define LASTALLOC_RETURN \
+ if ((nonlocal_useheap ? global_heapalloc() : \
+ global_permalloc()), 0) {;} else return
+#else
+# define HEAPALLOC do { int nonlocal_useheap = global_heapalloc(); \
+ alloc_stackp++; do
+
+# define PERMALLOC do { int nonlocal_useheap = global_permalloc(); \
+ alloc_stackp++; do
+
+# define LASTALLOC while (0); alloc_stackp--; \
+ if (nonlocal_useheap) global_heapalloc(); \
+ else global_permalloc(); \
+ } while(0)
+
+# define LASTALLOC_RETURN \
+ if ((nonlocal_useheap ? global_heapalloc() : \
+ global_permalloc()),alloc_stackp--,0){;}else return
+#endif
+
+/****************/
+/* Debug macros */
+/****************/
+
+#ifdef DEBUG
+# define DPUTS(X,Y) if (!(X)) {;} else dputs(Y)
+# define MUSTUSEHEAP(X) if (useheap) {;} else \
+ fprintf(stderr, "BUG: permanent allocation in %s\n", X), \
+ fflush(stderr)
+#else
+# define DPUTS(X,Y)
+# define MUSTUSEHEAP(X)
+#endif
+
+/**************************/
+/* Signal handling macros */
+/**************************/
+
+/* These used in the sigtrapped[] array */
+
+#define ZSIG_TRAPPED (1<<0)
+#define ZSIG_IGNORED (1<<1)
+#define ZSIG_FUNC (1<<2)
+
+/****************/
+/* Entry points */
+/****************/
+
+/* compctl entry point pointers */
+
+typedef int (*CompctlReadFn) _((char *, char **, char *, char *));
+
+/* ZLE entry point pointers */
+
+typedef void (*ZleVoidFn) _((void));
+typedef void (*ZleVoidIntFn) _((int));
+typedef unsigned char * (*ZleReadFn) _((char *, char *, int));
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-08 10:00:03 +0000