/*
 *  PARSER.C - command parsing.
 */

#include "precomp.h"

#define C_OP_LOWEST C_MULTI
#define C_OP_HIGHEST C_PIPE
static const TCHAR OpString[][3] = { _T("&"), _T("||"), _T("&&"), _T("|") };

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

static const TCHAR *const IfOperatorString[] =
{
    _T("cmdextversion"),
    _T("defined"),
    _T("errorlevel"),
    _T("exist"),
#define IF_MAX_UNARY IF_EXIST
    _T("=="),
    _T("equ"),
    _T("gtr"),
    _T("geq"),
    _T("lss"),
    _T("leq"),
    _T("neq"),
#define IF_MAX_COMPARISON IF_NEQ
};

/* These three characters act like spaces to the parser in most contexts */
#define STANDARD_SEPS _T(",;=")

static BOOL IsSeparator(TCHAR Char)
{
    return _istspace(Char) || (Char && _tcschr(STANDARD_SEPS, Char));
}

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

static BOOL bParseError;
static BOOL bLineContinuations;
static TCHAR ParseLine[CMDLINE_LENGTH];
static TCHAR *ParsePos;
static TCHAR CurChar;

static TCHAR CurrentToken[CMDLINE_LENGTH];
static int CurrentTokenType;
static int InsideBlock;

static TCHAR ParseChar()
{
    TCHAR Char;

    if (bParseError)
        return CurChar = 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 (bLineContinuations)
        {
            if (!ReadLine(ParseLine, TRUE))
            {
                /* ^C pressed, or line was too long */
                bParseError = TRUE;
            }
            else if (*(ParsePos = ParseLine))
            {
                goto restart;
            }
        }
    }
    return CurChar = Char;
}

static void ParseError()
{
    error_syntax(CurrentTokenType != TOK_END ? CurrentToken : NULL);
    bParseError = TRUE;
}

/*
 * Yes, cmd has a Lexical Analyzer. Whenever the parser gives an "xxx was
 * unexpected at this time." message, it shows what the last token read was.
 */
static int ParseToken(TCHAR ExtraEnd, TCHAR *Separators)
{
    TCHAR *Out = CurrentToken;
    TCHAR Char;
    int Type;
    BOOL bInQuote = FALSE;

    for (Char = CurChar; 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 == CurrentToken)
                        continue;
                    break;
                }
            }

            /* Check for numbered redirection */
            if ((Char >= _T('0') && Char <= _T('9') &&
                   (ParsePos == &ParseLine[1] || IsSeparator(ParsePos[-2]))
                   && (*ParsePos == _T('<') || *ParsePos == _T('>'))))
            {
                break;
            }

            if (Char == ExtraEnd)
                break;
            if (InsideBlock && Char == _T(')'))
                break;
            if (_tcschr(_T("&|<>"), Char))
                break;

            if (Char == _T('^'))
            {
                Char = ParseChar();
                /* Eat up a \n, allowing line continuation */
                if (Char == _T('\n'))
                    Char = ParseChar();
                /* Next character is a forced literal */
            }
        }
        if (Out == &CurrentToken[CMDLINE_LENGTH - 1])
            break;
        *Out++ = Char;
    }

    /* Check if we got at least one character before reaching a special one.
     * If so, return them and leave the special for the next call. */
    if (Out != CurrentToken)
    {
        Type = TOK_NORMAL;
    }
    else if (Char == _T('('))
    {
        Type = TOK_BEGIN_BLOCK;
        *Out++ = Char;
        ParseChar();
    }
    else if (Char == _T(')'))
    {
        Type = TOK_END_BLOCK;
        *Out++ = Char;
        ParseChar();
    }
    else if (Char == _T('&') || Char == _T('|'))
    {
        Type = TOK_OPERATOR;
        *Out++ = Char;
        Char = ParseChar();
        /* check for && or || */
        if (Char == Out[-1])
        {
            *Out++ = Char;
            ParseChar();
        }
    }
    else if ((Char >= _T('0') && Char <= _T('9'))
             || (Char == _T('<') || Char == _T('>')))
    {
        Type = TOK_REDIRECTION;
        if (Char >= _T('0') && Char <= _T('9'))
        {
            *Out++ = Char;
            Char = ParseChar();
        }
        *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 (Char >= _T('0') && Char <= _T('9'))
            {
                *Out++ = Char;
                ParseChar();
            }
        }
    }
    else
    {
        Type = TOK_END;
    }
    *Out = _T('\0');
    return CurrentTokenType = Type;
}

