parser.c File Reference

#include "precomp.h"

Include dependency graph for parser.c:

Go to the source code of this file.

Macros
#define	MSCMD_ECHO_COMMAND_COMPAT
#define	MSCMD_PARSER_BUGS
#define	MSCMD_REDIR_PARSE_BUGS
#define	C_OP_LOWEST   C_MULTI
#define	C_OP_HIGHEST   C_PIPE
#define	IF_MAX_UNARY   IF_DEFINED
#define	IF_MAX_COMPARISON   IF_GEQ
#define	DUMP(Command, Pad)
#define	CHAR(Char)
#define	STRING(String)
#define	PRINTF(Format, ...)
#define	RECURSE(Subcommand)

Typedefs
typedef enum _TOK_TYPE	TOK_TYPE

Enumerations
enum	_TOK_TYPE {   TOK_END, TOK_NORMAL, TOK_OPERATOR, TOK_REDIRECTION,   TOK_BEGIN_BLOCK, TOK_END_BLOCK }

Functions
static __inline BOOL	IsSeparator (TCHAR Char)
static VOID	ResetParser (IN PTCHAR Pos)
static VOID	UnParseToken (VOID)
static VOID	InitParser (VOID)
static TCHAR	ParseChar (VOID)
VOID	ParseErrorEx (IN PCTSTR s)
static __inline VOID	ParseError (VOID)
static TOK_TYPE	ParseTokenEx (IN TCHAR PrefixOperator OPTIONAL, IN TCHAR ExtraEnd OPTIONAL, IN PCTSTR Separators OPTIONAL, IN BOOL bHandleContinuations)
static __inline INT	ParseToken (IN TCHAR ExtraEnd OPTIONAL, IN PCTSTR Separators OPTIONAL)
static PARSED_COMMAND *	AllocCommand (IN COMMAND_TYPE Type, IN PCTSTR CmdHead OPTIONAL, IN PCTSTR CmdTail OPTIONAL)
VOID	FreeCommand (IN OUT PARSED_COMMAND *Cmd)
static BOOL	ParseRedirection (IN OUT REDIRECTION **List)
static __inline PARSED_COMMAND *	ParseCommandOp (IN COMMAND_TYPE OpType)
static PARSED_COMMAND *	ParseBlock (IN OUT REDIRECTION **RedirList)
static PARSED_COMMAND *	ParseIf (VOID)
static PARSED_COMMAND *	ParseFor (VOID)
static PARSED_COMMAND *	ParseRem (VOID)
static PARSED_COMMAND *	ParseCommandPart (IN OUT REDIRECTION **RedirList)
static PARSED_COMMAND *	ParsePrimary (VOID)
static PARSED_COMMAND *	ParseCommandBinaryOp (IN COMMAND_TYPE OpType)
PARSED_COMMAND *	ParseCommand (IN PCTSTR Line)
static VOID	DumpRedir (IN REDIRECTION *Redirections)
VOID	DumpCommand (IN PARSED_COMMAND *Cmd, IN ULONG SpacePad)
VOID	EchoCommand (IN PARSED_COMMAND *Cmd)
PTCHAR	UnparseCommand (IN PARSED_COMMAND *Cmd, OUT PTCHAR Out, IN PTCHAR OutEnd)

Variables
BOOLEAN	fDumpTokens = FALSE
BOOLEAN	fDumpParse = FALSE
static const TCHAR	OpString [][3] = { _T("&"), _T("||"), _T("&&"), _T("|") }
static const TCHAR	RedirString [][3] = { _T("<"), _T(">"), _T(">>") }
static const TCHAR *const	IfOperatorString []
static TCHAR	TempBuf [CMDLINE_LENGTH]
BOOL	bParseError
static BOOL	bLineContinuations
TCHAR	ParseLine [CMDLINE_LENGTH]
static PTCHAR	ParsePos
static PTCHAR	OldParsePos
BOOL	bIgnoreParserComments = TRUE
BOOL	bHandleContinuations = TRUE
static TCHAR	CurrentToken [CMDLINE_LENGTH]
static TOK_TYPE	CurrentTokenType = TOK_END
static INT	InsideBlock = 0

Macro Definition Documentation

C_OP_HIGHEST

#define C_OP_HIGHEST   C_PIPE

Definition at line 39 of file parser.c.

C_OP_LOWEST

#define C_OP_LOWEST   C_MULTI

Definition at line 38 of file parser.c.

CHAR

#define CHAR

(

Char

)

Value:

do { \
    if (Out == OutEnd) return NULL; \
    *Out++ = Char; \
} while (0)

DUMP

#define DUMP	(		Command,
			Pad
	)

Value:

do { \
    Cmd = (Command); \
    SpacePad = (Pad); \
    goto dump; \
} while (0)

IF_MAX_COMPARISON

#define IF_MAX_COMPARISON   IF_GEQ

IF_MAX_UNARY

#define IF_MAX_UNARY   IF_DEFINED

MSCMD_ECHO_COMMAND_COMPAT

#define MSCMD_ECHO_COMMAND_COMPAT

Definition at line 12 of file parser.c.

MSCMD_PARSER_BUGS

#define MSCMD_PARSER_BUGS

Definition at line 15 of file parser.c.

MSCMD_REDIR_PARSE_BUGS

#define MSCMD_REDIR_PARSE_BUGS

Definition at line 21 of file parser.c.

PRINTF

#define PRINTF	(		Format,
			...
	)

Value:

do { \
    UINT Len = _sntprintf(Out, OutEnd - Out, Format, __VA_ARGS__); \
    if (Len > (UINT)(OutEnd - Out)) return NULL; \
    Out += Len; \
} while (0)

RECURSE

#define RECURSE

(

Subcommand

)

Value:

do { \
    Out = UnparseCommand(Subcommand, Out, OutEnd); \
    if (!Out) return NULL; \
} while (0)

STRING

#define STRING

(

String

)

Value:

do { \
    if (Out + _tcslen(String) > OutEnd) return NULL; \
    Out = _stpcpy(Out, String); \
} while (0)

Typedef Documentation

TOK_TYPE

typedef enum _TOK_TYPE TOK_TYPE

Enumeration Type Documentation

_TOK_TYPE

enum _TOK_TYPE

Enumerator
TOK_END
TOK_NORMAL
TOK_OPERATOR
TOK_REDIRECTION
TOK_BEGIN_BLOCK
TOK_END_BLOCK

Definition at line 77 of file parser.c.

{
    TOK_END,
    TOK_NORMAL,
    TOK_OPERATOR,
    TOK_REDIRECTION,
    TOK_BEGIN_BLOCK,
    TOK_END_BLOCK
} TOK_TYPE;

Function Documentation

AllocCommand()

static PARSED_COMMAND* AllocCommand ( IN COMMAND_TYPE  Type, IN PCTSTR CmdHead  OPTIONAL, IN PCTSTR CmdTail  OPTIONAL  )

static

Definition at line 459 of file parser.c.

{
    PARSED_COMMAND* Cmd;

    switch (Type)
    {
    case C_COMMAND:
    case C_REM:
    {
        SIZE_T CmdHeadLen = _tcslen(CmdHead) + 1;
        SIZE_T CmdTailLen = _tcslen(CmdTail) + 1;

        Cmd = cmd_alloc(FIELD_OFFSET(PARSED_COMMAND,
                                     Command.First[CmdHeadLen + CmdTailLen]));
        if (!Cmd)
            return NULL;

        Cmd->Type = Type;
        Cmd->Next = NULL;
        Cmd->Subcommands = NULL;
        Cmd->Redirections = NULL; /* Is assigned by the calling function */
        memcpy(Cmd->Command.First, CmdHead, CmdHeadLen * sizeof(TCHAR));
        Cmd->Command.Rest = Cmd->Command.First + CmdHeadLen;
        memcpy(Cmd->Command.Rest, CmdTail, CmdTailLen * sizeof(TCHAR));
        return Cmd;
    }

    case C_QUIET:
    case C_BLOCK:
    case C_MULTI:
    case C_OR:
    case C_AND:
    case C_PIPE:
    {
        Cmd = cmd_alloc(sizeof(PARSED_COMMAND));
        if (!Cmd)
            return NULL;

        Cmd->Type = Type;
        Cmd->Next = NULL;
        Cmd->Subcommands = NULL;
        Cmd->Redirections = NULL; /* For C_BLOCK only: is assigned by the calling function */
        return Cmd;
    }

    case C_FOR:
    case C_IF:
    {
        Cmd = cmd_alloc(sizeof(PARSED_COMMAND));
        if (!Cmd)
            return NULL;

        memset(Cmd, 0, sizeof(PARSED_COMMAND));
        Cmd->Type = Type;
        return Cmd;
    }

    default:
        ERR("Unknown command type 0x%x\n", Type);
        ASSERT(FALSE);
        return NULL;
    }
}

Referenced by ParseBlock(), ParseCommandBinaryOp(), ParseCommandPart(), ParseFor(), ParseIf(), ParsePrimary(), and ParseRem().

DumpCommand()

