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.
 
 
 
 
 
 

399 lines
10 KiB

/*****************************************************************************
*
* builtin.c
*
* Builtin macros.
*
*****************************************************************************/
#include "m4.h"
extern TOK tokColonTab;
extern TOK tokEol;
/*****************************************************************************
*
* opIfdef
*
* If $1 is defined, then return $2, else $3.
*
* If $# < 2, then there's no point in returning anything at all.
*
* The extra ptokNil covers us in the case where $# is 2.
*
* QUIRK! GNU m4 emits a warning if $# < 2. AT&T remains silent.
* I side with AT&T on this one.
*
* QUIRK! GNU m4 emits `$0' if $# = 0. AT&T silently ignores
* the entire macro call. I side with GNU on this one.
*
*****************************************************************************/
DeclareOp(opIfdef)
{
if (ctokArgv >= 2) {
if (pmacFindPtok(ptokArgv(1))) {
PushPtok(ptokArgv(2));
} else {
PushPtok(ptokArgv(3));
}
} else if (ctokArgv == 0) {
PushQuotedPtok(ptokArgv(0));
} else {
#ifdef STRICT_M4
Warn("wrong number of arguments to %P", ptokArgv(0));
#endif
}
}
/*****************************************************************************
*
* opIfelse
*
* If $1 and $2 are identical, then return $3.
* If there are only four arguments, then return $4.
* Else, shift three and restart.
*
* If there are fewer than three arguments, then return nothing.
*
* The extra ptokNil saves us in the cases where $# = 2 + 3n.
*
* QUIRK! GNU m4 emits a warning if $# = 2 + 3n. AT&T remains silent.
* I side with AT&T on this one.
*
*****************************************************************************/
DeclareOp(opIfelse)
{
if (ctokArgv >= 3) { /* Need at least three for starters */
ITOK itok = 1;
do {
if (fEqPtokPtok(ptokArgv(itok), ptokArgv(itok+1))) {
PushPtok(ptokArgv(itok+2)); /* ptokNil saves us here */
return;
}
itok += 3;
} while (itok <= ctokArgv - 1); /* While at least two args left */
if (itok == ctokArgv) { /* If only one left... */
PushPtok(ptokArgv(itok));
} else {
Assert(itok == ctokArgv + 1); /* Else must be zero left */
}
return;
}
}
/*****************************************************************************
*
* opShift
*
* Return all but the first argument, quoted and pushed back with
* commas in between. We push them in reverse order so that they
* show up properly.
*
*****************************************************************************/
DeclareOpc(opcShift)
{
if (itok > 1) {
PushQuotedPtok(ptok);
if (itok > 2) {
PushTch(tchComma);
}
}
}
DeclareOp(opShift)
{
EachReverseOpcArgvDw(opcShift, argv, 0);
}
/*****************************************************************************
*
* opLen
*
* Returns the length of its argument.
* The extra ptokNil covers us in the case where $# is zero.
*
* QUIRK! AT&T m4 silently ignores the case where $# is zero, but
* GNU m4 will emit `$0' so as to reduce potential conflict with an
* identically-spelled language keyword. I side with GNU on this one.
*
* SOMEDAY! -- this quirk should be an op attribute.
*
*
*****************************************************************************/
DeclareOp(opLen)
{
if (ctokArgv) {
#ifdef STRICT_M4
if (ctokArgv != 1) {
Warn("wrong number of arguments to %P", ptokArgv(0));
}
#endif
PushAt(ctchArgv(1));
} else {
PushQuotedPtok(ptokArgv(0));
}
}
/*****************************************************************************
*
* opTraceon
*
* With no arguments, turns on global tracing.
* Otherwise, turns on local tracing on the specified macros.
*
* opTraceoff
*
* Turns off global tracing, and also turns off local tracing on the
* specified macros (if any).
*
*****************************************************************************/
DeclareOpc(opcTraceonoff)
{
PMAC pmac = pmacFindPtok(ptok);
if (pmac) {
pmac->pval->fTrace = dw;
}
}
DeclareOp(opTraceon)
{
if (ctokArgv == 0) {
g_fTrace = 1;
} else {
EachOpcArgvDw(opcTraceonoff, argv, 1);
}
}
DeclareOp(opTraceoff)
{
g_fTrace = 0;
EachOpcArgvDw(opcTraceonoff, argv, 0);
}
/*****************************************************************************
*
* opDnl
*
* Gobbles all characters up to and including the next newline.
*
* If EOF is reached, push the EOF back and stop.
*
* QUIRK! AT&T m4 silently ignores the case where $# > 0. GNU m4
* issues a warning. I side with AT&T on this one.
*
*****************************************************************************/
DeclareOp(opDnl)
{
TCH tch;
#ifdef STRICT_M4
if (ctokArgv != 0) {
Warn("wrong number of arguments to %P", ptokArgv(0));
}
#endif
while ((tch = tchGet()) != '\n') {
if (tch == tchMagic) {
TCH L_tch = tchGet();
if (L_tch == tchEof) {
PushPtok(&tokEof); /* Eek! Does this actually work? */
break;
}
}
}
}
/*****************************************************************************
*
* opChangequote - not implemented
* opChangecom - not implemented
* opUndivert - not implemented
* opSyscmd - not implemented
* opSysval - not implemented
* opMaketemp - not implemented
* opM4exit - not implemented
* opM4wrap - not implemented
*
*****************************************************************************/
/*****************************************************************************
*
* opDivert
*
* We currently support only two diversions:
*
* 0 = stdout
* 1-9 = unsupported
* <anything else> = /dev/null
*
* This is just barely enough to get DirectX building.
*
*****************************************************************************/
DeclareOp(opDivert)
{
#ifdef STRICT_M4
if (ctokArgv != 1) {
Warn("wrong number of arguments to divert");
}
#endif
if (ctokArgv > 0) {
PTOK ptok = ptokArgv(1);
if (ptok->ctch == 1 && ptok->u.ptch[0] == TEXT('0')) {
g_pdivCur = g_pdivOut;
} else {
g_pdivCur = g_pdivNul;
}
}
}
/*****************************************************************************
*
* opDivnum
*
* We currently support only two diversions:
*
* 0 = stdout
* 1-9 = unsupported
* <anything else> = /dev/null
*
* This is just barely enough to get DirectX building.
*
*****************************************************************************/
DeclareOp(opDivnum)
{
#ifdef STRICT_M4
if (ctokArgv != 0) {
Warn("wrong number of arguments to %P", ptokArgv(0));
}
#endif
PushAt(g_pdivCur == g_pdivOut ? 0 : -1);
}
/*****************************************************************************
*
* opErrprint
*
* Prints its argument on the dianostic output file.
* The extra ptokNil covers us in the case where $# is zero.
*
* QUIRK! AT&T m4 silently ignores excess arguments. GNU m4 emits
* all arguments, separated by spaces. I side with AT&T on this one.
*
*****************************************************************************/
DeclareOp(opErrprint)
{
#ifdef STRICT_M4
if (ctokArgv != 1) {
Warn("wrong number of arguments to errprint");
}
#endif
AddPdivPtok(g_pdivErr, ptokArgv(1));
FlushPdiv(g_pdivErr);
}
/*****************************************************************************
*
* opDumpdef
*
* With no arguments, dumps all definitions.
* Otherwise, dumps only the specified macros.
*
* QUIRK! When given multiple arguments, AT&T m4 dumps the macros in
* the order listed. GNU m4 dumps them in reverse order. (!)
* I side with AT&T on this one.
*
*****************************************************************************/
void STDCALL
DumpdefPmac(PMAC pmac)
{
PTCH ptch, ptchMax;
AddPdivPtok(g_pdivErr, &pmac->tokName);
AddPdivPtok(g_pdivErr, &tokColonTab);
ptch = ptchPtok(&pmac->pval->tok);
ptchMax = ptchMaxPtok(&pmac->pval->tok);
for ( ; ptch < ptchMax; ptch++) {
AddPdivTch(g_pdivErr, *ptch); /* SOMEDAY -- internals! - do they show up okay? */
}
AddPdivPtok(g_pdivErr, &tokEol);
}
DeclareOpc(opcDumpdef)
{
PMAC pmac = pmacFindPtok(ptok);
if (pmac) {
DumpdefPmac(pmac);
}
}
DeclareOp(opDumpdef)
{
if (ctokArgv == 0) {
EachMacroOp(DumpdefPmac);
} else {
EachOpcArgvDw(opcDumpdef, argv, 0);
}
FlushPdiv(g_pdivErr);
}
/*****************************************************************************
*
* opInclude
* opSinclude
*
* Pushes the contents of the file named in the argument.
* Sinclude says nothing if the file is inaccessible.
*
* QUIRK! AT&T m4 silently ignores the case where $1 is null, but
* GNU m4 issues an error (no such file or directory). I side with
* GNU on this one.
*
* QUIRK! AT&T m4 silently ignores the case where $# is zero, but
* GNU m4 will emit `$0' so as to reduce potential conflict with an
* identically-spelled language keyword. I side with GNU on this one.
*
* QUIRK! AT&T m4 silently ignores arguments $2 onward. GNU emits
* a warning but continues. I side with AT&T on this one.
*
*****************************************************************************/
void STDCALL
opIncludeF(ARGV argv, BOOL fFatal)
{
if (ctokArgv) {
PTCH ptch = ptchDupPtok(ptokArgv(1));
if (ptch) {
if (hfInputPtchF(ptch, fFatal) == hfNil) {
FreePv(ptch);
}
#ifdef STRICT_M4
if (ctokArgv != 1) {
Warn("excess arguments to built-in %P ignored", ptokArgv(0));
}
#endif
}
} else {
PushQuotedPtok(ptokArgv(0));
}
}
DeclareOp(opInclude)
{
opIncludeF(argv, 1);
}
DeclareOp(opSinclude)
{
opIncludeF(argv, 0);
}