void OAuthParseJSON(char *JSON, ListNode *Vars)
{
char *ptr, *ptr2, *Token=NULL, *Name=NULL, *Value=NULL;
StripLeadingWhitespace(JSON);
StripTrailingWhitespace(JSON);
ptr=JSON+StrLen(JSON)-1;
if (*ptr=='}') *ptr='\0';
ptr=JSON;
if (*ptr=='{') ptr++;
ptr=GetToken(ptr,",",&Token,0);
while (ptr)
{
printf("TOK: %s\n",Token);
ptr2=GetToken(Token,":",&Name,0);
StripTrailingWhitespace(Name);
StripQuotes(Name);
ptr2=GetToken(ptr2,":",&Value,GETTOKEN_QUOTES);
StripLeadingWhitespace(Value);
StripTrailingWhitespace(Value);
StripQuotes(Value);
printf("JSON: %s=%s\n",Name,Value);
SetVar(Vars,Name,Value);
ptr=GetToken(ptr,",",&Token,0);
}
DestroyString(Name);
DestroyString(Value);
DestroyString(Token);
}
char *
AddColor(char *c, char *representation, char *l, int IsAddressd)
{
Color *color;
ColorTable *list = (ColorTable *)l;
int IsAddress = 1;
if ('"' == c[0])
{
StripQuotes(c);
IsAddress = 0;
}
StripQuotes(representation);
color = ColorNew(c, 0, 0, 0);
if (IsAddress)
{
ColorSetAddress(color);
}
if (NULL == list)
{
list = ColorTableNew();
}
ColorTableAppend(list, representation, color);
return (char *)list;
}
// Ugh, this is ugly.
static bool ParseLine(const std::string& line, std::string* keyOut, std::string* valueOut, std::string* commentOut)
{
int FirstEquals = (int)line.find("=", 0);
int FirstCommentChar = -1;
// Comments
if (FirstCommentChar < 0)
FirstCommentChar =
(int)line.find("#", FirstEquals > 0 ? FirstEquals : 0);
if (FirstCommentChar < 0 && line[0] == ';')
FirstCommentChar = 0;
// Allow preservation of spacing before comment
while (FirstCommentChar > 0 && line[FirstCommentChar - 1] <= ' ')
{
FirstCommentChar--;
}
if ((FirstEquals >= 0) && ((FirstCommentChar < 0) || (FirstEquals < FirstCommentChar)))
{
// Yes, a valid key/value line!
*keyOut = StripSpaces(line.substr(0, FirstEquals));
if (commentOut) *commentOut = FirstCommentChar > 0 ? line.substr(FirstCommentChar) : std::string("");
if (valueOut) *valueOut = StripQuotes(StripSpaces(line.substr(FirstEquals + 1, FirstCommentChar - FirstEquals - 1)));
return true;
}
return false;
}
char *
InsertString(char *sl, char *s)
{
char temp[256];
Char8Vector *StringList = (Char8Vector *)sl;
if (NULL == StringList)
{
StringList = Char8VectorNew();
}
if ('"' == s[0])
{
StripQuotes(s);
}
else
{
strcpy(&temp[1], s);
temp[0] = '~';
s = temp;
}
Char8VectorAppend(StringList, __MrmStore(s));
return (char *)StringList;
}
static TString FindOutputFile() {
TString candidate;
if (!out_argument.empty()) {
candidate = StripQuotes(out_argument);
} else if (!first_object_name.empty()) {
candidate = first_object_name;
if (!StripSuffix(candidate, TEXT(".obj")))
StripSuffix(candidate, TEXT(".o"));
} else {
return TString();
}
if (PathFileExists(candidate.c_str()))
return candidate;
// FIXME: we should figure out from the linker's command line
// whether the output file is an .exe or .dll
TString exe_file = candidate + TEXT(".exe");
if (PathFileExists(exe_file.c_str()))
return exe_file;
TString dll_file = candidate + TEXT(".dll");
if (PathFileExists(dll_file.c_str()))
return dll_file;
return TString();
}
char *
bitmap(char *s)
{
StripQuotes(s);
return (char *)XBitmapFileNew(s);
}
static char *GetAFileName( void )
/*******************************/
{
char *fname;
fname = CopyOfParm();
StripQuotes( fname );
return( fname );
}
char *
expr_STRING_Compound(char *st, int Separate, int IsAddress)
{
if (!IsAddress)
{
StripQuotes(st);
}
return (char *)CStringNew(st, NULL, IsAddress, Separate);
}
char *
font(char *s)
{
if ('"' == s[0])
{
StripQuotes(s);
}
return (char *)FontMNew(s);
}
static bool openCmdFile( // OPEN A COMMAND FILE
char const *filename, // - file name
size_t size ) // - size of name
{
char fnm[ _MAX_PATH ]; // - buffer for name
stvcpy( fnm, filename, size );
StripQuotes( fnm );
return IoSuppOpenSrc( fnm, FT_CMD );
}
static void PartyMngt_Dlg_Response(int response, const char *text) {
PartyMngt_Dialog_Close();
switch (PMngtData.dlgid) {
case PDLGID_NEWPARTY:
if (response == PDLGRESP_YES) {
cgImports->SendClientCommand("~pmngt partycreate");
}
break;
case PDLGID_ACCEPTINVITE:
if (response == PDLGRESP_YES) {
cgImports->SendClientCommand(va("~pmngt partyaccept %i", PMngtData.partySelection));
}
break;
case PDLGID_REJECTINVITE:
if (response == PDLGRESP_YES) {
cgImports->SendClientCommand(va("~pmngt partyreject %i", PMngtData.partySelection));
}
break;
case PDLGID_LEAVEPARTY:
if (response == PDLGRESP_YES) {
cgImports->SendClientCommand("~pmngt partyleave");
}
break;
case PDLGID_DISBANDPARTY:
if (response == PDLGRESP_YES) {
cgImports->SendClientCommand("~pmngt partydisband");
}
break;
case PDLGID_MAKELEADER:
if (response == PDLGRESP_YES) {
cgImports->SendClientCommand(va("~pmngt partychangeleader %i", PMngtData.Data.PartyMembers[PMngtData.partySelection].slotid ));
}
break;
case PDLGID_DISMISSMEMBER:
if (response == PDLGRESP_YES) {
cgImports->SendClientCommand(va("~pmngt partydismiss %i", PMngtData.Data.PartyMembers[PMngtData.partySelection].slotid ));
}
break;
case PDLGID_ADDTOLIST:
if (response == PDLGRESP_OK) {
cgImports->SendClientCommand(va("~pmngt partylistregister \"%s\"", StripQuotes((char *)text)));
}
break;
case PDLGID_REMOVEFROMLIST:
if (response == PDLGRESP_YES) {
cgImports->SendClientCommand("~pmngt partylistunregister");
}
break;
case PDLGID_INVITE:
if (response == PDLGRESP_YES) {
cgImports->SendClientCommand(va("~pmngt partyinvite %i", PMngtData.partySeeker[PMngtData.seekerSelection].id));
}
break;
}
}
/*
* CD / CHDIR
*
*/
INT cmd_chdir (LPTSTR param)
{
TCHAR szCurrent[MAX_PATH];
BOOL bChangeDrive = FALSE;
/* Filter out special cases first */
/* Print Help */
if (!_tcsncmp(param, _T("/?"), 2))
{
ConOutResPaging(TRUE,STRING_CD_HELP);
return 0;
}
/* Remove " */
StripQuotes(param);
/* Set Error Level to Success */
nErrorLevel = 0;
/* Print Current Directory on a disk */
if (_tcslen(param) == 2 && param[1] == _T(':'))
{
if (GetRootPath(param, szCurrent, MAX_PATH))
{
error_invalid_drive();
return 1;
}
ConOutPuts(szCurrent);
return 0;
}
/* Get Current Directory */
GetCurrentDirectory(MAX_PATH, szCurrent);
if (param[0] == _T('\0'))
{
ConOutPuts(szCurrent);
return 0;
}
/* Input String Contains /D Switch */
if (!_tcsncicmp(param, _T("/D"), 2))
{
bChangeDrive = TRUE;
param += 2;
while (_istspace(*param))
param++;
}
if (!SetRootPath(bChangeDrive ? NULL : szCurrent, param))
return 1;
return 0;
}
/*
* The rvalue of an equation is a string. Set values and return.
*/
char *
expr_STRING(char *st, char *cs, int CompoundString)
{
char s[256];
int i;
FontSet *fs = (FontSet *) cs;
char *FontName = NULL;
if (fs)
{
FontName = fs->fontset.name;
}
for (i = 0; *st; i++)
{
if ('\\' == *st)
{
st++;
while (*st && isdigit(*st))
{
s[i] = s[i] * 10 + *st++ - '0';
}
if (*st != '\\')
{
__MrmExit(LOC, "String ERROR\n");
}
st++;
}
else
{
s[i] = *st++;
}
}
s[i] = 0;
st = s;
if (CompoundString)
{
return (char *)CStringNew(st, FontName, 0, 0);
}
else
{
StripQuotes(st);
return (char *)CStringNew(st, FontName, 0, 0);
}
}
bool OPT_GET_FILE // PARSE: FILE NAME
( OPT_STRING **p ) // - target
{
size_t len;
char const *fname;
CmdRecogEquals();
len = CmdScanFilename( &fname );
if( len != 0 ) {
addString( p, fname, len );
StripQuotes( (*p)->data );
return( TRUE );
}
BadCmdLineFile();
return( FALSE );
}
char *
color(char *s, char *r, char *g, char *b)
{
if (s && s[0])
{
if ('"' == s[0])
{
StripQuotes(s);
}
return (char *)ColorNew(s, 0, 0, 0);
}
else
{
return (char *)ColorNew(NULL, atoi(r), atoi(g), atoi(b));
}
}
bool OPT_GET_PATH // PARSE: PATH
( OPT_STRING **p ) // - target
{
size_t len;
char const *path;
// CmdPathDelim();
CmdRecogEquals();
len = CmdScanFilename( &path );
if( len != 0 ) {
addString( p, path, len );
StripQuotes( (*p)->data );
return( TRUE );
}
BadCmdLinePath();
return( FALSE );
}
char *
keysym(char *s)
{
char temp[256];
if ('"' == s[0])
{
StripQuotes(s);
}
else
{
temp[0] = '~';
strcpy(&temp[1], s);
s = temp;
}
return (char *)KeysymNew(s);
}
void IniFile::ParseLine(const std::string& line, std::string* keyOut, std::string* valueOut)
{
if (line[0] == '#')
return;
size_t firstEquals = line.find("=", 0);
if (firstEquals != std::string::npos)
{
// Yes, a valid line!
*keyOut = StripSpaces(line.substr(0, firstEquals));
if (valueOut)
{
*valueOut = StripQuotes(StripSpaces(line.substr(firstEquals + 1, std::string::npos)));
}
}
}
bool OPT_GET_PATH_OPT // PARSE: OPTIONAL PATH
( OPT_STRING **p ) // - target
{
size_t len;
char const *fname;
// if( CmdPathDelim() || !CmdDelimitChar() ) {
if( CmdRecogEquals() || !CmdDelimitChar() ) {
// specified an '=' so accept -this-is-a-path-name.fil or /tmp/ack.tmp
len = CmdScanFilename( &fname );
if( len != 0 ) {
addString( p, fname, len );
StripQuotes( (*p)->data );
} else {
OPT_CLEAN_STRING( p );
}
}
return( TRUE );
}
static TString ProcessInputFile(const _TCHAR *file) {
// If the file name is surrounded by quotes, remove them
auto input_file = StripQuotes(TString(file));
// If the file ends something other than .obj, skip it
auto dot = PathFindExtension(input_file.c_str());
if (dot == nullptr) {
// MSDN says that files without an extension get .obj appended
input_file.append(TEXT(".obj"));
} else if (_tcsicmp(dot, TEXT(".lib")) == 0) {
auto tmp_file = TempFile::Create(TEXT(".lib"), true);
auto trap_status = TRaPCOFFLibrary(input_file.c_str(), tmp_file.data());
#if 0
if (trap_status == TRaPStatus::TRAP_ERROR) {
perror("LinkWrapper:ProcessInputFile:TRaPCOFFLibrary");
exit(-1);
}
#endif
if (trap_status == TRaPStatus::TRAP_ADDED)
return tmp_file;
return input_file;
} else if (_tcsicmp(dot, TEXT(".obj")) != 0 &&
_tcsicmp(dot, TEXT(".o")) != 0) // FIXME: create a list of allowed object file extensions (or let TRaPCOFFObject detect object files itself)
return input_file;
// Run TrapObj.exe <file.obj> <file.obj>
// TODO: parallelize this (using WaitForMultipleObjects)
// FIXME: output to a temporary file instead, and erase it afterwards
// FIXME: Trap.cpp leaks some memory
TString output_file = input_file;
COFFObject coff_file;
if (!coff_file.readFromFile(input_file.c_str()))
return output_file;
if (coff_file.createTRaPInfo()) {
output_file = TempFile::Create(TEXT(".obj"), true);
coff_file.writeToFile(output_file.c_str());
}
// Mark this input file if it's the first
if (first_object_name.empty())
first_object_name = input_file;
return output_file;
}
static void scanInputFile( // PROCESS NAME OF INPUT FILE
void )
{
char filename[ _MAX_PATH ]; // - scanned file name
size_t len; // - length of file name
char const *fnm; // - file name in command line
len = CmdScanFilename( &fnm );
++CompInfo.compfile_max;
if( CompInfo.compfile_max == CompInfo.compfile_cur ) {
if( WholeFName == NULL ) {
stvcpy( filename, fnm, len );
StripQuotes( filename );
WholeFName = FNameAdd( filename );
} else {
CErr1( ERR_CAN_ONLY_COMPILE_ONE_FILE );
}
}
}
bool OPT_GET_FILE_OPT // PARSE: OPTIONAL FILE NAME
( OPT_STRING **p ) // - target
{
size_t len;
char const *fname;
// handle leading option char specially
if( CmdRecogEquals() || !CmdDelimitChar() ) {
// specified an '=' so accept -this-is-a-file-name.fil or /tmp/ack.tmp
len = CmdScanFilename( &fname );
if( len != 0 ) {
addString( p, fname, len );
StripQuotes( (*p)->data );
} else {
OPT_CLEAN_STRING( p );
}
}
return( TRUE );
}
INT cmd_set (LPTSTR param)
{
LPTSTR p;
LPTSTR lpEnv;
LPTSTR lpOutput;
if ( !_tcsncmp (param, _T("/?"), 2) )
{
ConOutResPaging(TRUE,STRING_SET_HELP);
return 0;
}
param = (LPTSTR)skip_ws(param);
/* if no parameters, show the environment */
if (param[0] == _T('\0'))
{
lpEnv = (LPTSTR)GetEnvironmentStrings ();
if (lpEnv)
{
lpOutput = lpEnv;
while (*lpOutput)
{
if (*lpOutput != _T('='))
ConOutPuts(lpOutput);
lpOutput += _tcslen(lpOutput) + 1;
}
FreeEnvironmentStrings (lpEnv);
}
return 0;
}
/* the /A does *NOT* have to be followed by a whitespace */
if ( !_tcsnicmp (param, _T("/A"), 2) )
{
BOOL Success;
StripQuotes(param);
Success = seta_eval ( skip_ws(param+2) );
if(!Success)
{
/*might seem random but this is what windows xp does */
nErrorLevel = 9165;
}
return !Success;
}
if (!_tcsnicmp(param, _T("/P"), 2))
{
TCHAR value[1023];
param = GetQuotedString((LPTSTR)skip_ws(param + 2));
p = _tcschr(param, _T('='));
if (!p)
{
ConErrResPuts(STRING_SYNTAX_COMMAND_INCORRECT);
nErrorLevel = 1;
return 1;
}
*p++ = _T('\0');
ConOutPrintf(_T("%s"), GetQuotedString(p));
ConInString(value, 1023);
if (!*value || !SetEnvironmentVariable(param, value))
{
nErrorLevel = 1;
return 1;
}
return 0;
}
param = GetQuotedString(param);
p = _tcschr (param, _T('='));
if (p)
{
/* set or remove environment variable */
if (p == param)
{
/* handle set =val case */
ConErrResPuts(STRING_SYNTAX_COMMAND_INCORRECT);
nErrorLevel = 1;
return 1;
}
*p++ = _T('\0');
if (!SetEnvironmentVariable(param, *p ? p : NULL))
{
nErrorLevel = 1;
return 1;
}
}
else
{
/* display all environment variable with the given prefix */
BOOL bFound = FALSE;
while (_istspace(*param) || *param == _T(',') || *param == _T(';'))
param++;
p = _tcsrchr(param, _T(' '));
if (!p)
p = param + _tcslen(param);
*p = _T('\0');
lpEnv = GetEnvironmentStrings();
if (lpEnv)
{
lpOutput = lpEnv;
while (*lpOutput)
{
if (!_tcsnicmp(lpOutput, param, p - param))
{
ConOutPuts(lpOutput);
bFound = TRUE;
}
lpOutput += _tcslen(lpOutput) + 1;
}
FreeEnvironmentStrings(lpEnv);
}
if (!bFound)
{
ConErrResPrintf (STRING_PATH_ERROR, param);
nErrorLevel = 1;
return 1;
}
}
return 0;
}
/*
* DirReadParameters
*
* Parse the parameters and switches of the command line and exports them
*/
static BOOL
DirReadParam(LPTSTR Line, /* [IN] The line with the parameters & switches */
LPTSTR** params, /* [OUT] The parameters after parsing */
LPINT entries, /* [OUT] The number of parameters after parsing */
LPDIRSWITCHFLAGS lpFlags) /* [IN/OUT] The flags after calculating switches */
{
TCHAR cCurSwitch; /* The current switch */
TCHAR cCurChar; /* Current examing character */
TCHAR cCurUChar; /* Current upper examing character */
BOOL bNegative; /* Negative switch */
BOOL bPNegative; /* Negative switch parameter */
BOOL bIntoQuotes; /* A flag showing if we are in quotes (") */
LPTSTR ptrStart; /* A pointer to the first character of a parameter */
LPTSTR ptrEnd; /* A pointer to the last character of a parameter */
BOOL bOrderByNoPar; /* A flag to indicate /O with no switch parameter */
LPTSTR temp;
/* Initialize parameter array */
*params = NULL;
*entries = 0;
/* Initialize variables; */
cCurSwitch = _T(' ');
bNegative = FALSE;
bPNegative = FALSE;
/* We suppose that switch parameters
were given to avoid setting them to default
if the switch was not given */
bOrderByNoPar = FALSE;
/* Main Loop (see README_DIR.txt) */
/* scan the command line char per char, and we process its char */
while (*Line)
{
/* we save current character as it is and its upper case */
cCurChar = *Line;
cCurUChar = _totupper(*Line);
/* 1st section (see README_DIR.txt) */
/* When a switch is expecting */
if (cCurSwitch == _T('/'))
{
while (*Line == _T(' '))
Line++;
bNegative = (*Line == _T('-'));
Line += bNegative;
cCurChar = *Line;
cCurUChar = _totupper(*Line);
if ((cCurUChar == _T('A')) ||(cCurUChar == _T('T')) || (cCurUChar == _T('O')))
{
/* If positive, prepare for parameters... if negative, reset to defaults */
switch (cCurUChar)
{
case _T('A'):
lpFlags->stAttribs.dwAttribVal = 0L;
lpFlags->stAttribs.dwAttribMask = 0L;
if (bNegative)
lpFlags->stAttribs.dwAttribMask = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
break;
case _T('T'):
if (bNegative)
lpFlags->stTimeField.eTimeField = TF_MODIFIEDDATE;
break;
case _T('O'):
bOrderByNoPar = !bNegative;
lpFlags->stOrderBy.sCriteriaCount = 0;
break;
}
if (!bNegative)
{
/* Positive switch, so it can take parameters. */
cCurSwitch = cCurUChar;
Line++;
/* Skip optional leading colon */
if (*Line == _T(':'))
Line++;
continue;
}
}
else if (cCurUChar == _T('L'))
lpFlags->bLowerCase = ! bNegative;
else if (cCurUChar == _T('B'))
lpFlags->bBareFormat = ! bNegative;
else if (cCurUChar == _T('C'))
lpFlags->bTSeperator = ! bNegative;
else if (cCurUChar == _T('W'))
lpFlags->bWideList = ! bNegative;
else if (cCurUChar == _T('D'))
lpFlags->bWideListColSort = ! bNegative;
else if (cCurUChar == _T('N'))
lpFlags->bNewLongList = ! bNegative;
else if (cCurUChar == _T('P'))
lpFlags->bPause = ! bNegative;
else if (cCurUChar == _T('Q'))
lpFlags->bUser = ! bNegative;
else if (cCurUChar == _T('S'))
lpFlags->bRecursive = ! bNegative;
else if (cCurUChar == _T('X'))
lpFlags->bShortName = ! bNegative;
else if (cCurChar == _T('4'))
lpFlags->b4Digit = ! bNegative;
else if (cCurChar == _T('?'))
{
DirHelp();
return FALSE;
}
else
{
error_invalid_switch ((TCHAR)_totupper (*Line));
return FALSE;
}
/* Make sure there's no extra characters at the end of the switch */
if (Line[1] && Line[1] != _T('/') && Line[1] != _T(' '))
{
error_parameter_format(Line[1]);
return FALSE;
}
cCurSwitch = _T(' ');
}
else if (cCurSwitch == _T(' '))
{
/* 2nd section (see README_DIR.txt) */
/* We are expecting parameter or the unknown */
if (cCurChar == _T('/'))
cCurSwitch = _T('/');
else if (cCurChar == _T(' '))
/* do nothing */;
else
{
/* This is a file/directory name parameter. Find its end */
ptrStart = Line;
bIntoQuotes = FALSE;
while (*Line)
{
if (!bIntoQuotes && (*Line == _T('/') || *Line == _T(' ')))
break;
bIntoQuotes ^= (*Line == _T('"'));
Line++;
}
ptrEnd = Line;
/* Copy it to the entries list */
temp = cmd_alloc((ptrEnd - ptrStart + 1) * sizeof (TCHAR));
if(!temp)
return FALSE;
memcpy(temp, ptrStart, (ptrEnd - ptrStart) * sizeof (TCHAR));
temp[ptrEnd - ptrStart] = _T('\0');
StripQuotes(temp);
if(!add_entry(entries, params, temp))
{
cmd_free(temp);
freep(*params);
return FALSE;
}
cmd_free(temp);
continue;
}
}
else
{
/* 3rd section (see README_DIR.txt) */
/* We are waiting for switch parameters */
/* Check if there are no more switch parameters */
if ((cCurChar == _T('/')) || ( cCurChar == _T(' ')))
{
/* Wrong desicion path, reprocess current character */
cCurSwitch = _T(' ');
continue;
}
/* Process parameter switch */
switch(cCurSwitch)
{
case _T('A'): /* Switch parameters for /A (attributes filter) */
if(cCurChar == _T('-'))
bPNegative = TRUE;
else if(cCurUChar == _T('D'))
{
lpFlags->stAttribs.dwAttribMask |= FILE_ATTRIBUTE_DIRECTORY;
if (bPNegative)
lpFlags->stAttribs.dwAttribVal &= ~FILE_ATTRIBUTE_DIRECTORY;
else
lpFlags->stAttribs.dwAttribVal |= FILE_ATTRIBUTE_DIRECTORY;
}
else if(cCurUChar == _T('R'))
{
lpFlags->stAttribs.dwAttribMask |= FILE_ATTRIBUTE_READONLY;
if (bPNegative)
lpFlags->stAttribs.dwAttribVal &= ~FILE_ATTRIBUTE_READONLY;
else
lpFlags->stAttribs.dwAttribVal |= FILE_ATTRIBUTE_READONLY;
}
else if(cCurUChar == _T('H'))
{
lpFlags->stAttribs.dwAttribMask |= FILE_ATTRIBUTE_HIDDEN;
if (bPNegative)
lpFlags->stAttribs.dwAttribVal &= ~FILE_ATTRIBUTE_HIDDEN;
else
lpFlags->stAttribs.dwAttribVal |= FILE_ATTRIBUTE_HIDDEN;
}
else if(cCurUChar == _T('A'))
{
lpFlags->stAttribs.dwAttribMask |= FILE_ATTRIBUTE_ARCHIVE;
if (bPNegative)
lpFlags->stAttribs.dwAttribVal &= ~FILE_ATTRIBUTE_ARCHIVE;
else
lpFlags->stAttribs.dwAttribVal |= FILE_ATTRIBUTE_ARCHIVE;
}
else if(cCurUChar == _T('S'))
{
lpFlags->stAttribs.dwAttribMask |= FILE_ATTRIBUTE_SYSTEM;
if (bPNegative)
lpFlags->stAttribs.dwAttribVal &= ~FILE_ATTRIBUTE_SYSTEM;
else
lpFlags->stAttribs.dwAttribVal |= FILE_ATTRIBUTE_SYSTEM;
}
else
{
error_parameter_format((TCHAR)_totupper (*Line));
return FALSE;
}
break;
case _T('T'): /* Switch parameters for /T (time field) */
if(cCurUChar == _T('C'))
lpFlags->stTimeField.eTimeField= TF_CREATIONDATE ;
else if(cCurUChar == _T('A'))
lpFlags->stTimeField.eTimeField= TF_LASTACCESSEDDATE ;
else if(cCurUChar == _T('W'))
lpFlags->stTimeField.eTimeField= TF_MODIFIEDDATE ;
else
{
error_parameter_format((TCHAR)_totupper (*Line));
return FALSE;
}
break;
case _T('O'): /* Switch parameters for /O (order) */
/* Ok a switch parameter was given */
bOrderByNoPar = FALSE;
if(cCurChar == _T('-'))
bPNegative = TRUE;
else if(cCurUChar == _T('N'))
{
if (lpFlags->stOrderBy.sCriteriaCount < 3) lpFlags->stOrderBy.sCriteriaCount++;
lpFlags->stOrderBy.bCriteriaRev[lpFlags->stOrderBy.sCriteriaCount - 1] = bPNegative;
lpFlags->stOrderBy.eCriteria[lpFlags->stOrderBy.sCriteriaCount - 1] = ORDER_NAME;
}
else if(cCurUChar == _T('S'))
{
if (lpFlags->stOrderBy.sCriteriaCount < 3) lpFlags->stOrderBy.sCriteriaCount++;
lpFlags->stOrderBy.bCriteriaRev[lpFlags->stOrderBy.sCriteriaCount - 1] = bPNegative;
lpFlags->stOrderBy.eCriteria[lpFlags->stOrderBy.sCriteriaCount - 1] = ORDER_SIZE;
}
else if(cCurUChar == _T('G'))
{
if (lpFlags->stOrderBy.sCriteriaCount < 3) lpFlags->stOrderBy.sCriteriaCount++;
lpFlags->stOrderBy.bCriteriaRev[lpFlags->stOrderBy.sCriteriaCount - 1] = bPNegative;
lpFlags->stOrderBy.eCriteria[lpFlags->stOrderBy.sCriteriaCount - 1] = ORDER_DIRECTORY;
}
else if(cCurUChar == _T('E'))
{
if (lpFlags->stOrderBy.sCriteriaCount < 3) lpFlags->stOrderBy.sCriteriaCount++;
lpFlags->stOrderBy.bCriteriaRev[lpFlags->stOrderBy.sCriteriaCount - 1] = bPNegative;
lpFlags->stOrderBy.eCriteria[lpFlags->stOrderBy.sCriteriaCount - 1] = ORDER_EXTENSION;
}
else if(cCurUChar == _T('D'))
{
if (lpFlags->stOrderBy.sCriteriaCount < 3) lpFlags->stOrderBy.sCriteriaCount++;
lpFlags->stOrderBy.bCriteriaRev[lpFlags->stOrderBy.sCriteriaCount - 1] = bPNegative;
lpFlags->stOrderBy.eCriteria[lpFlags->stOrderBy.sCriteriaCount - 1] = ORDER_TIME;
}
else
{
error_parameter_format((TCHAR)_totupper (*Line));
return FALSE;
}
}
/* We check if we calculated the negative value and realese the flag */
if ((cCurChar != _T('-')) && bPNegative)
bPNegative = FALSE;
}
Line++;
}
/* /O with no switch parameters acts like /O:GN */
if (bOrderByNoPar)
{
lpFlags->stOrderBy.sCriteriaCount = 2;
lpFlags->stOrderBy.eCriteria[0] = ORDER_DIRECTORY;
lpFlags->stOrderBy.bCriteriaRev[0] = FALSE;
lpFlags->stOrderBy.eCriteria[1] = ORDER_NAME;
lpFlags->stOrderBy.bCriteriaRev[1] = FALSE;
}
return TRUE;
}
static
LPSTR *
split(
LPSTR s,
LPINT args)
{
LPSTR *arg;
LPSTR start;
LPSTR q;
INT ac;
INT_PTR len;
BOOL bQuoted;
arg = RtlAllocateHeap(ProcessHeap, 0 , sizeof(LPTSTR));
if (arg == NULL)
return NULL;
*arg = NULL;
ac = 0;
while (*s)
{
bQuoted = FALSE;
/* skip leading spaces */
while (*s && (isspace(*s) || iscntrl(*s)))
++s;
start = s;
/* the first character can be '/' */
if (*s == '/')
s++;
/* skip to next word delimiter or start of next option */
while (isprint(*s))
{
/* if quote (") then set bQuoted */
bQuoted ^= (*s == '\"');
/* Check if we have unquoted text */
if (!bQuoted)
{
/* check for separators */
if (isspace(*s) || (*s == '/'))
{
/* Make length at least one character */
if (s == start)
s++;
break;
}
}
s++;
}
/* a word was found */
if (s != start)
{
len = s - start;
q = RtlAllocateHeap(ProcessHeap, 0, len + 1);
if (q == NULL)
{
freep(arg);
return NULL;
}
memcpy(q, start, len);
q[len] = '\0';
StripQuotes(q);
if (!add_entry(&ac, &arg, q))
{
RtlFreeHeap(ProcessHeap, 0, q);
freep(arg);
return NULL;
}
RtlFreeHeap(ProcessHeap, 0, q);
}
}
*args = ac;
return arg;
}
//
//---------------------------------------------------------
//
BOOL CEasyBDoc::ReadFile(CArchive& ar)
{
int i,nRtnCode,nLineCode,nSectionCode;
int nIndex,nValue,nOffset,nLen;
int nPlayOffset, nPos;
int nBidIndex = 0;
CString strMessage,string,partString;
CCard* pCard;
double fValue;
BOOL bValue;
BOOL bFileInfoFound = FALSE;
// read
m_nLineNumber = 0;
try
{
for(;;)
{
nRtnCode = ReadLine(ar, strBuf);
next: if (nRtnCode == EOF)
break;
if (nRtnCode == 0)
continue;
if ((strBuf[0] == '#') || (strBuf[0] == '*'))
continue;
nLineLen = nRtnCode;
nLineCode = ParseLine(strBuf,nLineLen);
if (nLineCode < 0)
{
// section signifier
nSectionCode = -nLineCode;
if (nSectionCode == BLOCK_FILEINFO)
{
//
bFileInfoFound = TRUE;
// file info; skip this section
do {
nRtnCode = ReadLine(ar, strBuf);
} while ((nRtnCode != EOF) && (strBuf.Left(2) != "[["));
//
goto next;
}
//
if (nSectionCode == BLOCK_FILEDESC)
{
// file description; read until next block
m_strFileDescription.Empty();
do {
nRtnCode = ReadLine(ar, strBuf);
if (strBuf.Left(2) != "[[")
{
strBuf += "\r\n";
m_strFileDescription += strBuf;
}
} while ((nRtnCode != EOF) && (strBuf.Left(2) != "[["));
// trim ending CR/LF
int nLen = m_strFileDescription.GetLength();
if ((nLen >= 2) && (m_strFileDescription[nLen-1] == _T('\n')))
m_strFileDescription = m_strFileDescription.Left(nLen-2);
//
goto next;
}
else if (nSectionCode == BLOCK_COMMENTS)
{
// file comments
for (;;)
{
nRtnCode = ReadLine(ar, strBuf);
if ((nRtnCode == EOF) || (strBuf.Left(2) == "[["))
{
// update file comments dialog if it's open
CWnd* pWnd = pMAINFRAME->GetDialog(twFileCommentsDialog);
if (pWnd)
pWnd->SendMessage(WM_COMMAND, WMS_UPDATE_TEXT, FALSE);
goto next;
}
strBuf += "\r\n";
m_strFileComments += strBuf;
}
}
else if ((nSectionCode == BLOCK_SOUTH_ANALYSIS) ||
(nSectionCode == BLOCK_WEST_ANALYSIS) ||
(nSectionCode == BLOCK_NORTH_ANALYSIS) ||
(nSectionCode == BLOCK_EAST_ANALYSIS))
{
// don't bother to save the analysis
int nPlayer = nSectionCode - BLOCK_SOUTH_ANALYSIS;
CString strAnalysisBiffer;
do {
nRtnCode = ReadLine(ar, strBuf);
// strBuf += "\r\n";
// strAnalysisBiffer += strBuf;
} while ((nRtnCode != EOF) && (strBuf.Left(2) != "[["));
// m_player[nPlayer].SetValueString(tszAnalysis, strAnalysisBiffer);
goto next;
}
}
else if (nLineCode > 0)
{
// first skip spaces
nLen = strBuf.GetLength();
while ((nDataPosition < nLen) &&
(strBuf[nDataPosition] == ' '))
nDataPosition++;
if (nDataPosition >= nLen)
continue;
// then get data item
string = strBuf.Mid(nDataPosition);
nValue = atoi(string);
fValue = atof(string);
if ((string == "Yes") || (string == "1"))
bValue = TRUE;
else
bValue = FALSE;
switch(nLineCode)
{
case ITEM_PROGRAM_ID:
m_strFileProgTitle = string;
break;
case ITEM_MAJOR_VERSIONNO:
m_nFileProgMajorVersion = nValue;
break;
case ITEM_MINOR_VERSIONNO:
m_nFileProgMinorVersion = nValue;
break;
case ITEM_INCREMENT_VERSIONNO:
m_nFileProgIncrementVersion = nValue;
break;
case ITEM_BUILD_NUMBER:
m_nFileProgBuildNumber = nValue;
break;
case ITEM_BUILD_DATE:
m_strFileProgBuildDate = string;
break;
case ITEM_FILE_DATE:
m_strFileDate = string;
break;
// hand info, 10..19
case ITEM_CURRHAND_NORTH:
AssignCards(string,NORTH);
break;
case ITEM_CURRHAND_EAST:
AssignCards(string,EAST);
break;
case ITEM_CURRHAND_SOUTH:
AssignCards(string,SOUTH);
break;
case ITEM_CURRHAND_WEST:
AssignCards(string,WEST);
break;
case ITEM_ORIGHAND_NORTH:
AssignCards(string,NORTH,TRUE);
break;
case ITEM_ORIGHAND_EAST:
AssignCards(string,EAST,TRUE);
break;
case ITEM_ORIGHAND_SOUTH:
AssignCards(string,SOUTH,TRUE);
break;
case ITEM_ORIGHAND_WEST:
AssignCards(string,WEST,TRUE);
break;
// current round info
case ITEM_CURR_ROUND_LEAD:
m_nRoundLead = StringToPosition(string);
break;
case ITEM_NUM_CARDS_PLAYED_IN_ROUND:
m_numCardsPlayedInRound = nValue;
break;
case ITEM_TRICK_CARD_1:
m_pCurrTrick[0] = deck.GetCard(string);
break;
case ITEM_TRICK_CARD_2:
m_pCurrTrick[1] = deck.GetCard(string);
break;
case ITEM_TRICK_CARD_3:
m_pCurrTrick[2] = deck.GetCard(string);
break;
case ITEM_TRICK_CARD_4:
m_pCurrTrick[3] = deck.GetCard(string);
break;
// game status info
case ITEM_VIEW_STATUS_CODE:
pVIEW->SetCurrentMode((CEasyBView::ScreenMode)nValue);
break;
case ITEM_RUBBER_IN_PROGRESS:
theApp.SetValue(tbRubberInProgress, bValue);
break;
case ITEM_GAME_IN_PROGRESS:
// TEMP
// theApp.SetValue(tbGameInProgress, FALSE);
theApp.SetValue(tbGameInProgress, bValue);
break;
case ITEM_BIDDING_IN_PROGRESS:
theApp.SetValue(tbBiddingInProgress, bValue);
break;
case ITEM_HANDS_DEALT:
m_bHandsDealt = bValue;
break;
case ITEM_CONTRACT_SUIT:
nLen = string.GetLength();
m_nContractSuit = CharToSuit(string.GetAt(0));
break;
case ITEM_CONTRACT_LEVEL:
m_nContractLevel = nValue;
break;
case ITEM_CONTRACT_MODIFIER:
switch(nValue)
{
case 0:
m_bDoubled = FALSE;
m_bRedoubled = FALSE;
m_nContractModifier = 0;
break;
case 1:
m_bDoubled = TRUE;
m_bRedoubled = FALSE;
m_nContractModifier = 1;
break;
case 2:
m_bDoubled = FALSE;
m_bRedoubled = TRUE;
m_nContractModifier = 2;
break;
}
break;
case ITEM_DEALER:
m_nDealer = StringToPosition(string);
break;
case ITEM_NUM_BIDS:
// m_numBidsMade = nValue;
break;
case ITEM_BIDDING_HISTORY:
strBiddingHistory = string;
break;
case ITEM_DECLARER:
m_nDeclarer = StringToPosition(string);
m_nContractTeam = GetPlayerTeam(m_nDeclarer);
m_nDefendingTeam = (m_nContractTeam == NORTH_SOUTH)? EAST_WEST : NORTH_SOUTH;
break;
// game record
case ITEM_NUM_TRICKS_PLAYED:
m_numTricksPlayed = nValue;
break;
case ITEM_NUM_TRICKS_WON_NS:
m_numTricksWon[0] = nValue;
break;
case ITEM_NUM_TRICKS_WON_EW:
m_numTricksWon[1] = nValue;
break;
case ITEM_GAME_LEAD:
m_nGameLead = StringToPosition(string);
break;
case ITEM_GAME_TRICK_1: case ITEM_GAME_TRICK_2:
case ITEM_GAME_TRICK_3: case ITEM_GAME_TRICK_4:
case ITEM_GAME_TRICK_5: case ITEM_GAME_TRICK_6:
case ITEM_GAME_TRICK_7: case ITEM_GAME_TRICK_8:
case ITEM_GAME_TRICK_9: case ITEM_GAME_TRICK_10:
case ITEM_GAME_TRICK_11: case ITEM_GAME_TRICK_12:
case ITEM_GAME_TRICK_13:
try
{
nIndex = nLineCode - ITEM_GAME_TRICK_1;
nOffset = 0;
nLen = string.GetLength();
// first read the lead player for the trick
partString = string.Mid(nOffset);
m_nTrickLead[nIndex] = StringToPosition(partString);
nOffset = string.Find(' ');
//
for(i=0;i<4;i++)
{
while((nOffset < nLen) && (string[nOffset] == ' '))
nOffset++;
partString = string.Mid(nOffset);
nOffset += 2;
if (partString.IsEmpty())
{
strMessage.Format("Incomplete Trick record at line %d;\n%s",
m_nLineNumber, string);
AfxMessageBox(strMessage);
break;
}
//
if (partString.Left(2) == "--")
{
m_pGameTrick[nIndex][i] = NULL;
}
else
{
pCard = deck.GetCard(partString);
m_pGameTrick[nIndex][i] = pCard;
}
}
// insert the trick record into the game record
// in the proper order
nPlayOffset = nIndex * 4;
nPos = m_nTrickLead[nIndex];
for(i=0;i<4;i++)
{
CCard* pCard = m_pGameTrick[nIndex][nPos];
if (pCard)
m_nPlayRecord[nPlayOffset+i] = pCard->GetDeckValue();
nPos = GetNextPlayer(nPos);
}
// and finally read the trick's winner
while((nOffset < nLen) && (string[nOffset] == ' '))
nOffset++;
partString = string.Mid(nOffset);
m_nTrickWinner[nIndex] = StringToPosition(partString);
}
catch(...)
{
// error
}
break;
// match info
case ITEM_SCORE_NS_BONUS:
m_nBonusScore[NORTH_SOUTH] = nValue;
break;
case ITEM_SCORE_NS_GAME0:
m_nGameScore[0][NORTH_SOUTH] = nValue;
break;
case ITEM_SCORE_NS_GAME1:
m_nGameScore[1][NORTH_SOUTH] = nValue;
break;
case ITEM_SCORE_NS_GAME2:
m_nGameScore[2][NORTH_SOUTH] = nValue;
break;
case ITEM_SCORE_NS_GAMES_WON:
m_numGamesWon[NORTH_SOUTH] = nValue;
break;
case ITEM_SCORE_EW_BONUS:
m_nBonusScore[EAST_WEST] = nValue;
break;
case ITEM_SCORE_EW_GAME0:
m_nGameScore[0][EAST_WEST] = nValue;
break;
case ITEM_SCORE_EW_GAME1:
m_nGameScore[1][EAST_WEST] = nValue;
break;
case ITEM_SCORE_EW_GAME2:
m_nGameScore[2][EAST_WEST] = nValue;
break;
case ITEM_SCORE_EW_GAMES_WON:
m_numGamesWon[EAST_WEST] = nValue;
break;
case ITEM_CURRENT_GAME_INDEX:
m_nCurrGame = nValue-1;
break;
case ITEM_BONUS_SCORE_RECORD:
m_strArrayBonusPointsRecord.Add(StripQuotes(string));
break;
case ITEM_GAME_SCORE_RECORD:
m_strArrayTrickPointsRecord.Add(StripQuotes(string));
break;
// misc info
case ITEM_AUTOSHOW_COMMENTS:
m_bShowCommentsUponOpen = bValue;
break;
case ITEM_AUTOSHOW_BID_HISTORY:
m_bShowBidHistoryUponOpen = bValue;
break;
case ITEM_AUTOSHOW_PLAY_HISTORY:
m_bShowPlayHistoryUponOpen = bValue;
break;
case ITEM_AUTOSHOW_ANALYSES:
m_bShowAnalysesUponOpen = bValue;
break;
}
}
else
{
/*
// unknown line
strMessage.Format("Found Unknown line\n%s.\nContinue?",strBuf);
if (AfxMessageBox(strMessage, MB_ICONEXCLAMATION | MB_OKCANCEL) == IDCANCEL)
break;
*/
}
}
}
catch(...)
{
// handle any improper file error here
ClearAllInfo();
// AfxMessageBox("An error ocurred while reading the game file.");
return FALSE;
}
// see if this was a valid file
if (!bFileInfoFound)
{
AfxMessageBox("This is not a proper Easy Bridge game file.");
AfxThrowFileException(CFileException::generic);
}
//
// do some sanity checks
//
m_nContract = MAKEBID(m_nContractSuit, m_nContractLevel);
if (!ISPLAYER(m_nDeclarer) || !ISBID(m_nContract))
theApp.SetValue(tbGameInProgress, FALSE);
//
// parse the bidding history
//
if (!ISPLAYER(m_nDeclarer))
m_nDeclarer = SOUTH;
nPos = m_nDeclarer;
m_nCurrPlayer = nPos;
int nTeam = GetPlayerTeam(nPos);
nOffset = 0;
//
nLen = strBiddingHistory.GetLength();
for(i=0;;i++)
{
// skip leading spaces
while((nOffset < nLen) && (strBiddingHistory[nOffset] == ' '))
nOffset++;
if (nOffset >= nLen)
break;
// grab the next bid
partString = strBiddingHistory.Mid(nOffset);
int nBid = ContractStringToBid(partString);
// and record it
m_nBiddingHistory[m_numBidsMade] = nBid;
m_numBidsMade++;
m_nCurrPlayer = GetNextPlayer(m_nCurrPlayer);
int nBiddingRound = i % 4;
m_nBidsByPlayer[nPos][nBiddingRound] = nBid;
// see if this is an actual numeric bid
if (ISBID(nBid))
{
m_nValidBidHistory[m_numValidBidsMade] = nBid;
m_numValidBidsMade++;
m_nLastValidBid = nBid;
m_nLastValidBidTeam = nTeam;
}
// skip over remainder of current bid string
while((nOffset < nLen) && (strBiddingHistory[nOffset] != ' '))
nOffset++;
// and move to the next player
nPos = GetNextPlayer(nPos);
nTeam = GetOpposingTeam(nTeam);
}
if (ISBID(m_nContract))
UpdateBiddingHistory();
// tally some figures
m_nTotalScore[0] = m_nGameScore[0][0] + m_nGameScore[1][0] +
m_nGameScore[2][0] + m_nBonusScore[0];
m_nTotalScore[1] = m_nGameScore[0][1] + m_nGameScore[1][1] +
m_nGameScore[2][1] + m_nBonusScore[1];
// vulnerability
if ((m_numGamesWon[0] > 0) && (m_numGamesWon[1] > 0))
{
m_nVulnerableTeam = BOTH;
m_bVulnerable[0] = m_bVulnerable[1] = TRUE;
}
else if (m_numGamesWon[0] > 0)
{
m_nVulnerableTeam = NORTH_SOUTH;
m_bVulnerable[0] = TRUE;
}
else if (m_numGamesWon[1] > 0)
{
m_nVulnerableTeam = EAST_WEST;
m_bVulnerable[1] = TRUE;
}
else
{
m_nVulnerableTeam = NEITHER;
}
//
// set contract info
//
m_nContract = ContractParamsToBid(m_nContractSuit,m_nContractLevel);
m_nTrumpSuit = m_nContractSuit;
m_nBiddingRound = nBidIndex;
// set play info
if (ISBID(m_nContract) && ISPLAYER(m_nDeclarer))
{
// contract has been reached
m_nDummy = GetPartner((int) m_nDeclarer);
m_nGameLead = GetNextPlayer(m_nDeclarer);
m_nRoundLead = m_nGameLead;
m_nCurrPlayer = m_nRoundLead;
m_nTrickLead[0] = m_nRoundLead;
// m_pPlayer[m_nDummy]->SetDummyFlag(TRUE);
// m_pPlayer[m_nDeclarer]->SetDeclarerFlag(TRUE);
}
else
{
// contract has NOT been reached, so restart
m_nCurrPlayer = m_nDealer;
m_numBidsMade = 0;
}
// restore initial hands (temp?)
for(i=0;i<4;i++)
m_pPlayer[i]->RestoreInitialHand();
// not reviewing game
m_bReviewingGame = FALSE;
// all done
return TRUE;
}
static const char *ParserJSONItems(int ParserType, const char *Doc, ListNode *Parent, int IndentLevel)
{
const char *ptr;
char *Token=NULL, *PrevToken=NULL, *Name=NULL;
ListNode *Node;
int BreakOut=FALSE;
ptr=GetToken(Doc, JSON_TOKENS, &Token,GETTOKEN_MULTI_SEP|GETTOKEN_INCLUDE_SEP|GETTOKEN_HONOR_QUOTES);
while (ptr)
{
switch (*Token)
{
case '[':
ptr=ParserAddNewStructure(ParserType, ptr, Parent, ITEM_ARRAY, Name, IndentLevel+1);
Name=CopyStr(Name,"");
break;
case ']':
if (ptr && (*ptr==',')) ptr++;
BreakOut=TRUE;
break;
case '{':
ptr=ParserAddNewStructure(ParserType, ptr, Parent, ITEM_ENTITY, Name, IndentLevel+1);
Name=CopyStr(Name,"");
break;
case '}':
//we can have an item right before a '}' that doesn't terminate with a ',' becasue the '}' terminates it
if (StrValid(Name) && StrValid(PrevToken))
{
Node=ListAddNamedItem(Parent, Name, CopyStr(NULL, PrevToken));
Node->ItemType=ITEM_VALUE;
}
if (ptr && (*ptr==',')) ptr++;
BreakOut=TRUE;
break;
case ':':
Name=CopyStr(Name, PrevToken);
break;
case '\r':
//ignore and do nothing
break;
case '\n':
case ',':
Node=ListAddNamedItem(Parent, Name, CopyStr(NULL, PrevToken));
Node->ItemType=ITEM_VALUE;
break;
default:
StripTrailingWhitespace(Token);
StripQuotes(Token);
PrevToken=CopyStr(PrevToken, Token);
break;
}
if (BreakOut) break;
while (isspace(*ptr)) ptr++;
ptr=GetToken(ptr, JSON_TOKENS, &Token,GETTOKEN_MULTI_SEP|GETTOKEN_INCLUDE_SEP|GETTOKEN_HONOR_QUOTES);
}
DestroyString(PrevToken);
DestroyString(Token);
DestroyString(Name);
return(ptr);
}
/*
===============
Cmd_Echo_f
Just prints the rest of the line to the console
===============
*/
void Cmd_Echo_f (void)
{
Com_Printf ("%s\n", LOG_GENERAL, StripQuotes(Cmd_Args()));
}
static int ProcOptions( char *str, int *level )
/*********************************************/
{
char *save[MAX_NESTING];
char *buffers[MAX_NESTING];
if( str != NULL ) {
for( ;; ) {
while( *str == ' ' || *str == '\t' )
++str;
if( *str == '@' && *level < MAX_NESTING ) {
save[(*level)++] = CollectEnvOrFileName( str + 1 );
buffers[*level] = NULL;
str = getenv( ParamBuf );
if( str == NULL ) {
str = ReadIndirectFile();
buffers[*level] = str;
}
if( str != NULL )
continue;
str = save[--(*level)];
}
if( *str == '\0' ) {
if( *level == 0 )
break;
if( buffers[*level] != NULL ) {
AsmFree( buffers[*level] );
buffers[*level] = NULL;
}
str = save[--(*level)];
continue;
}
if( *str == '-' || *str == SwitchChar ) {
str = ProcessOption(str+1, str);
} else { /* collect file name */
char *beg, *p;
int len;
beg = str;
if( *str == '"' ) {
for( ;; ) {
++str;
if( *str == '"' ) {
++str;
break;
}
if( *str == '\0' )
break;
if( *str == '\\' ) {
++str;
}
}
} else {
for( ;; ) {
if( *str == '\0' )
break;
if( *str == ' ' )
break;
if( *str == '\t' )
break;
#if !defined(__UNIX__)
if( *str == SwitchChar )
break;
#endif
++str;
}
}
len = str-beg;
p = (char *) AsmAlloc( len + 1 );
memcpy( p, beg, len );
p[ len ] = '\0';
StripQuotes( p );
get_fname( p, ASM );
AsmFree(p);
}
}
}
return( 0 );
}
BOOL
PerformRedirection(REDIRECTION *RedirList)
{
REDIRECTION *Redir;
LPTSTR Filename;
HANDLE hNew;
UINT DupNumber;
static SECURITY_ATTRIBUTES SecAttr = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
/* Some parameters used for read, write, and append, respectively */
static const DWORD dwAccess[] = {
GENERIC_READ,
GENERIC_WRITE,
GENERIC_WRITE
};
static const DWORD dwShareMode[] = {
FILE_SHARE_READ | FILE_SHARE_WRITE,
FILE_SHARE_READ,
FILE_SHARE_READ
};
static const DWORD dwCreationDisposition[] = {
OPEN_EXISTING,
CREATE_ALWAYS,
OPEN_ALWAYS
};
for (Redir = RedirList; Redir; Redir = Redir->Next)
{
Filename = DoDelayedExpansion(Redir->Filename);
if (!Filename)
goto redir_error;
StripQuotes(Filename);
if (*Filename == _T('&'))
{
DupNumber = Filename[1] - _T('0');
if (DupNumber >= 10 ||
!DuplicateHandle(GetCurrentProcess(),
GetHandle(DupNumber),
GetCurrentProcess(),
&hNew,
0,
TRUE,
DUPLICATE_SAME_ACCESS))
{
hNew = INVALID_HANDLE_VALUE;
}
}
else
{
hNew = CreateFile(Filename,
dwAccess[Redir->Type],
dwShareMode[Redir->Type],
&SecAttr,
dwCreationDisposition[Redir->Type],
0,
NULL);
}
if (hNew == INVALID_HANDLE_VALUE)
{
ConErrResPrintf(Redir->Type == REDIR_READ ? STRING_CMD_ERROR1 : STRING_CMD_ERROR3,
Filename);
cmd_free(Filename);
redir_error:
/* Undo all the redirections before this one */
UndoRedirection(RedirList, Redir);
return FALSE;
}
if (Redir->Type == REDIR_APPEND)
SetFilePointer(hNew, 0, NULL, FILE_END);
Redir->OldHandle = GetHandle(Redir->Number);
SetHandle(Redir->Number, hNew);
TRACE("%d redirected to: %s\n", Redir->Number, debugstr_aw(Filename));
cmd_free(Filename);
}
return TRUE;
}