VOID DumpCommand	(	IN PARSED_COMMAND *	Cmd,
		IN ULONG	SpacePad
	)

Definition at line 1533 of file parser.c.

{
/*
 * This macro is like DumpCommand(Cmd, Pad);
 * but avoids an extra recursive level.
 * Note that it can be used ONLY for terminating commands!
 */
#define DUMP(Command, Pad) \
do { \
    Cmd = (Command); \
    SpacePad = (Pad); \
    goto dump; \
} while (0)

    PARSED_COMMAND* Sub;

dump:
    if (!Cmd)
        return;

    /* Space padding */
    ConOutPrintf(_T("%*s"), SpacePad, _T(""));

    switch (Cmd->Type)
    {
    case C_COMMAND:
    case C_REM:
    {
        /* Generic command name, and Type */
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutPrintf(_T("Cmd: %s  Type: %x"),
                     Cmd->Command.First, Cmd->Type);
#else
        ConOutPrintf(_T("Cmd: %s  Type: %x "),
                     Cmd->Command.First, Cmd->Type);
#endif
        /* Arguments */
        if (Cmd->Command.Rest && *(Cmd->Command.Rest))
#ifndef MSCMD_ECHO_COMMAND_COMPAT
            ConOutPrintf(_T(" Args: `%s'"), Cmd->Command.Rest);
#else
            ConOutPrintf(_T("Args: `%s' "), Cmd->Command.Rest);
#endif
        /* Redirections */
        DumpRedir(Cmd->Redirections);

        ConOutChar(_T('\n'));
        return;
    }

    case C_QUIET:
    {
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutChar(_T('@'));
#else
        ConOutPuts(_T("@ "));
#endif
        DumpRedir(Cmd->Redirections); // FIXME: Can we have leading redirections??
        ConOutChar(_T('\n'));

        /*DumpCommand*/DUMP(Cmd->Subcommands, SpacePad + 2);
        return;
    }

    case C_BLOCK:
    {
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutChar(_T('('));
#else
        ConOutPuts(_T("( "));
#endif
        DumpRedir(Cmd->Redirections);
        ConOutChar(_T('\n'));

        SpacePad += 2;

        for (Sub = Cmd->Subcommands; Sub; Sub = Sub->Next)
        {
#if defined(MSCMD_ECHO_COMMAND_COMPAT) && defined(MSCMD_PARSER_BUGS)
            /*
             * We will emulate Windows' CMD handling of "CRLF" and "&" multi-command
             * enumeration within parenthesized command blocks.
             */

            if (!Sub->Next)
            {
                DumpCommand(Sub, SpacePad);
                continue;
            }

            if (Sub->Type != C_MULTI)
            {
                ConOutPrintf(_T("%*s"), SpacePad, _T(""));
                ConOutPuts(_T("CRLF \n"));
                DumpCommand(Sub, SpacePad);
                continue;
            }

            /* Now, Sub->Type == C_MULTI */

            Cmd = Sub;

            ConOutPrintf(_T("%*s"), SpacePad, _T(""));
            ConOutPrintf(_T("%s \n"), OpString[Cmd->Type - C_OP_LOWEST]);
            // FIXME: Can we have redirections on these operator-type commands?

            SpacePad += 2;

            Cmd = Cmd->Subcommands;
            DumpCommand(Cmd, SpacePad);
            ConOutPrintf(_T("%*s"), SpacePad, _T(""));
            ConOutPuts(_T("CRLF \n"));
            DumpCommand(Cmd->Next, SpacePad);

            // NOTE: Next commands will remain indented.

#else

            /*
             * If this command is followed by another one, first display "CRLF".
             * This also emulates the CRLF placement "bug" of Windows' CMD
             * for the last two commands.
             */
            if (Sub->Next)
            {
                ConOutPrintf(_T("%*s"), SpacePad, _T(""));
#ifndef MSCMD_ECHO_COMMAND_COMPAT
                ConOutPuts(_T("CRLF\n"));
#else
                ConOutPuts(_T("CRLF \n"));
#endif
            }
            DumpCommand(Sub, SpacePad);

#endif // defined(MSCMD_ECHO_COMMAND_COMPAT) && defined(MSCMD_PARSER_BUGS)
        }

        return;
    }

    case C_MULTI:
    case C_OR:
    case C_AND:
    case C_PIPE:
    {
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutPrintf(_T("%s\n"), OpString[Cmd->Type - C_OP_LOWEST]);
#else
        ConOutPrintf(_T("%s \n"), OpString[Cmd->Type - C_OP_LOWEST]);
#endif
        // FIXME: Can we have redirections on these operator-type commands?

        SpacePad += 2;

        Sub = Cmd->Subcommands;
        DumpCommand(Sub, SpacePad);
        /*DumpCommand*/DUMP(Sub->Next, SpacePad);
        return;
    }

    case C_FOR:
    {
        ConOutPuts(_T("for"));
        /* NOTE: FOR cannot have leading redirections */

        if (Cmd->For.Switches & FOR_DIRS)      ConOutPuts(_T(" /D"));
        if (Cmd->For.Switches & FOR_F)         ConOutPuts(_T(" /F"));
        if (Cmd->For.Switches & FOR_LOOP)      ConOutPuts(_T(" /L"));
        if (Cmd->For.Switches & FOR_RECURSIVE) ConOutPuts(_T(" /R"));
        if (Cmd->For.Params)
            ConOutPrintf(_T(" %s"), Cmd->For.Params);
        ConOutPrintf(_T(" %%%c in (%s) do\n"), Cmd->For.Variable, Cmd->For.List);
        /*DumpCommand*/DUMP(Cmd->Subcommands, SpacePad + 2);
        return;
    }

    case C_IF:
    {
        ConOutPuts(_T("if"));
        /* NOTE: IF cannot have leading redirections */

        if (Cmd->If.Flags & IFFLAG_IGNORECASE)
            ConOutPuts(_T(" /I"));

        ConOutChar(_T('\n'));

        SpacePad += 2;

        /*
         * Show the IF command condition as a command.
         * If it is negated, indent the command more.
         */
        if (Cmd->If.Flags & IFFLAG_NEGATE)
        {
            ConOutPrintf(_T("%*s"), SpacePad, _T(""));
            ConOutPuts(_T("not\n"));
            SpacePad += 2;
        }

        ConOutPrintf(_T("%*s"), SpacePad, _T(""));

        /*
         * Command name:
         * - Unary operator: its name is the command name, and its argument is the command argument.
         * - Binary operator: its LHS is the command name, its RHS is the command argument.
         *
         * Type:
         * Windows' CMD (Win2k3 / Win7-10) values are as follows:
         *   CMDEXTVERSION  Type: 0x32 / 0x34
         *   ERRORLEVEL     Type: 0x33 / 0x35
         *   DEFINED        Type: 0x34 / 0x36
         *   EXIST          Type: 0x35 / 0x37
         *   ==             Type: 0x37 / 0x39 (String Comparison)
         *
         * For the following command:
         *   NOT            Type: 0x36 / 0x38
         * Windows only prints it without any type / redirection.
         *
         * For the following command:
         *   EQU, NEQ, etc. Type: 0x38 / 0x3a (Generic Comparison)
         * Windows displays it as command of unknown type.
         */
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutPrintf(_T("Cmd: %s  Type: %x"),
                     (Cmd->If.Operator <= IF_MAX_UNARY) ?
                        IfOperatorString[Cmd->If.Operator] :
                        Cmd->If.LeftArg,
                     Cmd->If.Operator);
#else
        ConOutPrintf(_T("Cmd: %s  Type: %x "),
                     (Cmd->If.Operator <= IF_MAX_UNARY) ?
                        IfOperatorString[Cmd->If.Operator] :
                        Cmd->If.LeftArg,
                     Cmd->If.Operator);
#endif
        /* Arguments */
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutPrintf(_T(" Args: `%s'"), Cmd->If.RightArg);
#else
        ConOutPrintf(_T("Args: `%s' "), Cmd->If.RightArg);
#endif

        ConOutChar(_T('\n'));

        if (Cmd->If.Flags & IFFLAG_NEGATE)
        {
            SpacePad -= 2;
        }

        Sub = Cmd->Subcommands;
        DumpCommand(Sub, SpacePad);
        if (Sub->Next)
        {
            ConOutPrintf(_T("%*s"), SpacePad - 2, _T(""));
            ConOutPuts(_T("else\n"));
            DumpCommand(Sub->Next, SpacePad);
        }
        return;
    }

    default:
        ConOutPrintf(_T("*** Unknown type: %x\n"), Cmd->Type);
        break;
    }

#undef DUMP
}

Referenced by ParseCommand().

DumpRedir()

static VOID DumpRedir ( IN REDIRECTION *  Redirections )

static

Definition at line 1514 of file parser.c.

{
    REDIRECTION* Redir;

    if (Redirections)
#ifndef MSCMD_ECHO_COMMAND_COMPAT
        ConOutPuts(_T(" Redir: "));
#else
        ConOutPuts(_T("Redir: "));
#endif
    for (Redir = Redirections; Redir; Redir = Redir->Next)
    {
        ConOutPrintf(_T(" %x %s%s"), Redir->Number,
                     RedirString[Redir->Mode], Redir->Filename);
    }
}

