/*

 * 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 zle_resetprompt()      zle_resetpromptptr()

#define zleread(X,Y,H,C)  zlereadptr(X,Y,H,C)

#define spaceinline(X)  spaceinlineptr(X)

#define zrefresh()      refreshptr()

#define compctlread(N,A,O,R) compctlreadptr(N,A,O,R)

/* A few typical macros */

#define minimum(a,b)  ((a) < (b) ? (a) : (b))

/*

 * Our longest integer type:  will be a 64 bit either if long already is,

 * or if we found some alternative such as long long.

 * Currently we only define this to be longer than a long if --enable-lfs

 * was given.  That enables internal use of 64-bit types even if

 * no actual large file support is present.

 */

#ifdef ZSH_64_BIT_TYPE

typedef ZSH_64_BIT_TYPE zlong;

#ifdef ZSH_64_BIT_UTYPE

typedef ZSH_64_BIT_UTYPE zulong;

#else

typedef unsigned zlong zulong;

#endif

#else

typedef long zlong;

typedef unsigned long zulong;

#endif

/*

 * Double float support requires 64-bit alignment, so if longs and

 * pointers are less we need to pad out.

 */

#ifndef LONG_IS_64_BIT

# define PAD_64_BIT 1

#endif

/* math.c */

typedef struct {

    union {

	zlong l;

	double d;

    } u;

    int type;

} mnumber;

#define MN_INTEGER 1		/* mnumber is integer */

#define MN_FLOAT   2		/* mnumber is floating point */

#define MN_UNSET   4		/* mnumber not yet retrieved */

typedef struct mathfunc *MathFunc;

typedef mnumber (*NumMathFunc)(char *, int, mnumber *, int);

typedef mnumber (*StrMathFunc)(char *, char *, int);

struct mathfunc {

    MathFunc next;

    char *name;

    int flags;

    NumMathFunc nfunc;

    StrMathFunc sfunc;

    char *module;

    int minargs;

    int maxargs;

    int funcid;

};

#define MFF_STR      1

#define MFF_ADDED    2

#define NUMMATHFUNC(name, func, min, max, id) \

    { NULL, name, 0, func, NULL, NULL, min, max, id }

#define STRMATHFUNC(name, func, id) \

    { NULL, name, MFF_STR, NULL, func, NULL, 0, 0, id }

/* 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    */

    DOLOOP,	/* 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 {

    REDIR_WRITE,		/* > */

    REDIR_WRITENOW,		/* >| */

    REDIR_APP,		/* >> */

    REDIR_APPNOW,		/* >>| */

    REDIR_ERRWRITE,		/* &>, >& */

    REDIR_ERRWRITENOW,	/* >&| */

    REDIR_ERRAPP,		/* >>& */

    REDIR_ERRAPPNOW,		/* >>&| */

    REDIR_READWRITE,		/* <> */

    REDIR_READ,		/* < */

    REDIR_HEREDOC,		/* << */

    REDIR_HEREDOCDASH,	/* <<- */

    REDIR_HERESTR,		/* <<< */

    REDIR_MERGEIN,		/* <&n */

    REDIR_MERGEOUT,		/* >&n */

    REDIR_CLOSE,		/* >&-, <&- */

    REDIR_INPIPE,		/* < <(...) */

    REDIR_OUTPIPE		/* > >(...) */

};

#define IS_WRITE_FILE(X)      ((X)>=REDIR_WRITE && (X)<=REDIR_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)>=REDIR_ERRWRITE && (X)<=REDIR_ERRAPPNOW)

#define IS_READFD(X)          (((X)>=REDIR_READWRITE && (X)<=REDIR_MERGEIN) || (X)==REDIR_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.     */

#define INP_LINENO    (1<<5)    /* update line number                      */

/* 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 optname   *Optname;

typedef struct reswd     *Reswd;

typedef struct alias     *Alias;

typedef struct param     *Param;

typedef struct paramdef  *Paramdef;

typedef struct cmdnam    *Cmdnam;

typedef struct shfunc    *Shfunc;

typedef struct funcstack *Funcstack;

typedef struct funcwrap  *FuncWrap;

typedef struct options	 *Options;

typedef struct builtin   *Builtin;

typedef struct nameddir  *Nameddir;

typedef struct module    *Module;

typedef struct linkedmod *Linkedmod;

typedef struct patprog   *Patprog;

typedef struct process   *Process;

typedef struct job       *Job;

typedef struct value     *Value;

typedef struct conddef   *Conddef;

typedef struct redir     *Redir;

typedef struct complist  *Complist;

typedef struct heap      *Heap;

typedef struct heapstack *Heapstack;

typedef struct histent   *Histent;

typedef struct hookdef   *Hookdef;

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 zaddlinknode(X,Y)   zinsertlinknode(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 zpushnode(X,Y)      zinsertlinknode(X,(LinkNode) X,Y)

#define incnode(X)          (X = nextnode(X))

#define firsthist()         (hist_ring? hist_ring->down->histnum : curhist)

#define setsizednode(X,Y,Z) ((X)->first[(Y)].dat = (void *) (Z))

/* stack allocated linked lists */

