NS_IMETHODIMP
nsCommandLine::HandleFlagWithParam(const nsAString& aFlag, bool aCaseSensitive,
nsAString& aResult)
{
nsresult rv;
int32_t found;
rv = FindFlag(aFlag, aCaseSensitive, &found);
NS_ENSURE_SUCCESS(rv, rv);
if (found == -1) {
aResult.SetIsVoid(true);
return NS_OK;
}
if (found == int32_t(mArgs.Length()) - 1) {
return NS_ERROR_INVALID_ARG;
}
++found;
{ // scope for validity of |param|, which RemoveArguments call invalidates
const nsString& param = mArgs[found];
if (!param.IsEmpty() && param.First() == '-') {
return NS_ERROR_INVALID_ARG;
}
aResult = param;
}
RemoveArguments(found - 1, found);
return NS_OK;
}
//==========================================================================
//
// Processes a flag. Also used by olddecorations.cpp
//
//==========================================================================
void HandleActorFlag(FScanner &sc, Baggage &bag, const char *part1, const char *part2, int mod)
{
FFlagDef *fd;
if ( (fd = FindFlag (bag.Info, part1, part2)) )
{
AActor *defaults = (AActor*)bag.Info->Defaults;
if (fd->structoffset == -1) // this is a deprecated flag that has been changed into a real property
{
HandleDeprecatedFlags(defaults, bag.Info, mod=='+', fd->flagbit);
}
else
{
ModActorFlag(defaults, fd, mod == '+');
}
}
else
{
if (part2 == NULL)
{
sc.ScriptMessage("\"%s\" is an unknown flag\n", part1);
}
else
{
sc.ScriptMessage("\"%s.%s\" is an unknown flag\n", part1, part2);
}
FScriptPosition::ErrorCounter++;
}
}
NS_IMETHODIMP
nsCommandLine::HandleFlagWithParam(const nsAString& aFlag, bool aCaseSensitive,
nsAString& aResult)
{
nsresult rv;
int32_t found;
rv = FindFlag(aFlag, aCaseSensitive, &found);
NS_ENSURE_SUCCESS(rv, rv);
if (found == -1) {
aResult.SetIsVoid(true);
return NS_OK;
}
if (found == int32_t(mArgs.Length()) - 1) {
return NS_ERROR_INVALID_ARG;
}
++found;
if (mArgs[found].First() == '-') {
return NS_ERROR_INVALID_ARG;
}
aResult = mArgs[found];
RemoveArguments(found - 1, found);
return NS_OK;
}
string GFlagsHandler::SetFlags(
const vector<pair<string, string> >& new_flag_values) {
vector<CommandLineFlagInfo> flags_info;
google::GetAllFlags(&flags_info);
string error_msg;
for (vector<pair<string, string> >::const_iterator iter =
new_flag_values.begin(); iter != new_flag_values.end(); ++iter) {
if (!FindFlag(iter->first, flags_info)) {
// Failed to find this flag
error_msg.append("This flag does not exist: ")
.append(iter->first)
.append("\n");
continue;
}
// It's thread safe too
LOG(INFO) << google::SetCommandLineOptionWithMode(iter->first.c_str(),
iter->second.c_str(),
google::SET_FLAGS_VALUE);
}
return error_msg == "" ? "OK" : error_msg;
}
FFlagDef *FindFlag (const PClass *type, const char *part1, const char *part2)
{
FFlagDef *def;
size_t i;
if (part2 == NULL)
{ // Search all lists
for (i = 0; i < NUM_FLAG_LISTS; ++i)
{
if (type->IsDescendantOf (*FlagLists[i].Type))
{
def = FindFlag (FlagLists[i].Defs, FlagLists[i].NumDefs, part1);
if (def != NULL)
{
return def;
}
}
}
}
else
{ // Search just the named list
for (i = 0; i < NUM_FLAG_LISTS; ++i)
{
if (stricmp ((*FlagLists[i].Type)->TypeName.GetChars(), part1) == 0)
{
if (type->IsDescendantOf (*FlagLists[i].Type))
{
return FindFlag (FlagLists[i].Defs, FlagLists[i].NumDefs, part2);
}
else
{
return NULL;
}
}
}
}
return NULL;
}
void AdminCache::OnSourceModLevelChange(const char *mapName)
{
int i;
AdminFlag flag;
/* For now, we only read these once per level. */
s_FlagReader.LoadLevels();
memset(g_ReverseFlags, '?', sizeof(g_ReverseFlags));
for (i = 0; i < 26; i++)
{
if (FindFlag('a' + i, &flag))
{
g_ReverseFlags[flag] = 'a' + i;
}
}
}
NS_IMETHODIMP
nsCommandLine::HandleFlag(const nsAString& aFlag, bool aCaseSensitive,
bool *aResult)
{
nsresult rv;
int32_t found;
rv = FindFlag(aFlag, aCaseSensitive, &found);
NS_ENSURE_SUCCESS(rv, rv);
if (found == -1) {
*aResult = false;
return NS_OK;
}
*aResult = true;
RemoveArguments(found, found);
return NS_OK;
}
void AdminCache::OnSimillimumLevelChange(const char *mapName)
{
int i;
AdminFlag flag;
/* For now, we only read these once per level. */
s_FlagReader.LoadLevels();
for (i = 0; i < 26; i++)
{
if (FindFlag('a' + i, &flag))
{
g_ReverseFlags[flag] = 'a' + i;
}
else
{
g_ReverseFlags[flag] = '?';
}
}
}
FlagBits AdminCache::ReadFlagString(const char *flags, const char **end)
{
FlagBits bits = 0;
while (flags && (*flags != '\0'))
{
AdminFlag flag;
if (!FindFlag(*flags, &flag))
{
break;
}
bits |= FlagArrayToBits(&flag, 1);
flags++;
}
if (end)
{
*end = flags;
}
return bits;
}
void ProcessSoundLine(char buffer[])
{
short sidx,eidx;
short done=0;
long TODO,flag;
RIFF_FILE *WaveFile=NULL;
SoundList *rec;
char ID[32];
sidx=0;
eidx=0;
// Find Token
while(buffer[sidx+eidx] != ',' && buffer[sidx+eidx] > ' ' && buffer[sidx+eidx] != '#')
eidx++;
if(!eidx)
return;
buffer[eidx]=0;
TODO=FindTODO(&buffer[sidx]);
if(!TODO)
return;
sidx=eidx+1;
eidx=0;
// Handle Token
if(TODO == LOAD_SOUND)
{
// Find ID
while((buffer[sidx] <= ' ' || buffer[sidx] == ',') && buffer[sidx])
sidx++;
if(!buffer[sidx] || buffer[sidx] == '#')
return;
eidx=0;
while(buffer[sidx+eidx] > ' ' && buffer[sidx+eidx] != ',')
eidx++;
if(!eidx)
return;
memset(ID,0,32);
memcpy(ID,&buffer[sidx],min(eidx,32));
sidx+=eidx+1;
// Find filename
while(buffer[sidx] != '"' && buffer[sidx])
sidx++;
if(buffer[sidx] != '"')
return;
eidx=0;
sidx++;
while(buffer[sidx+eidx] != '"' && buffer[sidx+eidx] >= ' ')
eidx++;
if(buffer[sidx+eidx] != '"')
return;
buffer[sidx+eidx]=0;
printf("Processing (%s)...",&buffer[sidx]);
WaveFile=LoadRiff(&buffer[sidx]);
if(!WaveFile)
{
printf("Failed\n");
return;
}
printf("Adding (%s) (%1ld)\n",&buffer[sidx],WaveFile->Size);
rec=new SoundList;
memset(rec,0,sizeof(SoundList));
rec->Sound=WaveFile;
rec->Size=WaveFile->Size;
rec->Header.Type=_RSC_IS_SOUND_;
memcpy(rec->Header.ID,ID,32);
rec->Header.headersize=WaveFile->Headersize;
rec->Header.Channels=WaveFile->Header->nChannels;
rec->Header.SoundType=WaveFile->Header->wFormatTag;
sidx+=eidx+1;
eidx=0;
// Get flags
while(!done)
{
while((buffer[sidx] == ',' || buffer[sidx] <= ' ') && buffer[sidx])
sidx++;
if(buffer[sidx] < ' ')
done=1;
else
{
while(buffer[sidx+eidx] > ' ' && buffer[sidx+eidx] != ',')
eidx++;
buffer[sidx+eidx]=0;
if(eidx)
{
flag=FindFlag(&buffer[sidx]);
rec->Header.flags |= flag;
}
else
done=1;
sidx +=eidx+1;
eidx=0;
}
}
HeaderSize+=sizeof(SoundFmt);
DataSize+=rec->Size;
SoundTable->Add(UniqueID++,rec);
}
}
BitfieldFlag*
Bitfield::FindFlag ( const char* name )
{
return FindFlag ( StringCrc32 ( name ) );
}
T_void CompileArgs(T_byte8 *p_args, T_word16 numArgs)
{
char args[10][100] ;
T_word16 i, j, k ;
T_byte8 arg[100] ;
T_sword32 value ;
T_word16 len ;
p_args++ ;
if (numArgs == 0)
p_args++ ;
for (i=0; i<numArgs; i++) {
j = 0 ;
while ((*p_args != ',') && (*p_args != ')')) {
if (j==100) {
printf("Argument %d on line %d too long!\n",
i+1,
G_line) ;
G_errors++ ;
return ;
}
args[i][j++] = *(p_args++) ;
}
if ((p_args[0] == ')') && ((i+1) != numArgs)) {
printf("Error! Wrong number of arguments on line %d\n",
G_line) ;
G_errors++ ;
return ;
}
args[i][j] = '\0' ;
p_args++ ;
}
if (p_args[-1] != ')') {
printf("Error! Wrong number of arguments on line %d\n",
G_line) ;
G_errors ++ ;
return ;
}
for (i=0; i<numArgs; i++) {
//printf("arg[%d] = '%s'\n", i, args[i]) ;
strcpy(arg, args[i]) ;
Strip(arg) ;
if ((arg[0] == '-') || (isdigit(arg[0]))) {
/* Arg is Number. */
value = atol(arg) ;
OutputNumber(value) ;
} else if (arg[0] == '&') {
/* Event. */
value = atol(arg+1) ;
if (!((value >= 1) && (value <= 3))) {
printf("Error! Event parameter (%ld) out of range (1-3) on line %d!\n",
value,
G_line) ;
G_errors++ ;
return ;
}
OutputByte(SCRIPT_DATA_TYPE_EVENT_PARAMETER) ;
OutputByte((T_byte8)value) ;
} else if (arg[0] == QUOTE_START) {
len = strlen(arg)-2 ;
if (len >= 80) {
printf("Error! String too long on line %d!\n", G_line) ;
G_errors++ ;
return ;
}
OutputByte(SCRIPT_DATA_TYPE_STRING) ;
OutputByte((T_byte8)len) ;
for (k=0; k<len; k++) {
OutputByte(arg[1+k]) ;
}
} else {
/* Try doing a flag name. */
value = FindFlag(arg) ;
if (value != -1) {
OutputByte(SCRIPT_DATA_TYPE_FLAG) ;
OutputByte((T_byte8)value) ;
} else {
value = FindVar(arg) ;
if (value != -1) {
value = G_vars[value].number ;
OutputByte(SCRIPT_DATA_TYPE_VARIABLE) ;
OutputByte(((T_byte8 *)&value)[0]) ;
OutputByte(((T_byte8 *)&value)[1]) ;
} else {
//printf("Searching for defnum: %s\n", arg) ;
value = FindDefnum(arg) ;
if (value != -1) {
value = G_defnums[value].number ;
//printf("Output defnum: %s %ld\n", arg, value) ;
OutputNumber(value) ;
} else {
printf("Error! Unknown argument '%s' on line %d\n",
arg,
G_line) ;
G_errors++ ;
return ;
}
}
}
}
}
}