Referenced by DumpCommand().

EchoCommand()

VOID EchoCommand

(

IN PARSED_COMMAND *

Cmd

)

Definition at line 1808 of file parser.c.

{
    PARSED_COMMAND* Sub;
    REDIRECTION* Redir;

    if (!Cmd)
        return;

    switch (Cmd->Type)
    {
    case C_COMMAND:
    case C_REM:
    {
        if (SubstituteForVars(Cmd->Command.First, TempBuf))
            ConOutPrintf(_T("%s"), TempBuf);
        if (SubstituteForVars(Cmd->Command.Rest, TempBuf))
        {
            ConOutPrintf(_T("%s"), TempBuf);
#ifdef MSCMD_ECHO_COMMAND_COMPAT
            /* NOTE: For Windows compatibility, add a trailing space after printing the command parameter, if present */
            if (*TempBuf) ConOutChar(_T(' '));
#endif
        }
        break;
    }

    case C_QUIET:
        return;

    case C_BLOCK:
    {
        BOOLEAN bIsFirstCmdCRLF;

        ConOutChar(_T('('));

        Sub = Cmd->Subcommands;

        bIsFirstCmdCRLF = (Sub && Sub->Next);

#if defined(MSCMD_ECHO_COMMAND_COMPAT) && defined(MSCMD_PARSER_BUGS)
        /*
         * We will emulate Windows' CMD handling of "CRLF" and "&" multi-command
         * enumeration within parenthesized command blocks.
         */
        bIsFirstCmdCRLF = bIsFirstCmdCRLF && (Sub->Type != C_MULTI);
#endif

        /*
         * Single-command block: display all on one line.
         * Multi-command block: display commands on separate lines.
         */
        if (bIsFirstCmdCRLF)
            ConOutChar(_T('\n'));

        for (; Sub; Sub = Sub->Next)
        {
            EchoCommand(Sub);
            if (Sub->Next)
#ifdef MSCMD_ECHO_COMMAND_COMPAT
                ConOutPuts(_T(" \n "));
#else
                ConOutChar(_T('\n'));
#endif
        }

        if (bIsFirstCmdCRLF)
            ConOutChar(_T('\n'));

#ifdef MSCMD_ECHO_COMMAND_COMPAT
        /* NOTE: For Windows compatibility, add a trailing space after printing the closing parenthesis */
        ConOutPuts(_T(") "));
#else
        ConOutChar(_T(')'));
#endif
        break;
    }

    case C_MULTI:
    case C_OR:
    case C_AND:
    case C_PIPE:
    {
        Sub = Cmd->Subcommands;
        EchoCommand(Sub);
        ConOutPrintf(_T(" %s "), OpString[Cmd->Type - C_OP_LOWEST]);
        EchoCommand(Sub->Next);
        break;
    }

    case C_FOR:
    {
        ConOutPuts(_T("for"));
        if (Cmd->For.Switches & FOR_DIRS)      ConOutPuts(_T(" /D"));
        if (Cmd->For.Switches & FOR_F)         ConOutPuts(_T(" /F"));
        if (Cmd->For.Switches & FOR_LOOP)      ConOutPuts(_T(" /L"));
        if (Cmd->For.Switches & FOR_RECURSIVE) ConOutPuts(_T(" /R"));
        if (Cmd->For.Params)
            ConOutPrintf(_T(" %s"), Cmd->For.Params);
        if (Cmd->For.List && SubstituteForVars(Cmd->For.List, TempBuf))
            ConOutPrintf(_T(" %%%c in (%s) do "), Cmd->For.Variable, TempBuf);
        else
            ConOutPrintf(_T(" %%%c in (%s) do "), Cmd->For.Variable, Cmd->For.List);
        EchoCommand(Cmd->Subcommands);
        break;
    }

    case C_IF:
    {
        ConOutPuts(_T("if"));
        if (Cmd->If.Flags & IFFLAG_IGNORECASE)
            ConOutPuts(_T(" /I"));
        if (Cmd->If.Flags & IFFLAG_NEGATE)
            ConOutPuts(_T(" not"));
        if (Cmd->If.LeftArg && SubstituteForVars(Cmd->If.LeftArg, TempBuf))
            ConOutPrintf(_T(" %s"), TempBuf);
        ConOutPrintf(_T(" %s"), IfOperatorString[Cmd->If.Operator]);
        if (SubstituteForVars(Cmd->If.RightArg, TempBuf))
            ConOutPrintf(_T(" %s "), TempBuf);
        Sub = Cmd->Subcommands;
        EchoCommand(Sub);
        if (Sub->Next)
        {
            ConOutPuts(_T(" else "));
            EchoCommand(Sub->Next);
        }
        break;
    }

    default:
        ASSERT(FALSE);
        break;
    }

    for (Redir = Cmd->Redirections; Redir; Redir = Redir->Next)
    {
        if (SubstituteForVars(Redir->Filename, TempBuf))
        {
#ifdef MSCMD_ECHO_COMMAND_COMPAT
            ConOutPrintf(_T("%c%s%s "),
                         _T('0') + Redir->Number,
                         RedirString[Redir->Mode], TempBuf);
#else
            ConOutPrintf(_T(" %c%s%s"),
                         _T('0') + Redir->Number,
                         RedirString[Redir->Mode], TempBuf);
#endif
        }
    }
}

Referenced by ExecuteCommandWithEcho().

FreeCommand()

VOID FreeCommand

(

IN OUT PARSED_COMMAND *

Cmd

)

Definition at line 527 of file parser.c.

{
    if (Cmd->Subcommands)
        FreeCommand(Cmd->Subcommands);
    if (Cmd->Next)
        FreeCommand(Cmd->Next);
    FreeRedirection(Cmd->Redirections);
    if (Cmd->Type == C_FOR)
    {
        cmd_free(Cmd->For.Params);
        cmd_free(Cmd->For.List);
    }
    else if (Cmd->Type == C_IF)
    {
        cmd_free(Cmd->If.LeftArg);
        cmd_free(Cmd->If.RightArg);
    }
    cmd_free(Cmd);
}

Referenced by Batch(), cmd_call(), ParseBlock(), ParseCommand(), ParseCommandBinaryOp(), ParseCommandLine(), ParseFor(), ParseIf(), and ProcessInput().

InitParser()

static VOID InitParser ( VOID  )

static

Definition at line 173 of file parser.c.

{
    *CurrentToken = 0;
    CurrentTokenType = TOK_END;
    InsideBlock = 0;

#ifndef MSCMD_PARSER_BUGS
    bReparseToken = FALSE;
    LastCurTokPos = NULL;
#endif

    ResetParser(ParseLine);
}

Referenced by ParseCommand().

IsSeparator()

static __inline BOOL IsSeparator ( TCHAR  Char )

static

Definition at line 72 of file parser.c.

{
    return _istspace(Char) || (Char && !!_tcschr(STANDARD_SEPS, Char));
}

Referenced by ParseTokenEx().

ParseBlock()

static PARSED_COMMAND* ParseBlock ( IN OUT REDIRECTION **  RedirList )

static

Definition at line 649 of file parser.c.

{
    PARSED_COMMAND *Cmd, *Sub, **NextPtr;

    Cmd = AllocCommand(C_BLOCK, NULL, NULL);
    if (!Cmd)
    {
        WARN("Cannot allocate memory for Cmd!\n");
        ParseError();
        return NULL;
    }

    /* Read the block contents */
    NextPtr = &Cmd->Subcommands;
    ++InsideBlock;
    while (TRUE)
    {
        /*
         * Windows' CMD compatibility: Strip leading newlines in the block.
         *
         * Note that this behaviour is buggy, especially when MSCMD_PARSER_BUGS is defined!
         * For example:
         *   (foo^\n
         *   bar)
         * would be parsed ultimately as: '(', 'bar', ')' because the "foo^"
         * part would be discarded due to the UnParseToken() call, since this
         * function doesn't work across line continuations.
         */
        while (ParseToken(0, STANDARD_SEPS) == TOK_END && *CurrentToken == _T('\n'))
            ;
        if (*CurrentToken && *CurrentToken != _T('\n'))
            UnParseToken();

        /* Break early if we have nothing else to read. We will also fail
         * due to the fact we haven't encountered any closing parenthesis. */
        if (!*CurrentToken /* || *CurrentToken == _T('\n') */)
        {
            ASSERT(CurrentTokenType == TOK_END);
            break;
        }

        /*
         * NOTE: Windows' CMD uses a "CRLF" operator when dealing with
         * newlines in parenthesized blocks, as an alternative to the
         * '&' command-separation operator.
         */

        Sub = ParseCommandOp(C_OP_LOWEST);
        if (Sub)
        {
            *NextPtr = Sub;
            NextPtr = &Sub->Next;
        }
        else if (bParseError)
        {
            --InsideBlock;
            FreeCommand(Cmd);
            return NULL;
        }

        if (CurrentTokenType == TOK_END_BLOCK)
            break;

        /* Skip past the \n */
    }
    --InsideBlock;

    /* Fail if the block was not terminated, or if we have
     * an empty block, i.e. "( )", considered invalid. */
    if ((CurrentTokenType != TOK_END_BLOCK) || (Cmd->Subcommands == NULL))
    {
        ParseError();
        FreeCommand(Cmd);
        return NULL;
    }

    /* Process any trailing redirections and append them to the list */
#ifndef MSCMD_REDIR_PARSE_BUGS
    while (ParseToken(0, STANDARD_SEPS) == TOK_REDIRECTION)
    {
        if (!ParseRedirection(RedirList))
        {
            FreeCommand(Cmd);
            return NULL;
        }
    }
#else
    while (ParseToken(0, STANDARD_SEPS) != TOK_END)
    {
        if (!ParseRedirection(RedirList))
        {
            /* If an actual error happened in ParseRedirection(), bail out */
            if (bParseError)
            {
                FreeCommand(Cmd);
                return NULL;
            }
            /* Otherwise it just returned FALSE because the current token
             * is not a redirection. Unparse the token and refetch it. */
            break;
        }
    }
#endif
    if (CurrentTokenType != TOK_END)
    {
        /*
         * Windows' CMD compatibility: Unparse the current token.
         *
         * Note that this behaviour is buggy, especially when MSCMD_PARSER_BUGS is defined!
         * For example:
         *   (foo^\n
         *   bar)
         * would be parsed ultimately as: '(', 'bar', ')' because the "foo^"
         * part would be discarded due to the UnParseToken() call, since this
         * function doesn't work across line continuations.
         */
        UnParseToken();

        /*
         * Since it is expected that when ParseBlock() returns, the next
         * token is already fetched, call ParseToken() again to compensate.
         */
        ParseToken(0, STANDARD_SEPS);
    }

    return Cmd;
}

