#include "precomp.h"

Include dependency graph for parser.c:

Macros
#define	C_OP_LOWEST C_MULTI

#define	C_OP_HIGHEST C_PIPE

#define	IF_MAX_UNARY IF_EXIST

#define	IF_MAX_COMPARISON IF_NEQ

#define	STANDARD_SEPS _T(",;=")

#define	CHAR(Char)

#define	STRING(String)

#define	PRINTF(Format,...)

#define	RECURSE(Subcommand)

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

Functions
static BOOL	IsSeparator (TCHAR Char)

static TCHAR	ParseChar ()

static void	ParseError ()

static int	ParseToken (TCHAR ExtraEnd, TCHAR *Separators)

static BOOL	ParseRedirection (REDIRECTION **List)

static PARSED_COMMAND *	ParseCommandOp (int OpType)

static PARSED_COMMAND *	ParseBlock (REDIRECTION *RedirList)

static PARSED_COMMAND *	ParseIf (void)

static PARSED_COMMAND *	ParseFor (void)

static PARSED_COMMAND *	ParseRem (void)

static DECLSPEC_NOINLINE PARSED_COMMAND *	ParseCommandPart (REDIRECTION *RedirList)

static PARSED_COMMAND *	ParsePrimary (void)

PARSED_COMMAND *	ParseCommand (LPTSTR Line)

VOID	EchoCommand (PARSED_COMMAND *Cmd)

TCHAR *	Unparse (PARSED_COMMAND Cmd, TCHAR Out, TCHAR *OutEnd)

VOID	FreeCommand (PARSED_COMMAND *Cmd)

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

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

static const TCHAR *const	IfOperatorString []

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

Macro Definition Documentation

#define C_OP_HIGHEST C_PIPE

Definition at line 8 of file parser.c.

Referenced by ParseCommandOp().

#define C_OP_LOWEST C_MULTI

Definition at line 7 of file parser.c.

Referenced by EchoCommand(), ParseBlock(), ParseCommand(), ParseCommandOp(), ParseFor(), ParseIf(), ParsePrimary(), and Unparse().

#define CHAR ( Char )

Value:

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

Referenced by AddConsoleAliasA(), AtapiDmaReinit(), AtapiHwInitialize__(), AtapiStartIo__(), AtaSetTransferMode(), BytesInHostent(), BytesInProtoent(), BytesInServent(), calc_arg_size(), CmpCopyName(), CmpGetNameControlBlock(), co_UserCreateWindowEx(), ComputeStringSize(), ConDrvReadConsoleOutputString(), ConDrvWriteConsoleOutputString(), ConMgrSerialPortConsumer(), CopyCompStringIMEtoClient(), CopyHostentToBuffer(), CopyProtoentToBuffer(), CopyServentToBuffer(), CPin::CPin(), CSR_API(), DuplicateStringAEx(), CPin::EnumMediaTypes(), ExpLoadBootSymbols(), FAST486_OPCODE_HANDLER(), FatCreateRootDcb(), FlatBuf_Arg_WriteString(), FONT_TextMetricWToA(), FsRtlIsDbcsInExpression(), FsRtlNotifyFilterChangeDirectory(), FsRtlNotifyFilterReportChange(), gdb_receive_packet(), get_type_size(), GetServiceDisplayNameA(), GetServiceKeyNameA(), GspGetPacket(), HCR_GetClassNameA(), HEXEDIT_WM_CHAR(), IntWideCharToMultiByteCP(), IntWideCharToMultiByteSYMBOL(), IntWideCharToMultiByteUTF8(), IPADDRESS_SubclassProc(), KbdHid_InsertScanCodes(), KdbpSymUnicodeToAnsi(), KdInitSystem(), KeBugCheckUnicodeToAnsi(), KeInitializeProcess(), LdrpGetProcedureAddress(), ListBoxWndProc_common(), main(), MountMgrNextDriveLetterWorker(), NLS_EnumCalendarInfo(), PciGetDescriptionMessage(), QueryCygwinEA(), RawUszAsz(), RtlInitAnsiString(), RtlIntegerToChar(), RtlLargeIntegerToChar(), RWComputeCHS(), ScBuildAnsiArgsVector(), test_GetPrinterData(), test_GetPrinterDataEx(), test_GetPrivateProfileString(), test_profile_sections_names(), UniataFindBusMasterController(), Unparse(), UrlUnescapeA(), UTF8fromUNICODE(), write_unicode2cp_table(), wvnsprintfA(), and wvnsprintfW().

#define IF_MAX_COMPARISON IF_NEQ

Referenced by ParseIf().

#define IF_MAX_UNARY IF_EXIST

Referenced by ParseIf().

#define PRINTF	(	Format,
		...
	)

Value:

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

Referenced by Unparse().

#define RECURSE ( Subcommand )

Value:

{ \
    Out = Unparse(Subcommand, Out, OutEnd); \
    if (!Out) return NULL; }

Referenced by Unparse().

#define STANDARD_SEPS _T(",;=")

Definition at line 31 of file parser.c.

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

#define STRING ( String )

Value:

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

Referenced by Unparse(), and while().

Enumeration Type Documentation

anonymous enum

Enumerator
TOK_END
TOK_NORMAL
TOK_OPERATOR
TOK_REDIRECTION
TOK_BEGIN_BLOCK
TOK_END_BLOCK

Definition at line 38 of file parser.c.

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

Function Documentation

VOID EchoCommand ( PARSED_COMMAND * Cmd )

Definition at line 752 of file parser.c.

Referenced by Batch(), and RunInstance().

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

VOID FreeCommand ( PARSED_COMMAND * Cmd )

Definition at line 945 of file parser.c.

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

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

static BOOL IsSeparator ( TCHAR Char )

static

Definition at line 33 of file parser.c.

Referenced by ParsePrimary(), and ParseToken().

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

static PARSED_COMMAND* ParseBlock ( REDIRECTION * RedirList )

static

Definition at line 291 of file parser.c.

Referenced by ParsePrimary().

 {
     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;
 }

static TCHAR ParseChar ( )

static

Definition at line 58 of file parser.c.

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

 {
     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;
 }

PARSED_COMMAND* ParseCommand ( LPTSTR Line )

Definition at line 707 of file parser.c.

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

 {
     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;
 }

static PARSED_COMMAND * ParseCommandOp ( int OpType )

static

Definition at line 668 of file parser.c.

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

 {
     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;
 }

static DECLSPEC_NOINLINE PARSED_COMMAND* ParseCommandPart ( REDIRECTION * RedirList )

static

Definition at line 546 of file parser.c.

Referenced by ParsePrimary().

 {
     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 void ParseError ( )

static

Definition at line 94 of file parser.c.

Referenced by ParseCommand(), ParseCommandOp(), ParseCommandPart(), ParseFor(), ParseIf(), ParsePrimary(), and ParseRedirection().

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

static PARSED_COMMAND* ParseFor ( void )

static

Definition at line 430 of file parser.c.

Referenced by ParseCommandPart().

 {
     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;
 }

static PARSED_COMMAND* ParseIf ( void )

static

Definition at line 338 of file parser.c.

Referenced by ParseCommandPart().

 {
     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;
 }

static PARSED_COMMAND* ParsePrimary ( void )

static

Definition at line 611 of file parser.c.

Referenced by ParseCommandOp().

 {
     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 BOOL ParseRedirection ( REDIRECTION ** List )

static

Definition at line 224 of file parser.c.

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

 {
     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* ParseRem ( void )

static

Definition at line 538 of file parser.c.

Referenced by ParseCommandPart().

 {
     /* Just ignore the rest of the line */
     while (CurChar && CurChar != _T('\n'))
         ParseChar();
     return NULL;
 }

static int ParseToken	(	TCHAR	ExtraEnd,
		TCHAR *	Separators
	)

static

Definition at line 104 of file parser.c.

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

 {
     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;
 }

TCHAR* Unparse	(	PARSED_COMMAND *	Cmd,
		TCHAR *	Out,
		TCHAR *	OutEnd
	)

Definition at line 844 of file parser.c.

Referenced by ExecuteAsync().

 {
     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;
 }

Variable Documentation

BOOL bLineContinuations

static

Definition at line 49 of file parser.c.

Referenced by ParseChar(), and ParseCommand().

BOOL bParseError

static

Definition at line 48 of file parser.c.

Referenced by ParseBlock(), ParseChar(), ParseCommand(), ParseCommandOp(), and ParseError().

TCHAR CurChar

static

Definition at line 52 of file parser.c.

Referenced by GuiPasteToTextModeBuffer(), ParseChar(), ParseCommand(), ParsePrimary(), ParseRem(), ParseToken(), PrintMessageAnsi(), and RxCanonicalizeFileNameByServerSpecs().

TCHAR CurrentToken[CMDLINE_LENGTH]

static

Definition at line 54 of file parser.c.

Referenced by ParseCommandOp(), ParseCommandPart(), ParseError(), ParseFor(), ParseIf(), ParseRedirection(), and ParseToken().

int CurrentTokenType

static

Definition at line 55 of file parser.c.

Referenced by ParseBlock(), ParseCommand(), ParseError(), ParseIf(), and ParseToken().

const TCHAR* const IfOperatorString[]

static

Initial value:

=
{
    _T("cmdextversion"),
    _T("defined"),
    _T("errorlevel"),
    _T("exist"),
#define IF_MAX_UNARY
    _T("=="),
    _T("equ"),
    _T("gtr"),
    _T("geq"),
    _T("lss"),
    _T("leq"),
    _T("neq"),
#define IF_MAX_COMPARISON
}