static BOOL ParseRedirection(REDIRECTION **List)
{
    TCHAR *Tok = CurrentToken;
    BYTE Number;
    REDIR_MODE RedirMode;
    REDIRECTION *Redir;

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

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

    if (!*Tok)
    {
        /* The file name was not part of this token, so it'll be the next one */
        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]));
    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;
}

static PARSED_COMMAND *ParseCommandOp(int OpType);

/* Parse a parenthesized block */
static PARSED_COMMAND *ParseBlock(REDIRECTION *RedirList)
{
    PARSED_COMMAND *Cmd, *Sub, **NextPtr;
    Cmd = cmd_alloc(sizeof(PARSED_COMMAND));
    Cmd->Type = C_BLOCK;
    Cmd->Next = NULL;
    Cmd->Subcommands = NULL;
    Cmd->Redirections = RedirList;

    /* Read the block contents */
    NextPtr = &Cmd->Subcommands;
    InsideBlock++;
    while (1)
    {
        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 */
        ParseChar();
    }
    InsideBlock--;

    /* Process any trailing redirections */
    while (ParseToken(0, STANDARD_SEPS) == TOK_REDIRECTION)
    {
        if (!ParseRedirection(&Cmd->Redirections))
        {
            FreeCommand(Cmd);
            return NULL;
        }
    }
    return Cmd;
}

/* Parse an IF statement */
static PARSED_COMMAND *ParseIf(void)
{
    PARSED_COMMAND *Cmd = cmd_alloc(sizeof(PARSED_COMMAND));
    int Type;
    memset(Cmd, 0, sizeof(PARSED_COMMAND));
    Cmd->Type = C_IF;

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

    if (Type != TOK_NORMAL)
    {
        FreeCommand(Cmd);
        ParseError();
        return NULL;
    }

    /* Check for unary operators */
    for (; Cmd->If.Operator <= IF_MAX_UNARY; Cmd->If.Operator++)
    {
        if (_tcsicmp(CurrentToken, IfOperatorString[Cmd->If.Operator]) == 0)
        {
            if (ParseToken(0, STANDARD_SEPS) != TOK_NORMAL)
            {
                FreeCommand(Cmd);
                ParseError();
                return NULL;
            }
            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;
    }

    for (; Cmd->If.Operator <= IF_MAX_COMPARISON; Cmd->If.Operator++)
    {
        if (_tcsicmp(CurrentToken, IfOperatorString[Cmd->If.Operator]) == 0)
        {
            if (ParseToken(0, STANDARD_SEPS) != TOK_NORMAL)
                break;
            Cmd->If.RightArg = cmd_dup(CurrentToken);
            goto condition_done;
        }
    }
    FreeCommand(Cmd);
    ParseError();
    return NULL;

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

    return Cmd;
}

/*
 * Parse a FOR command.
 * Syntax is: FOR [options] %var IN (list) DO command
 */
static PARSED_COMMAND *ParseFor(void)
{
    PARSED_COMMAND *Cmd = cmd_alloc(sizeof(PARSED_COMMAND));
    TCHAR List[CMDLINE_LENGTH];
    TCHAR *Pos = List;

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

    while (1)
    {
        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;
    }

    /* 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 (1)
    {
        int Type;

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

        if (Type == TOK_END_BLOCK)
            break;

        if (Type != 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)
    {
        FreeCommand(Cmd);
        return NULL;
    }

    return Cmd;

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

/* Parse a REM command */
static PARSED_COMMAND *ParseRem(void)
{
    /* Just ignore the rest of the line */
    while (CurChar && CurChar != _T('\n'))
        ParseChar();
    return NULL;
}

static DECLSPEC_NOINLINE PARSED_COMMAND *ParseCommandPart(REDIRECTION *RedirList)
{
    TCHAR ParsedLine[CMDLINE_LENGTH];
    PARSED_COMMAND *Cmd;
    PARSED_COMMAND *(*Func)(void);

    TCHAR *Pos = _stpcpy(ParsedLine, CurrentToken) + 1;
    DWORD_PTR 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))
    {
        ParseToken(0, STANDARD_SEPS);
        /* Do special parsing only if it's not followed by /? */
        if (_tcscmp(CurrentToken, _T("/?")) != 0)
        {
            if (RedirList)
            {
                ParseError();
                FreeRedirection(RedirList);
                return NULL;
            }
            return Func();
        }
        Pos = _stpcpy(Pos, _T(" /?"));
    }

    /* Now get the tail */
    while (1)
    {
        int Type = ParseToken(0, NULL);
        if (Type == TOK_NORMAL)
        {
            if (Pos + _tcslen(CurrentToken) >= &ParsedLine[CMDLINE_LENGTH])
            {
                ParseError();
                FreeRedirection(RedirList);
                return NULL;
            }
            Pos = _stpcpy(Pos, CurrentToken);
        }
        else if (Type == TOK_REDIRECTION)
        {
            if (!ParseRedirection(&RedirList))
                return NULL;
        }
        else
        {
            break;
        }
    }
    *Pos++ = _T('\0');

    Cmd = cmd_alloc(FIELD_OFFSET(PARSED_COMMAND, Command.First[Pos - ParsedLine]));
    Cmd->Type = C_COMMAND;
    Cmd->Next = NULL;
    Cmd->Subcommands = NULL;
    Cmd->Redirections = RedirList;
    memcpy(Cmd->Command.First, ParsedLine, (Pos - ParsedLine) * sizeof(TCHAR));
    Cmd->Command.Rest = Cmd->Command.First + TailOffset;
    return Cmd;
}