Referenced by ParsePrimary().

ParseChar()

static TCHAR ParseChar ( VOID  )

static

Definition at line 187 of file parser.c.

{
    TCHAR Char;

    if (bParseError)
        return 0;

restart:
    /*
     * Although CRs can be injected into a line via an environment
     * variable substitution, the parser ignores them - they won't
     * even separate tokens.
     */
    do
    {
        Char = *ParsePos++;
    }
    while (Char == _T('\r'));

    if (!Char) --ParsePos;
    if (!Char && bLineContinuations)
    {
        if (!ReadLine(ParseLine, TRUE))
        {
            /* ^C pressed, or line was too long */
            //
            // FIXME: Distinguish with respect to BATCH end of file !!
            //
            bParseError = TRUE;
        }
        else
        {
            ResetParser(ParseLine);
            if (*ParsePos)
                goto restart;
        }
    }
    return Char;
}

Referenced by ParseTokenEx().

ParseCommand()

PARSED_COMMAND* ParseCommand

(

IN PCTSTR

Line

)

Definition at line 1461 of file parser.c.

{
    PARSED_COMMAND* Cmd;

    if (Line)
    {
        if (!SubstituteVars(Line, ParseLine, _T('%')))
            return NULL;
        bLineContinuations = FALSE;
    }
    else
    {
        if (!ReadLine(ParseLine, FALSE))
            return NULL;
        bLineContinuations = TRUE;
    }

    InitParser();

    Cmd = ParseCommandOp(C_OP_LOWEST);
    if (Cmd)
    {
        bIgnoreEcho = FALSE;

        if ((CurrentTokenType != TOK_END) &&
            (_tcscmp(CurrentToken, _T("\n")) != 0))
        {
            ParseError();
        }
        if (bParseError)
        {
            FreeCommand(Cmd);
            return NULL;
        }

        /* Debugging support */
        if (fDumpParse)
            DumpCommand(Cmd, 0);
    }
    else
    {
        bIgnoreEcho = TRUE;
    }
    return Cmd;
}

Referenced by Batch(), cmd_call(), ParseCommandLine(), and ProcessInput().

ParseCommandBinaryOp()

static PARSED_COMMAND* ParseCommandBinaryOp ( IN COMMAND_TYPE  OpType )

static

bc &&

Definition at line 1295 of file parser.c.

{
    PARSED_COMMAND* Cmd;

    if (OpType == C_OP_LOWEST) // i.e. CP_MULTI
    {
        /* Ignore any parser-level comments */
        if (bIgnoreParserComments && (*CurrentToken == _T(':')))
        {
            /* Ignore the rest of the line, including line continuations */
            while (ParseToken(0, NULL) != TOK_END)
                ;
#ifdef MSCMD_PARENS_PARSE_BUGS
            /*
             * Return NULL in case we are NOT inside a parenthesized block,
             * otherwise continue. The effects can be observed as follows:
             * within a parenthesized block, every second ':'-prefixed command
             * is not ignored, while the first of each "pair" is ignored.
             * This first command **MUST NOT** be followed by an empty line,
             * otherwise a syntax error is raised.
             */
            if (InsideBlock == 0)
            {
#endif
                return NULL;
#ifdef MSCMD_PARENS_PARSE_BUGS
            }
            /* Get the next token */
            ParseToken(0, NULL);
#endif
        }

        /*
         * Ignore single closing parenthesis outside of command blocks,
         * thus interpreted as a command. This very specific situation
         * can happen e.g. while running in batch mode, when jumping to
         * a label present inside a command block.
         *
         * NOTE: If necessary, this condition can be restricted to only
         * when a batch context 'bc' is active.
         *
         * NOTE 2: For further security, Windows checks that we are NOT
         * currently inside a parenthesized block, and also, ignores
         * explicitly everything (ParseToken() loop) on the same line
         * (including line continuations) after this closing parenthesis.
         *
         * Why doing so? Consider the following batch:
         *
         *   IF 1==1 (
         *   :label
         *       echo A
         *   ) ^
         *   ELSE (
         *       echo B
         *       exit /b
         *   )
         *   GOTO :label
         *
         * First the IF block is executed. Since the condition is trivially
         * true, only the first block "echo A" is executed, then execution
         * goes after the IF block, that is, at the GOTO. Here, the GOTO
         * jumps within the first IF-block, however, the running context now
         * is NOT an IF. So parsing and execution will go through each command,
         * starting with 'echo A'. But then one gets the ') ^\n ELSE (' part !!
         * If we want to make sense of this without bailing out due to
         * parsing error, we should ignore this line, **including** the line
         * continuation. Hence we need to loop over all the tokens following
         * the closing parenthesis, instead of just returning NULL straight ahead.
         * Then execution continues with the other commands, 'echo B' and
         * 'exit /b' (here to stop the code loop). Execution would also
         * continue (if 'exit' was replaced by something else) and encounter
         * the lone closing parenthesis ')', that should again be ignored.
         *
         * Note that this feature has been introduced in Win2k+.
         */
        if ( (_tcscmp(CurrentToken, _T(")")) == 0) &&
            (CurrentTokenType != TOK_END_BLOCK))
        {
            ASSERT(InsideBlock == 0);

            /* Ignore the rest of the line, including line continuations */
            while (ParseToken(0, NULL) != TOK_END)
                ;
            return NULL;
        }

#ifdef MSCMD_PARENS_PARSE_BUGS
        /* Check whether we have an empty line only if we are not inside
         * a parenthesized block, and return NULL if so, otherwise do not
         * do anything; a syntax error will be raised later. */
        if (InsideBlock == 0)
#endif
        if (!*CurrentToken || *CurrentToken == _T('\n'))
        {
            ASSERT(CurrentTokenType == TOK_END);
            return NULL;
        }
    }

    if (OpType == C_OP_HIGHEST)
        Cmd = ParsePrimary();
    else
        Cmd = ParseCommandBinaryOp(OpType + 1);

    if (Cmd && !_tcscmp(CurrentToken, OpString[OpType - C_OP_LOWEST]))
    {
        PARSED_COMMAND* Left = Cmd;
        PARSED_COMMAND* Right;

        Right = ParseCommandOp(OpType);
        if (!Right)
        {
            /*
             * The '&' operator is allowed to have an empty RHS.
             * In this case, we directly return the LHS only.
             * Note that Windows' CMD prefers building a '&'
             * command with an empty RHS.
             */
            if (!bParseError && (OpType != C_MULTI))
                ParseError();
            if (bParseError)
            {
                FreeCommand(Left);
                return NULL;
            }

#ifndef MSCMD_MULTI_EMPTY_RHS
            return Left;
#endif
        }

        Cmd = AllocCommand(OpType, NULL, NULL);
        if (!Cmd)
        {
            WARN("Cannot allocate memory for Cmd!\n");
            ParseError();
            FreeCommand(Left);
            FreeCommand(Right);
            return NULL;
        }
        Cmd->Subcommands = Left;
        Left->Next = Right;
#ifdef MSCMD_MULTI_EMPTY_RHS
        if (Right)
#endif
        Right->Next = NULL;
    }

    return Cmd;
}

Referenced by ParseCommandOp().

ParseCommandOp()

static __inline PARSED_COMMAND * ParseCommandOp ( IN COMMAND_TYPE  OpType )