#define local_list0(N) struct linklist N

#define init_list0(N) \

    do { \

        (N).first = NULL; \

        (N).last = (LinkNode) &(N); \

    } while (0)

#define local_list1(N) struct linklist N; struct linknode __n0

#define init_list1(N,V0) \

    do { \

        (N).first = &__n0; \

        (N).last = &__n0; \

        __n0.next = NULL; \

        __n0.last = (LinkNode) &(N); \

        __n0.dat = (void *) (V0); \

    } while (0)

/********************************/

/* Definitions for syntax trees */

/********************************/

/* 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 (&|) */

/* (1<<4) is used for Z_END, see the wordcode definitions */

/* (1<<5) is used for Z_SIMPLE, see the wordcode definitions */

/* Condition types. */

#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

#define COND_MOD   16

#define COND_MODI  17

typedef int (*CondHandler) _((char **, int));

struct conddef {

    Conddef next;		/* next in list                       */

    char *name;			/* the condition name                 */

    int flags;			/* see CONDF_* below                  */

    CondHandler handler;	/* handler function                   */

    int min;			/* minimum number of strings          */

    int max;			/* maximum number of strings          */

    int condid;			/* for overloading handler functions  */

    char *module;		/* module to autoload                 */

};

#define CONDF_INFIX  1

#define CONDF_ADDED  2

#define CONDDEF(name, flags, handler, min, max, condid) \

    { NULL, name, flags, handler, min, max, condid, NULL }

/* tree element for redirection lists */

struct redir {

    int type;

    int fd1, fd2;

    char *name;

};

/* 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 */

};

/* structure for foo=bar assignments */

struct asgment {

    struct asgment *next;

    char *name;

    char *value;

};

/* lvalue for variable assignment/expansion */

struct value {

    int isarr;

    Param pm;		/* parameter node                      */

    int inv;		/* should we return the index ?        */

    int start;		/* first element of array slice, or -1 */

    int end;		/* 1-rel last element of array slice, or -1 */

    char **arr;		/* cache for hash turned into array */

};

#define MAX_ARRLEN    262144

/********************************************/

/* Definitions for word code                 */

/********************************************/

typedef unsigned int wordcode;

typedef wordcode *Wordcode;

typedef struct funcdump *FuncDump;

typedef struct eprog *Eprog;

struct funcdump {

    FuncDump next;		/* next in list */

    dev_t dev;			/* device */

    ino_t ino;			/* indoe number */

    int fd;			/* file descriptor */

    Wordcode map;		/* pointer to header */

    Wordcode addr;		/* mapped region */

    int len;			/* length */

    int count;			/* reference count */

    char *filename;

};

/*

 * A note on the use of reference counts in Eprogs.

 *

 * When an Eprog is created, nref is set to -1 if the Eprog is on the

 * heap; then no attempt is ever made to free it.  (This information is

 * already present in EF_HEAP; we use the redundancy for debugging

 * checks.)

 *

 * Otherwise, nref is initialised to 1.  Calling freeprog() decrements

 * nref and frees the Eprog if the count is now zero.  When the Eprog

 * is in use, we call useeprog() at the start and freeprog() at the

 * end to increment and decrement the reference counts.  If an attempt

 * is made to free the Eprog from within, this will then take place

 * when execution is finished, typically in the call to freeeprog()

 * in execode().  If the Eprog was on the heap, neither useeprog()

 * nor freeeprog() has any effect.

 */

struct eprog {

    int flags;			/* EF_* below */

    int len;			/* total block length */

    int npats;			/* Patprog cache size */

    int nref;			/* number of references: delete when zero */

    Patprog *pats;		/* the memory block, the patterns */

    Wordcode prog;		/* memory block ctd, the code */

    char *strs;			/* memory block ctd, the strings */

    Shfunc shf;			/* shell function for autoload */

    FuncDump dump;		/* dump file this is in */

};