static PARSED_COMMAND *ParsePrimary(void)
{
    REDIRECTION *RedirList = NULL;
    int Type;

    while (IsSeparator(CurChar))
    {
        if (CurChar == _T('\n'))
            return NULL;
        ParseChar();
    }

    if (!CurChar)
        return NULL;

    if (CurChar == _T(':'))
    {
        /* "Ignore" the rest of the line.
         * (Line continuations will still be parsed, though.) */
        while (ParseToken(0, NULL) != TOK_END)
            ;
        return NULL;
    }

    if (CurChar == _T('@'))
    {
        PARSED_COMMAND *Cmd;
        ParseChar();
        Cmd = cmd_alloc(sizeof(PARSED_COMMAND));
        Cmd->Type = C_QUIET;
        Cmd->Next = NULL;
        /* @ acts like a unary operator with low precedence,
         * so call the top-level parser */
        Cmd->Subcommands = ParseCommandOp(C_OP_LOWEST);
        Cmd->Redirections = NULL;
        return Cmd;
    }

    /* Process leading redirections and get the head of the command */
    while ((Type = ParseToken(_T('('), STANDARD_SEPS)) == TOK_REDIRECTION)
    {
        if (!ParseRedirection(&RedirList))
            return NULL;
    }

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

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

static PARSED_COMMAND *ParseCommandOp(int OpType)
{
    PARSED_COMMAND *Cmd, *Left, *Right;

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

    if (Cmd && !_tcscmp(CurrentToken, OpString[OpType - C_OP_LOWEST]))
    {
        Left = Cmd;
        Right = ParseCommandOp(OpType);
        if (!Right)
        {
            if (!bParseError)
            {
                /* & is allowed to have an empty RHS */
                if (OpType == C_MULTI)
                    return Left;
                ParseError();
            }
            FreeCommand(Left);
            return NULL;
        }

        Cmd = cmd_alloc(sizeof(PARSED_COMMAND));
        Cmd->Type = OpType;
        Cmd->Next = NULL;
        Cmd->Redirections = NULL;
        Cmd->Subcommands = Left;
        Left->Next = Right;
        Right->Next = NULL;
    }

    return Cmd;
}

PARSED_COMMAND *
ParseCommand(LPTSTR Line)
{
    PARSED_COMMAND *Cmd;

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

    Cmd = ParseCommandOp(C_OP_LOWEST);
    if (Cmd)
    {
        if (CurrentTokenType != TOK_END)
            ParseError();
        if (bParseError)
        {
            FreeCommand(Cmd);
            Cmd = NULL;
        }
        bIgnoreEcho = FALSE;
    }
    else
    {
        bIgnoreEcho = TRUE;
    }
    return Cmd;
}


/*
 * Reconstruct a parse tree into text form; used for echoing
 * batch file commands and FOR instances.
 */
VOID
EchoCommand(PARSED_COMMAND *Cmd)
{
    TCHAR Buf[CMDLINE_LENGTH];
    PARSED_COMMAND *Sub;
    REDIRECTION *Redir;

    switch (Cmd->Type)
    {
    case C_COMMAND:
        if (SubstituteForVars(Cmd->Command.First, Buf))
            ConOutPrintf(_T("%s"), Buf);
        if (SubstituteForVars(Cmd->Command.Rest, Buf))
            ConOutPrintf(_T("%s"), Buf);
        break;
    case C_QUIET:
        return;
    case C_BLOCK:
        ConOutChar(_T('('));
        Sub = Cmd->Subcommands;
        if (Sub && !Sub->Next)
        {
            /* Single-command block: display all on one line */
            EchoCommand(Sub);
        }
        else if (Sub)
        {
            /* Multi-command block: display parenthesis on separate lines */
            ConOutChar(_T('\n'));
            do
            {
                EchoCommand(Sub);
                ConOutChar(_T('\n'));
                Sub = Sub->Next;
            } while (Sub);
        }
        ConOutChar(_T(')'));
        break;
    case C_MULTI:
    case C_IFFAILURE:
    case C_IFSUCCESS:
    case C_PIPE:
        Sub = Cmd->Subcommands;
        EchoCommand(Sub);
        ConOutPrintf(_T(" %s "), OpString[Cmd->Type - C_OP_LOWEST]);
        EchoCommand(Sub->Next);
        break;
    case C_IF:
        ConOutPrintf(_T("if"));
        if (Cmd->If.Flags & IFFLAG_IGNORECASE)
            ConOutPrintf(_T(" /I"));
        if (Cmd->If.Flags & IFFLAG_NEGATE)
            ConOutPrintf(_T(" not"));
        if (Cmd->If.LeftArg && SubstituteForVars(Cmd->If.LeftArg, Buf))
            ConOutPrintf(_T(" %s"), Buf);
        ConOutPrintf(_T(" %s"), IfOperatorString[Cmd->If.Operator]);
        if (SubstituteForVars(Cmd->If.RightArg, Buf))
            ConOutPrintf(_T(" %s "), Buf);
        Sub = Cmd->Subcommands;
        EchoCommand(Sub);
        if (Sub->Next)
        {
            ConOutPrintf(_T(" else "));
            EchoCommand(Sub->Next);
        }
        break;
    case C_FOR:
        ConOutPrintf(_T("for"));
        if (Cmd->For.Switches & FOR_DIRS)      ConOutPrintf(_T(" /D"));
        if (Cmd->For.Switches & FOR_F)         ConOutPrintf(_T(" /F"));
        if (Cmd->For.Switches & FOR_LOOP)      ConOutPrintf(_T(" /L"));
        if (Cmd->For.Switches & FOR_RECURSIVE) ConOutPrintf(_T(" /R"));
        if (Cmd->For.Params)
            ConOutPrintf(_T(" %s"), Cmd->For.Params);
        ConOutPrintf(_T(" %%%c in (%s) do "), Cmd->For.Variable, Cmd->For.List);
        EchoCommand(Cmd->Subcommands);
        break;
    }

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

/*
 * "Unparse" a command into a text form suitable for passing to CMD /C.
 * Used for pipes. This is basically the same thing as EchoCommand, but
 * writing into a string instead of to standard output.
 */
TCHAR *
Unparse(PARSED_COMMAND *Cmd, TCHAR *Out, TCHAR *OutEnd)
{
    TCHAR Buf[CMDLINE_LENGTH];
    PARSED_COMMAND *Sub;
    REDIRECTION *Redir;

/*
 * 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) { \
    if (Out == OutEnd) return NULL; \
    *Out++ = Char; }
#define STRING(String) { \
    if (Out + _tcslen(String) > OutEnd) return NULL; \
    Out = _stpcpy(Out, String); }
#define PRINTF(Format, ...) { \
    UINT Len = _sntprintf(Out, OutEnd - Out, Format, __VA_ARGS__); \
    if (Len > (UINT)(OutEnd - Out)) return NULL; \
    Out += Len; }
#define RECURSE(Subcommand) { \
    Out = Unparse(Subcommand, Out, OutEnd); \
    if (!Out) return NULL; }

    switch (Cmd->Type)
    {
    case C_COMMAND:
        /* 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, Buf)) return NULL;
        STRING(Buf)
        if (!SubstituteForVars(Cmd->Command.Rest, Buf)) return NULL;
        STRING(Buf)
        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_IFFAILURE:
    case C_IFSUCCESS:
    case C_PIPE:
        Sub = Cmd->Subcommands;
        RECURSE(Sub)
        PRINTF(_T(" %s "), OpString[Cmd->Type - C_OP_LOWEST])
        RECURSE(Sub->Next)
        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, Buf))
            PRINTF(_T(" %s"), Buf)
        PRINTF(_T(" %s"), IfOperatorString[Cmd->If.Operator]);
        if (!SubstituteForVars(Cmd->If.RightArg, Buf)) return NULL;
        PRINTF(_T(" %s "), Buf)
        Sub = Cmd->Subcommands;
        RECURSE(Sub)
        if (Sub->Next)
        {
            STRING(_T(" else "))
            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)
        PRINTF(_T(" %%%c in (%s) do "), Cmd->For.Variable, Cmd->For.List)
        RECURSE(Cmd->Subcommands)
        break;
    }

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

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