static

Definition at line 1447 of file parser.c.

{
    /* Start parsing: initialize the first token */

    /* Parse the prefix "quiet" operator '@' as a separate command.
     * Thus, @@foo@bar is parsed as: '@', '@', 'foo@bar'. */
    ParseTokenEx(_T('@'), _T('('), STANDARD_SEPS, bHandleContinuations);

    return ParseCommandBinaryOp(OpType);
}

Referenced by ParseBlock(), ParseCommand(), ParseCommandBinaryOp(), ParseFor(), ParseIf(), and ParsePrimary().

ParseCommandPart()

static PARSED_COMMAND* ParseCommandPart ( IN OUT REDIRECTION **  RedirList )

static

Definition at line 1051 of file parser.c.

{
    PARSED_COMMAND* Cmd;
    PARSED_COMMAND* (*Func)(VOID);

    /* Use the scratch buffer */
    PTSTR ParsedLine = TempBuf;

    /* We need to copy the current token because it's going to be changed below by the ParseToken() calls */
    PTCHAR Pos = _stpcpy(ParsedLine, CurrentToken) + 1;
    SIZE_T TailOffset = Pos - ParsedLine;

    /* Check for special forms */
    if ((Func = ParseFor, _tcsicmp(ParsedLine, _T("FOR")) == 0) ||
        (Func = ParseIf,  _tcsicmp(ParsedLine, _T("IF"))  == 0) ||
        (Func = ParseRem, _tcsicmp(ParsedLine, _T("REM")) == 0))
    {
        PTCHAR pHelp;

        ParseToken(0, STANDARD_SEPS);

        if ((pHelp = _tcsstr(CurrentToken, _T("/?"))) &&
            (Func == ParseIf ? (pHelp[2] == _T('/') || pHelp[2] == 0) : TRUE))
        {
            /* /? was found within the first token */
            ParseToken(0, STANDARD_SEPS);
        }
        else
        {
            pHelp = NULL;
        }
        if (pHelp && (CurrentTokenType == TOK_NORMAL))
        {
            /* We encountered /? first, but is followed
             * by another token: that's an error. */
            ParseError();
            return NULL;
        }

        /* Do actual parsing only if no help is present */
        if (!pHelp)
        {
            /* FOR and IF commands cannot have leading redirection, but REM can */
            if (*RedirList && ((Func == ParseFor) || (Func == ParseIf)))
            {
                /* Display the culprit command and fail */
                ParseErrorEx(ParsedLine);
                return NULL;
            }

            return Func();
        }

        /* Otherwise, run FOR,IF,REM as regular commands only for help support */
        if (Pos + _tcslen(_T("/?")) >= &ParsedLine[CMDLINE_LENGTH])
        {
            ParseError();
            return NULL;
        }
        Pos = _stpcpy(Pos, _T("/?"));
    }
    else
    {
        ParseToken(0, NULL);
    }

    /* Now get the tail */
    while (CurrentTokenType != TOK_END)
    {
        if (CurrentTokenType == TOK_NORMAL)
        {
            if (Pos + _tcslen(CurrentToken) >= &ParsedLine[CMDLINE_LENGTH])
            {
                ParseError();
                return NULL;
            }
            Pos = _stpcpy(Pos, CurrentToken);
        }
#ifndef MSCMD_REDIR_PARSE_BUGS
        else if (CurrentTokenType == TOK_REDIRECTION)
        {
            /* Process any trailing redirections and append them to the list */
            while (CurrentTokenType == TOK_REDIRECTION)
            {
                if (!ParseRedirection(RedirList))
                    return NULL;

                ParseToken(0, STANDARD_SEPS);
            }
            if (CurrentTokenType == TOK_END)
                break;

            /* Unparse the current token, and reparse it below with no separators */
            UnParseToken();
        }
        else
        {
            /* There is no need to do a UnParseToken() / ParseToken() cycle */
            break;
        }
#else
        else
        {
            /* Process any trailing redirections and append them to the list */
            BOOL bSuccess = FALSE;

            ASSERT(CurrentTokenType != TOK_END);

            while (CurrentTokenType != TOK_END)
            {
                if (!ParseRedirection(RedirList))
                {
                    /* If an actual error happened in ParseRedirection(), bail out */
                    if (bParseError)
                        return NULL;

                    /* Otherwise it just returned FALSE because the current token
                     * is not a redirection. Unparse the token and refetch it. */
                    break;
                }
                bSuccess = TRUE;

                ParseToken(0, STANDARD_SEPS);
            }
            if (CurrentTokenType == TOK_END)
                break;

            /* Unparse the current token, and reparse it below with no separators */
            UnParseToken();

            /* If bSuccess == FALSE, we know that it's still the old fetched token, but
             * it has been unparsed, so we need to refetch it before quitting the loop. */
            if (!bSuccess)
            {
                ParseToken(0, NULL);
                break;
            }
        }
#endif

        ParseToken(0, NULL);
    }
    *Pos = _T('\0');

    Cmd = AllocCommand(C_COMMAND,
                       ParsedLine,
                       ParsedLine + TailOffset);
    if (!Cmd)
    {
        WARN("Cannot allocate memory for Cmd!\n");
        ParseError();
        return NULL;
    }
    return Cmd;
}

Referenced by ParsePrimary().

ParseError()

static __inline VOID ParseError ( VOID  )

static

Definition at line 235 of file parser.c.

{
    ParseErrorEx(CurrentTokenType != TOK_END ? CurrentToken : NULL);
}

Referenced by ParseBlock(), ParseCommand(), ParseCommandBinaryOp(), ParseCommandPart(), ParseFor(), ParseIf(), ParsePrimary(), ParseRedirection(), and ParseRem().

ParseErrorEx()

VOID ParseErrorEx

(

IN PCTSTR

s

)

Definition at line 227 of file parser.c.

{
    /* Only display the first error we encounter */
    if (!bParseError)
        error_syntax(s);
    bParseError = TRUE;
}

Referenced by cmd_for(), cmd_if(), GetBatchVar(), ParseCommandPart(), and ParseError().

ParseFor()

static PARSED_COMMAND* ParseFor ( VOID  )

static

Definition at line 875 of file parser.c.

{
    PARSED_COMMAND* Cmd;

    /* Use the scratch buffer */
    PTSTR List = TempBuf;
    PTCHAR Pos = List;

    Cmd = AllocCommand(C_FOR, NULL, NULL);
    if (!Cmd)
    {
        WARN("Cannot allocate memory for Cmd!\n");
        ParseError();
        return NULL;
    }

    /* Skip the extended FOR syntax if extensions are disabled */
    if (!bEnableExtensions)
        goto parseForBody;

    while (TRUE)
    {
        if (_tcsicmp(CurrentToken, _T("/D")) == 0)
        {
            Cmd->For.Switches |= FOR_DIRS;
        }
        else if (_tcsicmp(CurrentToken, _T("/F")) == 0)
        {
            Cmd->For.Switches |= FOR_F;
            if (!Cmd->For.Params)
            {
                ParseToken(0, STANDARD_SEPS);
                if (CurrentToken[0] == _T('/') || CurrentToken[0] == _T('%'))
                    break;
                Cmd->For.Params = cmd_dup(CurrentToken);
            }
        }
        else if (_tcsicmp(CurrentToken, _T("/L")) == 0)
        {
            Cmd->For.Switches |= FOR_LOOP;
        }
        else if (_tcsicmp(CurrentToken, _T("/R")) == 0)
        {
            Cmd->For.Switches |= FOR_RECURSIVE;
            if (!Cmd->For.Params)
            {
                ParseToken(0, STANDARD_SEPS);
                if (CurrentToken[0] == _T('/') || CurrentToken[0] == _T('%'))
                    break;
                StripQuotes(CurrentToken);
                Cmd->For.Params = cmd_dup(CurrentToken);
            }
        }
        else
        {
            break;
        }

        ParseToken(0, STANDARD_SEPS);
    }

    /* Make sure there aren't two different switches specified
     * at the same time, unless they're /D and /R */
    if ((Cmd->For.Switches & (Cmd->For.Switches - 1)) != 0
        && Cmd->For.Switches != (FOR_DIRS | FOR_RECURSIVE))
    {
        goto error;
    }

parseForBody:

    /* Variable name should be % and just one other character */
    if (CurrentToken[0] != _T('%') || _tcslen(CurrentToken) != 2)
        goto error;
    Cmd->For.Variable = CurrentToken[1];

    ParseToken(0, STANDARD_SEPS);
    if (_tcsicmp(CurrentToken, _T("in")) != 0)
        goto error;

    if (ParseToken(_T('('), STANDARD_SEPS) != TOK_BEGIN_BLOCK)
        goto error;

    while (TRUE)
    {
        /* Pretend we're inside a block so the tokenizer will stop on ')' */
        ++InsideBlock;
        ParseToken(0, STANDARD_SEPS);
        --InsideBlock;

        if (CurrentTokenType == TOK_END_BLOCK)
            break;

        /* Skip past the \n */
        if ((CurrentTokenType == TOK_END) && *CurrentToken == _T('\n'))
            continue;

        if (CurrentTokenType != TOK_NORMAL)
            goto error;

        if (Pos != List)
            *Pos++ = _T(' ');

        if (Pos + _tcslen(CurrentToken) >= &List[CMDLINE_LENGTH])
            goto error;
        Pos = _stpcpy(Pos, CurrentToken);
    }
    *Pos = _T('\0');
    Cmd->For.List = cmd_dup(List);

    ParseToken(0, STANDARD_SEPS);
    if (_tcsicmp(CurrentToken, _T("do")) != 0)
        goto error;

    Cmd->Subcommands = ParseCommandOp(C_OP_LOWEST);
    if (Cmd->Subcommands == NULL)
        goto error;

    return Cmd;

error:
    FreeCommand(Cmd);
    ParseError();
    return NULL;
}

