Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

398 lines
12 KiB

/*****************************************************************************
*
* m4.h
*
*****************************************************************************/
#ifdef POSIX
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <limits.h>
#include <string.h>
#include <unistd.h>
typedef char TCHAR, *PTCH;
typedef const char *PCSTR;
typedef unsigned char TBYTE, BYTE, *PBYTE;
typedef unsigned int UINT;
typedef unsigned long DWORD;
typedef int BOOL, HFILE;
typedef void *PVOID;
#define VOID void
#define CONST const
#define TEXT(lit) lit
#define MAX_PATH PATH_MAX
#define max(a,b) (((a) > (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))
#define EOL TEXT("\n")
#define cbEol 1
#else
#include <windows.h>
#define EOL TEXT("\r\n")
#define cbEol 2
#endif
#include <stddef.h> /* offsetof */
/*****************************************************************************
*
* Dialectical variation
*
*****************************************************************************/
#ifdef DBG
#define DEBUG
#endif
/*****************************************************************************
*
* Baggage - Stuff I carry everywhere.
*
* Stuff that begin with underscores are bottom-level gizmos which tend
* to get wrapped by functions with the same name.
*
*****************************************************************************/
#if defined(_MSC_VER)
#define STDCALL __stdcall
#undef CDECL /* <windows.h> defines it wrong */
#define CDECL __cdecl
#define INLINE static __inline /* Inlines are always static */
#define NORETURN
#define PURE
#define _pvAllocCb(cb) LocalAlloc(LMEM_FIXED, cb)
#define _pvZAllocCb(cb) LocalAlloc(LMEM_FIXED + LMEM_ZEROINIT, cb)
#define _pvReallocPvCb(pv, cb) LocalReAlloc(pv, cb, LMEM_MOVEABLE)
#define _FreePv(pv) LocalFree(pv)
#define PrintPtchPtchVa wvsprintf
#define PrintPtchPtchV wsprintf
#define exit ExitProcess
#define strlen lstrlen
#define strcmp lstrcmp
#define bzero ZeroMemory
#elif defined(__GNUC__)
#define STDCALL
#define CDECL
#define INLINE static __inline__ /* Inlines are always static */
#define NORETURN __NORETURN
#define PURE __CONSTVALUE
#define _pvAllocCb(cb) malloc(cb)
#define _pvZAllocCb(cb) calloc(cb, 1)
#define _pvReallocPvCb(pv, cb) realloc(pv, cb)
#define _FreePv(pv) free(pv)
#define PrintPtchPtchVa vsprintf
#define PrintPtchPtchV sprintf
#endif
typedef TCHAR TCH, *PTSTR; /* More basic types */
typedef UINT ITCH;
typedef UINT CTCH;
typedef UINT CB;
typedef BOOL F;
typedef PVOID PV;
typedef CONST VOID *PCVOID;
typedef CONST TCH *PCTCH, *PCTSTR;
#define cbCtch(ctch) ((ctch) * sizeof(TCHAR))
#define ctchCb(cb) ((cb) / sizeof(TCHAR))
#define ctchMax ((CTCH)~0)
#define CopyPtchPtchCtch(ptchDst, ptchSrc, ctch) \
memcpy(ptchDst, ptchSrc, cbCtch(ctch))
#define MovePtchPtchCtch(ptchDst, ptchSrc, ctch) \
memmove(ptchDst, ptchSrc, cbCtch(ctch))
#define fEqPtchPtchCtch(ptchDst, ptchSrc, ctch) \
!memcmp(ptchDst, ptchSrc, cbCtch(ctch))
#define pvSubPvCb(pv, cb) ((PV)((PBYTE)pv - (cb)))
/*
* Round cb up to the nearest multiple of cbAlign. cbAlign must be
* a power of 2 whose evaluation entails no side-effects.
*/
#define ROUNDUP(cb, cbAlign) ((((cb) + (cbAlign) - 1) / (cbAlign)) * (cbAlign))
/*
* Returns the number of elements in an array.
*/
#define cA(a) (sizeof(a)/sizeof(a[0]))
/*****************************************************************************
*
* assert.c
*
*****************************************************************************/
void NORETURN CDECL Die(PCTSTR pszFormat, ...);
int NORETURN STDCALL AssertPszPszLn(PCSTR pszExpr, PCSTR pszFile, int iLine);
#ifdef DEBUG
#define AssertFPsz(c, psz) ((c) ? 0 : AssertPszPszLn(psz, __FILE__, __LINE__))
#define Validate(c) ((c) ? 0 : AssertPszPszLn(#c, __FILE__, __LINE__))
#define D(x) x
#else
#define AssertFPsz(c, psz)
#define Validate(c) (c)
#define D(x)
#endif
#define Assert(c) AssertFPsz(c, #c)
typedef unsigned long SIG; /* Signatures */
#define sigABCD(a,b,c,d) ((a) + ((b)<<8) + ((c)<<16) + ((d)<<24))
#define AssertPNm(p, nm) AssertFPsz((p)->sig == (sig##nm), "Assert"#nm)
/*****************************************************************************
*
* tchMagic - Super-secret value used to signal out-of-band info
*
*****************************************************************************/
#define tchMagic '\0' /* Out-of-band marker */
#include "io.h" /* File I/O stuff */
#include "m4ctype.h" /* Character types */
#include "tok.h" /* Tokens */
#include "mem.h" /* Memory and GC */
#include "divert.h" /* Diversions */
#include "stream.h" /* Files, streams */
/*****************************************************************************
*
* A VAL records a macro's value, either the current value or a pushed
* value.
*
* tok - text value (HeapAllocate'd)
* fTrace - nonzero if this instance should be traced
* pvalPrev - link to previous value
*
* A MACRO records an active macro.
*
* tokName - macro name (HeapAllocate'd)
* pval - macro value
*
* A TSFL records the state of a token (token state flags).
*
*****************************************************************************/
typedef struct VALUE VAL, *PVAL;
struct VALUE {
D(SIG sig;)
TOK tok;
BOOL fTrace;
PVAL pvalPrev;
};
#define sigPval sigABCD('V', 'a', 'l', 'u')
#define AssertPval(pval) AssertPNm(pval, Pval)
typedef struct MACRO MAC, *PMAC, **PPMAC;
struct MACRO {
D(SIG sig;)
PMAC pmacNext;
TOK tokName;
PVAL pval;
};
#define sigPmac sigABCD('M', 'a', 'c', 'r')
#define AssertPmac(pmac) AssertPNm(pmac, Pmac)
extern PPMAC mphashpmac;
/*****************************************************************************
*
* operators
*
* Each operator is called as op(argv), where argv is the magic
* cookie for accessing argument vector.
*
* To access the parameters, use the following macros:
*
* ctokArgv -- Number of arguments provided, not including $0.
*
* ptokArgv(i) -- Access the i'th parameter
*
* Note that it is safe to pass a pptok because the call stack does
* not grow during macro expansion. Therefore, the token array
* cannot get reallocated.
*
* For convenience, ptokArgv(ctokArgv+1) is always ptokNil.
*
*****************************************************************************/
typedef PTOK ARGV; /* Argument vector cookie */
#define ptokArgv(i) (&argv[i])
#define ptchArgv(i) ptchPtok(ptokArgv(i))
#define ctchArgv(i) ctchSPtok(ptokArgv(i))
#define ctokArgv ((ITOK)ctchUPtok(ptokArgv(-1)))
#define SetArgvCtok(ctok) SetPtokCtch(ptokArgv(-1), ctok)
#define DeclareOp(op) void STDCALL op(ARGV argv)
#define DeclareOpc(opc) void STDCALL opc(PTOK ptok, ITOK itok, DWORD dw)
typedef void (STDCALL *OP)(ARGV argv);
typedef void (STDCALL *OPC)(PTOK ptok, ITOK itok, DWORD dw);
typedef void (STDCALL *MOP)(PMAC pmac);
void STDCALL EachOpcArgvDw(OPC opc, ARGV argv, DWORD dw);
void STDCALL EachReverseOpcArgvDw(OPC opc, ARGV argv, DWORD dw);
void STDCALL EachMacroOp(MOP mop);
extern OP rgop[];
/*****************************************************************************
*
* hash.c - Hashing
*
*****************************************************************************/
typedef unsigned long HASH;
extern HASH g_hashMod;
HASH STDCALL hashPtok(PCTOK ptok);
void STDCALL InitHash(void);
/*****************************************************************************
*
* obj.c - Basic object methods
*
*****************************************************************************/
void STDCALL PopdefPmac(PMAC pmac);
void STDCALL PushdefPmacPtok(PMAC pmac, PCTOK ptok);
void STDCALL FreePmac(PMAC pmac);
PMAC STDCALL pmacFindPtok(PCTOK ptok);
PMAC STDCALL pmacGetPtok(PCTOK ptok);
F STDCALL PURE fEqPtokPtok(PCTOK ptok1, PCTOK ptok2);
F STDCALL PURE fIdentPtok(PCTOK ptok);
PTCH STDCALL ptchDupPtch(PCTCH ptch);
PTCH STDCALL ptchDupPtok(PCTOK ptok);
/*****************************************************************************
*
* at.c - Arithmetic types
*
*****************************************************************************/
typedef int AT; /* AT = arithmetic type */
typedef AT *PAT; /* Pointer to AT */
typedef int DAT; /* Delta to AT */
void STDCALL SkipWhitePtok(PTOK ptok);
void STDCALL AddExpAt(AT at);
void STDCALL PushAtRadixCtch(AT atConvert, unsigned radix, CTCH ctch);
void STDCALL PushAt(AT at);
F STDCALL PURE fEvalPtokPat(PTOK ptok, PAT at);
AT STDCALL PURE atTraditionalPtok(PCTOK ptok);
/*****************************************************************************
*
* eval.c - Arithmetic evaluation
*
*****************************************************************************/
extern struct CELL *rgcellEstack;
/*****************************************************************************
*
* crackle.c - Macro expansion
*
*****************************************************************************/
void STDCALL PushSubstPtokArgv(PTOK ptok, ARGV argv);
void STDCALL TraceArgv(ARGV argv);
/*****************************************************************************
*
* main.c - Boring stuff
*
*****************************************************************************/
HF STDCALL hfInputPtchF(PTCH ptch, F fFatal);
/*****************************************************************************
*
* predef.c - Predefined (a.k.a. built-in) macros
*
*****************************************************************************/
void STDCALL InitPredefs(void);
/*****************************************************************************
*
* EachOp
*
* Before calling this macro, define the macro `x' to do whatever
* you want.
*
* EachOpX
*
* Same as EachOp, except that it also includes the Eof magic.
*
*****************************************************************************/
#define EachOp() \
x(Define, define) \
x(Undefine, undefine) \
x(Defn, defn) \
x(Pushdef, pushdef) \
x(Popdef, popdef) \
x(Ifdef, ifdef) \
x(Shift, shift) \
/* x(Changequote, changequote) */ \
/* x(Changecom, changecom) */ \
x(Divert, divert) \
/* x(Undivert, undivert) */ \
x(Divnum, divnum) \
x(Dnl, dnl) \
x(Ifelse, ifelse) \
x(Incr, incr) \
x(Decr, decr) \
x(Eval, eval) \
x(Len, len) \
x(Index, index) \
x(Substr, substr) \
x(Translit, translit) \
x(Include, include) \
x(Sinclude, sinclude) \
/* x(Syscmd, syscmd) */ \
/* x(Sysval, sysval) */ \
/* x(Maketemp, maketemp) */ \
/* x(M4exit, m4exit) */ \
/* x(M4wrap, m4wrap) */ \
x(Errprint, errprint) \
x(Dumpdef, dumpdef) \
x(Traceon, traceon) \
x(Traceoff, traceoff) \
x(Patsubst, patsubst) /* GNU extension that the d3d guys rely on */ \
#define EachOpX() EachOp() x(Eof, eof) x(Eoi, eoi)
#define x(cop, lop) DeclareOp(op##cop);
EachOpX()
#undef x
enum MAGIC {
#define x(cop, lop) tch##cop,
EachOpX()
#undef x
tchMax,
};