Referenced by ParseCommandPart().

ParseIf()

static PARSED_COMMAND* ParseIf ( VOID  )

static

Definition at line 780 of file parser.c.

{
    PARSED_COMMAND* Cmd;

    Cmd = AllocCommand(C_IF, NULL, NULL);
    if (!Cmd)
    {
        WARN("Cannot allocate memory for Cmd!\n");
        ParseError();
        return NULL;
    }

    if (bEnableExtensions && (_tcsicmp(CurrentToken, _T("/I")) == 0))
    {
        Cmd->If.Flags |= IFFLAG_IGNORECASE;
        ParseToken(0, STANDARD_SEPS);
    }
    if (_tcsicmp(CurrentToken, _T("not")) == 0)
    {
        Cmd->If.Flags |= IFFLAG_NEGATE;
        ParseToken(0, STANDARD_SEPS);
    }

    if (CurrentTokenType != TOK_NORMAL)
        goto error;

    /* Check for unary operators */
    for (; Cmd->If.Operator <= IF_MAX_UNARY; Cmd->If.Operator++)
    {
        /* Skip the extended operators if the extensions are disabled */
        if (!bEnableExtensions && (Cmd->If.Operator >= IF_CMDEXTVERSION))
            continue;

        if (_tcsicmp(CurrentToken, IfOperatorString[Cmd->If.Operator]) == 0)
        {
            if (ParseToken(0, STANDARD_SEPS) != TOK_NORMAL)
                goto error;
            Cmd->If.RightArg = cmd_dup(CurrentToken);
            goto condition_done;
        }
    }

    /* It must be a two-argument (comparison) operator. It could be ==, so
     * the equals sign can't be treated as whitespace here. */
    Cmd->If.LeftArg = cmd_dup(CurrentToken);
    ParseToken(0, _T(",;"));

    /* The right argument can come immediately after == */
    if (_tcsnicmp(CurrentToken, _T("=="), 2) == 0 && CurrentToken[2])
    {
        Cmd->If.RightArg = cmd_dup(&CurrentToken[2]);
        goto condition_done;
    }

    // Cmd->If.Operator == IF_MAX_UNARY + 1;
    for (; Cmd->If.Operator <= IF_MAX_COMPARISON; Cmd->If.Operator++)
    {
        /* Skip the extended operators if the extensions are disabled */
        if (!bEnableExtensions && (Cmd->If.Operator >= IF_EQU)) // (Cmd->If.Operator > IF_STRINGEQ)
            continue;

        if (_tcsicmp(CurrentToken, IfOperatorString[Cmd->If.Operator]) == 0)
        {
            if (ParseToken(0, STANDARD_SEPS) != TOK_NORMAL)
                goto error;
            Cmd->If.RightArg = cmd_dup(CurrentToken);
            goto condition_done;
        }
    }
    goto error;

condition_done:
    Cmd->Subcommands = ParseCommandOp(C_OP_LOWEST);
    if (Cmd->Subcommands == NULL)
        goto error;
    if (_tcsicmp(CurrentToken, _T("else")) == 0)
    {
        Cmd->Subcommands->Next = ParseCommandOp(C_OP_LOWEST);
        if (Cmd->Subcommands->Next == NULL)
            goto error;
    }

    return Cmd;

error:
    FreeCommand(Cmd);
    ParseError();
    return NULL;
}

Referenced by ParseCommandPart().

ParsePrimary()

static PARSED_COMMAND* ParsePrimary ( VOID  )

static

Definition at line 1209 of file parser.c.

{
    PARSED_COMMAND* Cmd = NULL;
    REDIRECTION* RedirList = NULL;

    /* In this context, '@' is considered as a separate token */
    if ((*CurrentToken == _T('@')) && (CurrentTokenType == TOK_OPERATOR))
    {
        Cmd = AllocCommand(C_QUIET, NULL, NULL);
        if (!Cmd)
        {
            WARN("Cannot allocate memory for Cmd!\n");
            ParseError();
            return NULL;
        }
        /* @ acts like a unary operator with low precedence,
         * so call the top-level parser */
        Cmd->Subcommands = ParseCommandOp(C_OP_LOWEST);
        return Cmd;
    }

    /* Process leading redirections and get the head of the command */
#ifndef MSCMD_REDIR_PARSE_BUGS
    while (CurrentTokenType == TOK_REDIRECTION)
    {
        if (!ParseRedirection(&RedirList))
            return NULL;

        ParseToken(_T('('), STANDARD_SEPS);
    }
#else
    {
    BOOL bSuccess = FALSE;
    while (CurrentTokenType != TOK_END)
    {
        if (!ParseRedirection(&RedirList))
        {
            /* If an actual error happened in ParseRedirection(), bail out */
            if (bParseError)
                return NULL;

            /* Otherwise it just returned FALSE because
             * the current token is not a redirection. */
            break;
        }
        bSuccess = TRUE;

        ParseToken(0, STANDARD_SEPS);
    }
    if (bSuccess)
    {
        /* Unparse the current token, and reparse it with support for parenthesis */
        if (CurrentTokenType != TOK_END)
            UnParseToken();

        ParseToken(_T('('), STANDARD_SEPS);
    }
    }
#endif

    if (CurrentTokenType == TOK_NORMAL)
        Cmd = ParseCommandPart(&RedirList);
    else if (CurrentTokenType == TOK_BEGIN_BLOCK)
        Cmd = ParseBlock(&RedirList);
    else if (CurrentTokenType == TOK_END_BLOCK && !RedirList)
        return NULL;

    if (Cmd)
    {
        /* FOR and IF commands cannot have leading redirection
         * (checked by ParseCommandPart(), errors out if so). */
        ASSERT(!RedirList || (Cmd->Type != C_FOR && Cmd->Type != C_IF));

        /* Save the redirection list in the command */
        Cmd->Redirections = RedirList;

        /* Return the new command */
        return Cmd;
    }

    ParseError();
    FreeRedirection(RedirList);
    return NULL;
}

Referenced by ParseCommandBinaryOp().

ParseRedirection()

static BOOL ParseRedirection ( IN OUT REDIRECTION **  List )

static

Definition at line 551 of file parser.c.

{
    PTSTR Tok = CurrentToken;
    REDIRECTION* Redir;
    REDIR_MODE RedirMode;
    BYTE Number;

    if ( !(*Tok == _T('<') || *Tok == _T('>')) &&
         !(_istdigit(*Tok) &&
           (Tok[1] == _T('<') || Tok[1] == _T('>')) ) )
    {
        ASSERT(CurrentTokenType != TOK_REDIRECTION);
        return FALSE;
    }
    ASSERT((CurrentTokenType == TOK_REDIRECTION) ||
           (CurrentTokenType == TOK_NORMAL));

    if (_istdigit(*Tok))
        Number = *Tok++ - _T('0');
    else
        Number = *Tok == _T('<') ? 0 : 1;

    if (*Tok++ == _T('<'))
    {
        RedirMode = REDIR_READ;
        /* Forbid '<<' */
        if (*Tok == _T('<'))
            goto fail;
    }
    else
    {
        RedirMode = REDIR_WRITE;
        if (*Tok == _T('>'))
        {
            RedirMode = REDIR_APPEND;
            Tok++;
        }
    }

    if (*Tok == _T('&'))
    {
        /* This is a handle redirection: the next character must be one single digit */
        if (!(_istdigit(Tok[1]) && !Tok[2]))
            goto fail;
    }
    else
#ifndef MSCMD_REDIR_PARSE_BUGS
    if (!*Tok)
        /* The file name was not part of this token, so it will be the next one */
#else
        /* Get rid of what possibly remains in the token, and retrieve the next one */
#endif
    {
        if (ParseToken(0, STANDARD_SEPS) != TOK_NORMAL)
            goto fail;
        Tok = CurrentToken;
    }

    /* If a redirection for this handle number already exists, delete it */
    while ((Redir = *List))
    {
        if (Redir->Number == Number)
        {
            *List = Redir->Next;
            cmd_free(Redir);
            continue;
        }
        List = &Redir->Next;
    }

    Redir = cmd_alloc(FIELD_OFFSET(REDIRECTION, Filename[_tcslen(Tok) + 1]));
    if (!Redir)
    {
        WARN("Cannot allocate memory for Redir!\n");
        goto fail;
    }
    Redir->Next = NULL;
    Redir->OldHandle = INVALID_HANDLE_VALUE;
    Redir->Number = Number;
    Redir->Mode = RedirMode;
    _tcscpy(Redir->Filename, Tok);
    *List = Redir;
    return TRUE;

fail:
    ParseError();
    FreeRedirection(*List);
    *List = NULL;
    return FALSE;
}

Referenced by ParseBlock(), ParseCommandPart(), and ParsePrimary().

ParseRem()

static PARSED_COMMAND* ParseRem ( VOID  )

static

Definition at line 1003 of file parser.c.

{
    PARSED_COMMAND* Cmd;

    /* The common scratch buffer already contains the name of the command */
    PTSTR ParsedLine = TempBuf;

    PTCHAR Pos = ParsedLine + _tcslen(ParsedLine) + 1;
    SIZE_T TailOffset = Pos - ParsedLine;

    /* Build a minimal command for REM, so that it can still get through the batch echo unparsing */

    /* Unparse the current token, so as to emulate the REM command parsing
     * behaviour of Windows' CMD, that discards everything before the last
     * line continuation. */
    UnParseToken();

    /*
     * Ignore the rest of the line, without any line continuation (but eat the caret).
     * We cannot simply set bLineContinuations to TRUE or FALSE, because we want (only
     * for the REM command), even when bLineContinuations == FALSE, to get the caret,
     * otherwise it would be ignored.
     */
    while (ParseTokenEx(0, 0, NULL, FALSE) != TOK_END)
    {
        if (Pos + _tcslen(CurrentToken) >= &ParsedLine[CMDLINE_LENGTH])
        {
            ParseError();
            return NULL;
        }
        Pos = _stpcpy(Pos, CurrentToken);
    }
    *Pos = _T('\0');

    Cmd = AllocCommand(C_REM,
                       ParsedLine,
                       ParsedLine + TailOffset);
    if (!Cmd)
    {
        WARN("Cannot allocate memory for Cmd!\n");
        ParseError();
        return NULL;
    }
    return Cmd;
}

Referenced by ParseCommandPart().

ParseToken()

static __inline INT ParseToken ( IN TCHAR ExtraEnd  OPTIONAL, IN PCTSTR Separators  OPTIONAL  )

static

Definition at line 450 of file parser.c.

{
    return ParseTokenEx(0, ExtraEnd, Separators, bHandleContinuations);
}

Referenced by ParseBlock(), ParseCommandBinaryOp(), ParseCommandPart(), ParseFor(), ParseIf(), ParsePrimary(), and ParseRedirection().

ParseTokenEx()

static TOK_TYPE ParseTokenEx ( IN TCHAR PrefixOperator  OPTIONAL, IN TCHAR ExtraEnd  OPTIONAL, IN PCTSTR Separators  OPTIONAL, IN BOOL  bHandleContinuations  )

static

Definition at line 241 of file parser.c.

{
    TOK_TYPE Type;
    PTCHAR CurrentTokStart = CurrentToken;
    PTCHAR Out = CurrentTokStart;
    TCHAR Char;
    BOOL bInQuote = FALSE;

#ifndef MSCMD_PARSER_BUGS
    if (bReparseToken)
    {
        bReparseToken = FALSE;

        /*
         * We will append the part to be reparsed to the old one
         * (still present in CurrentToken).
         */
        CurrentTokStart = LastCurTokPos;
        Out = CurrentTokStart;
    }
    else
    {
        LastCurTokPos = CurrentToken;
    }
#endif

    /* Start with what we have at current ParsePos */
    OldParsePos = ParsePos;

    for (Char = ParseChar(); Char && Char != _T('\n'); Char = ParseChar())
    {
        bInQuote ^= (Char == _T('"'));
        if (!bInQuote)
        {
            if (Separators != NULL)
            {
                if (_istspace(Char) || !!_tcschr(Separators, Char))
                {
                    /* Skip leading separators */
                    if (Out == CurrentTokStart)
                        continue;
                    break;
                }
            }

            /* Check for prefix operator */
            if ((Out == CurrentTokStart) && (Char == PrefixOperator))
                break;

            /*
             * Check for numbered redirection.
             *
             * For this purpose, we check whether this is a number, that is
             * in first position in the current parsing buffer (remember that
             * ParsePos points to the next character) or is preceded by a
             * whitespace-like separator, including standard command operators
             * (excepting '@' !) and double-quotes.
             */
            if ( _istdigit(Char) &&
                 (ParsePos == &OldParsePos[1]  ||
                     IsSeparator(ParsePos[-2]) ||
                     !!_tcschr(_T("()&|\""), ParsePos[-2])) &&
                 (*ParsePos == _T('<') || *ParsePos == _T('>')) )
            {
                break;
            }

            /* Check for other delimiters / operators */
            if (Char == ExtraEnd)
                break;
            if (InsideBlock && Char == _T(')'))
                break;
            if (_tcschr(_T("&|<>"), Char))
                break;

            if (bHandleContinuations && (Char == _T('^')))
            {
                Char = ParseChar();
                /* Eat up a \n, allowing line continuation */
                if (Char == _T('\n'))
                {
#ifndef MSCMD_PARSER_BUGS
                    LastCurTokPos = Out;
#endif
                    Char = ParseChar();
                }
                /* Next character is a forced literal */

                if (Out == CurrentTokStart)
                {
                    /* Ignore any prefix operator if we don't start a new command block */
                    if (CurrentTokenType != TOK_BEGIN_BLOCK)
                        PrefixOperator = 0;
                }
            }
        }
        if (Out == &CurrentToken[CMDLINE_LENGTH - 1])
            break;
        *Out++ = Char;

        // PrefixOperator = 0;
    }

    /*
     * We exited the parsing loop. If the current character is the first one
     * (Out == CurrentTokStart), interpret it as an operator. Otherwise,
     * terminate the current token (type TOK_NORMAL) and keep the current
     * character so that it can be refetched as an operator at the next call.
     */

    if (Out != CurrentTokStart)
    {
        Type = TOK_NORMAL;
    }
    /*
     * Else we have an operator.
     */
    else if (Char == _T('@'))
    {
        Type = TOK_OPERATOR; // TOK_QUIET / TOK_PREFIX_OPERATOR
        *Out++ = Char;
        Char = ParseChar();
    }
    else if (Char == _T('('))
    {
        Type = TOK_BEGIN_BLOCK;
        *Out++ = Char;
        Char = ParseChar();
    }
    else if (Char == _T(')'))
    {
        Type = TOK_END_BLOCK;
        *Out++ = Char;
        Char = ParseChar();
    }
    else if (Char == _T('&') || Char == _T('|'))
    {
        Type = TOK_OPERATOR;
        *Out++ = Char;
        Char = ParseChar();
        /* Check for '&&' or '||' */
        if (Char == Out[-1])
        {
            *Out++ = Char;
            Char = ParseChar();
        }
    }
    else if ( _istdigit(Char)  ||
              (Char == _T('<') || Char == _T('>')) )
    {
        Type = TOK_REDIRECTION;
        if (_istdigit(Char))
        {
            *Out++ = Char;
            Char = ParseChar();
        }
        /* By construction (see the while-loop above),
         * the next character must be a redirection. */
        ASSERT(Char == _T('<') || Char == _T('>'));
        *Out++ = Char;
        Char = ParseChar();
        if (Char == Out[-1])
        {
            /* Strangely, the tokenizer allows << as well as >>... (it
             * will cause an error when trying to parse it though) */
            *Out++ = Char;
            Char = ParseChar();
        }
        if (Char == _T('&'))
        {
            *Out++ = Char;
            while (IsSeparator(Char = ParseChar()))
                ;
            if (_istdigit(Char))
            {
                *Out++ = Char;
                Char = ParseChar();
            }
        }
    }
    else
    {
        Type = TOK_END;
        *Out++ = Char;
    }
    *Out = _T('\0');

    /*
     * Rewind the parsing position, so that the current character can be
     * refetched later on. However do this only if it is not NULL and if
     * this is not TOK_END, since we do not want to reparse later the line
     * termination (we could enter into infinite loops, or, in case of line
     * continuation, get unwanted "More?" prompts).
     */
    if (Char != 0 && Type != TOK_END)
        --ParsePos;

    /* Debugging support */
    if (fDumpTokens)
        ConOutPrintf(_T("ParseToken: (%d) '%s'\n"), Type, CurrentToken);

    return (CurrentTokenType = Type);
}

Referenced by ParseCommandOp(), ParseRem(), and ParseToken().

ResetParser()

static VOID ResetParser ( IN PTCHAR  Pos )

static

Definition at line 107 of file parser.c.

{
    bParseError = FALSE;
    ParsePos = Pos;
    OldParsePos = ParsePos;
}

Referenced by InitParser(), and ParseChar().

UnparseCommand()

PTCHAR UnparseCommand	(	IN PARSED_COMMAND *	Cmd,
		OUT PTCHAR	Out,
		IN PTCHAR	OutEnd
	)

Definition at line 1965 of file parser.c.

{
/*
 * Since this function has the annoying requirement that it must avoid
 * overflowing the supplied buffer, define some helper macros to make
 * this less painful.
 */
#define CHAR(Char) \
do { \
    if (Out == OutEnd) return NULL; \
    *Out++ = Char; \
} while (0)
#define STRING(String) \
do { \
    if (Out + _tcslen(String) > OutEnd) return NULL; \
    Out = _stpcpy(Out, String); \
} while (0)
#define PRINTF(Format, ...) \
do { \
    UINT Len = _sntprintf(Out, OutEnd - Out, Format, __VA_ARGS__); \
    if (Len > (UINT)(OutEnd - Out)) return NULL; \
    Out += Len; \
} while (0)
#define RECURSE(Subcommand) \
do { \
    Out = UnparseCommand(Subcommand, Out, OutEnd); \
    if (!Out) return NULL; \
} while (0)

    PARSED_COMMAND* Sub;
    REDIRECTION* Redir;

    if (!Cmd)
        return Out;

    switch (Cmd->Type)
    {
    case C_COMMAND:
    case C_REM:
    {
        /* This is fragile since there could be special characters, but
         * Windows doesn't bother escaping them, so for compatibility
         * we probably shouldn't do it either */
        if (!SubstituteForVars(Cmd->Command.First, TempBuf)) return NULL;
        STRING(TempBuf);
        if (!SubstituteForVars(Cmd->Command.Rest, TempBuf)) return NULL;
        STRING(TempBuf);
        break;
    }

    case C_QUIET:
    {
        CHAR(_T('@'));
        RECURSE(Cmd->Subcommands);
        break;
    }

    case C_BLOCK:
    {
        CHAR(_T('('));
        for (Sub = Cmd->Subcommands; Sub; Sub = Sub->Next)
        {
            RECURSE(Sub);
            if (Sub->Next)
                CHAR(_T('&'));
        }
        CHAR(_T(')'));
        break;
    }

    case C_MULTI:
    case C_OR:
    case C_AND:
    case C_PIPE:
    {
        Sub = Cmd->Subcommands;
        RECURSE(Sub);
        PRINTF(_T(" %s "), OpString[Cmd->Type - C_OP_LOWEST]);
        RECURSE(Sub->Next);
        break;
    }

    case C_FOR:
    {
        STRING(_T("for"));
        if (Cmd->For.Switches & FOR_DIRS)      STRING(_T(" /D"));
        if (Cmd->For.Switches & FOR_F)         STRING(_T(" /F"));
        if (Cmd->For.Switches & FOR_LOOP)      STRING(_T(" /L"));
        if (Cmd->For.Switches & FOR_RECURSIVE) STRING(_T(" /R"));
        if (Cmd->For.Params)
            PRINTF(_T(" %s"), Cmd->For.Params);
        if (Cmd->For.List && SubstituteForVars(Cmd->For.List, TempBuf))
            PRINTF(_T(" %%%c in (%s) do "), Cmd->For.Variable, TempBuf);
        else
            PRINTF(_T(" %%%c in (%s) do "), Cmd->For.Variable, Cmd->For.List);
        RECURSE(Cmd->Subcommands);
        break;
    }

    case C_IF:
    {
        STRING(_T("if"));
        if (Cmd->If.Flags & IFFLAG_IGNORECASE)
            STRING(_T(" /I"));
        if (Cmd->If.Flags & IFFLAG_NEGATE)
            STRING(_T(" not"));
        if (Cmd->If.LeftArg && SubstituteForVars(Cmd->If.LeftArg, TempBuf))
            PRINTF(_T(" %s"), TempBuf);
        PRINTF(_T(" %s"), IfOperatorString[Cmd->If.Operator]);
        if (!SubstituteForVars(Cmd->If.RightArg, TempBuf)) return NULL;
        PRINTF(_T(" %s "), TempBuf);
        Sub = Cmd->Subcommands;
        RECURSE(Sub);
        if (Sub->Next)
        {
            STRING(_T(" else "));
            RECURSE(Sub->Next);
        }
        break;
    }

    default:
        ASSERT(FALSE);
        break;
    }

    for (Redir = Cmd->Redirections; Redir; Redir = Redir->Next)
    {
        if (!SubstituteForVars(Redir->Filename, TempBuf))
            return NULL;
        PRINTF(_T(" %c%s%s"), _T('0') + Redir->Number,
               RedirString[Redir->Mode], TempBuf);
    }
    return Out;

#undef CHAR
#undef STRING
#undef PRINTF
#undef RECURSE
}

Referenced by ExecuteAsync().

UnParseToken()

static VOID UnParseToken ( VOID  )

static

Definition at line 160 of file parser.c.

{
    ParsePos = OldParsePos;

    /* Debugging support */
    if (fDumpTokens)
        ConOutPrintf(_T("Ungetting: '%s'\n"), ParsePos);

#ifndef MSCMD_PARSER_BUGS
    bReparseToken = TRUE;
#endif
}

Referenced by ParseBlock(), ParseCommandPart(), ParsePrimary(), and ParseRem().

Variable Documentation

bHandleContinuations

BOOL bHandleContinuations = TRUE

Definition at line 97 of file parser.c.

Referenced by cmd_call(), ParseCommandOp(), ParseToken(), and ParseTokenEx().

bIgnoreParserComments

BOOL bIgnoreParserComments = TRUE

Definition at line 96 of file parser.c.

Referenced by cmd_call(), and ParseCommandBinaryOp().

bLineContinuations

BOOL bLineContinuations

static

Definition at line 91 of file parser.c.

Referenced by ParseChar(), and ParseCommand().

bParseError

BOOL bParseError

Definition at line 90 of file parser.c.

Referenced by Batch(), cmd_call(), ParseBlock(), ParseChar(), ParseCommand(), ParseCommandBinaryOp(), ParseCommandLine(), ParseCommandPart(), ParseErrorEx(), ParsePrimary(), ResetParser(), and SubstituteVar().

CurrentToken

TCHAR CurrentToken[CMDLINE_LENGTH]

static

Definition at line 99 of file parser.c.

Referenced by InitParser(), ParseBlock(), ParseCommand(), ParseCommandBinaryOp(), ParseCommandPart(), ParseError(), ParseFor(), ParseIf(), ParsePrimary(), ParseRedirection(), ParseRem(), and ParseTokenEx().

CurrentTokenType

TOK_TYPE CurrentTokenType = TOK_END

static

Definition at line 100 of file parser.c.

Referenced by InitParser(), ParseBlock(), ParseCommand(), ParseCommandBinaryOp(), ParseCommandPart(), ParseError(), ParseFor(), ParseIf(), ParsePrimary(), ParseRedirection(), and ParseTokenEx().

fDumpParse

BOOLEAN fDumpParse = FALSE

Definition at line 36 of file parser.c.

Referenced by ParseCommand().

fDumpTokens

BOOLEAN fDumpTokens = FALSE

Definition at line 35 of file parser.c.

Referenced by ParseTokenEx(), and UnParseToken().

IfOperatorString

const TCHAR* const IfOperatorString[]

static

Initial value:

=
{
    

    
    _T("errorlevel"),
    _T("exist"),

    
    _T("cmdextversion"),
    _T("defined"),
#define IF_MAX_UNARY

    

    
    _T("=="),

    
    _T("equ"),
    _T("neq"),
    _T("lss"),
    _T("leq"),
    _T("gtr"),
    _T("geq"),
#define IF_MAX_COMPARISON
}

Definition at line 44 of file parser.c.

Referenced by DumpCommand(), EchoCommand(), ParseIf(), and UnparseCommand().

InsideBlock

INT InsideBlock = 0

static

Definition at line 105 of file parser.c.

Referenced by InitParser(), ParseBlock(), ParseCommandBinaryOp(), ParseFor(), and ParseTokenEx().

OldParsePos

PTCHAR OldParsePos

static

Definition at line 94 of file parser.c.

Referenced by ParseTokenEx(), ResetParser(), and UnParseToken().

OpString

const TCHAR OpString[][3] = { _T("&"), _T("||"), _T("&&"), _T("|") }

static

Definition at line 40 of file parser.c.

Referenced by DumpCommand(), EchoCommand(), ParseCommandBinaryOp(), and UnparseCommand().

ParseLine

TCHAR ParseLine[CMDLINE_LENGTH]

Definition at line 92 of file parser.c.

Referenced by Batch(), InitParser(), ParseChar(), and ParseCommand().

ParsePos

PTCHAR ParsePos

static

Definition at line 93 of file parser.c.

Referenced by ParseChar(), ParseTokenEx(), ResetParser(), and UnParseToken().

RedirString

const TCHAR RedirString[][3] = { _T("<"), _T(">"), _T(">>") }

static

Definition at line 42 of file parser.c.

Referenced by DumpRedir(), EchoCommand(), and UnparseCommand().

TempBuf

TCHAR TempBuf[CMDLINE_LENGTH]

static

Definition at line 88 of file parser.c.

Referenced by EchoCommand(), ParseCommandPart(), ParseFor(), ParseRem(), and UnparseCommand().