bool ScriptingBridge::InvokeMethod(const std::string& method) {
size_t current_pos = 0;
const std::string method_name = ScanToken(method, ¤t_pos);
MethodDictionary::iterator method_iter;
method_iter = method_dictionary_.find(method_name);
if (method_iter != method_dictionary_.end()) {
// Pull out the method parameters and build a dictionary that maps
// parameter names to values.
std::map<std::string, std::string> param_dict;
while (current_pos != std::string::npos) {
const std::string parameter = ScanToken(method, ¤t_pos);
if (parameter.length()) {
std::string param_name;
std::string param_value;
if (ParseParameter(parameter, ¶m_name, ¶m_value)) {
// Note that duplicate parameter names will override each other. The
// last one in the method string will be used.
param_dict[param_name] = param_value;
}
}
}
(*method_iter->second).Execute(*this, param_dict);
return true;
}
return false;
}
ECode CHttpAuthHeader::ParseParameter(
/* [in] */ const String& parameter)
{
if (parameter != NULL) {
// here, we are looking for the 1st occurence of '=' only!!!
Int32 i = parameter.IndexOf('=');
if (i >= 0) {
String token = parameter.Substring(0, i).Trim();
String value =
TrimDoubleQuotesIfAny(parameter.Substring(i + 1).Trim());
if (HttpLog::LOGV) {
HttpLog::V(String("HttpAuthHeader.parseParameter(): token: ") + token
+ String(" value: ") + value);
}
if (token.EqualsIgnoreCase(REALM_TOKEN)) {
mRealm = value;
} else {
if (mScheme == DIGEST) {
ParseParameter(token, value);
}
}
}
}
return NOERROR;
}
int GetParameterInt(const char* parameter)
{
char* tmp = GetParameter(parameter);
if(tmp == NULL)
{
fprintf(stderr, "No parameter gotten, returning 0\n");
return 0;
}
return ParseParameter(tmp);
}
list<Parametro*> Sintactico::ParseParameterList()
{
list<Parametro*> lista_params;
list<Parametro*>::iterator it;
Parametro* parametro = ParseParameter();
lista_params = _ParseParameterList();
it = lista_params.begin();
lista_params.insert(it,parametro);
return lista_params;
}
std::string Window_Message::ParseCommandCode(bool& success) {
int parameter;
bool is_valid;
uint32_t cmd_char = *text_index;
success = true;
switch (tolower(cmd_char)) {
case 'n':
// Output Hero name
parameter = ParseParameter(is_valid);
if (is_valid) {
Game_Actor* actor = NULL;
if (parameter == 0) {
// Party hero
actor = Main_Data::game_party->GetActors()[0];
} else {
actor = Game_Actors::GetActor(parameter);
}
if (actor != NULL) {
return actor->GetName();
}
}
break;
case 'v':
// Show Variable value
parameter = ParseParameter(is_valid);
if (is_valid && Game_Variables.IsValid(parameter)) {
std::stringstream ss;
ss << Game_Variables[parameter];
return ss.str();
} else {
// Invalid Var is always 0
return "0";
}
default:;
// When this happens text_index was not on a \ during calling
}
success = false;
return "";
}
std::string Window_Message::ParseCommandCode(bool& success, int& parameter) {
bool is_valid;
uint32_t cmd_char = *text_index;
success = true;
parameter = -1;
switch (tolower(cmd_char)) {
case 'n':
// Output Hero name
parameter = ParseParameter(is_valid);
if (is_valid) {
Game_Actor* actor = NULL;
if (parameter == 0) {
// Party hero
if (Main_Data::game_party->GetBattlerCount() > 0) {
actor = Main_Data::game_party->GetActors()[0];
}
} else {
actor = Game_Actors::GetActor(parameter);
}
if (actor != NULL) {
return actor->GetName();
}
}
break;
case 'v':
// Show Variable value
parameter = ParseParameter(is_valid);
if (is_valid) {
return std::to_string(Game_Variables.Get(parameter));
} else {
// Invalid Var is always 0
return "0";
}
default:;
// When this happens text_index was not on a \ during calling
}
success = false;
return "";
}
ECode CHttpAuthHeader::ParseParameters(
/* [in] */ const String& parameters)
{
if (HttpLog::LOGV) {
HttpLog::V(String("HttpAuthHeader.parseParameters(): parameters: ") + parameters);
}
if (parameters != NULL) {
Int32 i;
String loParameters = parameters;
do {
i = loParameters.IndexOf(',');
if (i < 0) {
// have only one parameter
ParseParameter(loParameters);
} else {
ParseParameter(loParameters.Substring(0, i));
loParameters = loParameters.Substring(i + 1);
}
} while (i >= 0);
}
return NOERROR;
}
list<Parametro*> Sintactico::_ParseParameterList()
{
list<Parametro*> lista_params;
if ( proximo_token.GetTipo() == punt_coma )
{
proximo_token = analizador_lexico->ObtenerSiguienteToken();
Parametro* parametro = ParseParameter();
lista_params = _ParseParameterList();
list<Parametro*>::iterator it = lista_params.begin();
lista_params.insert(it,parametro);
}
return lista_params;
}
bool cChannel::StringToParameters(const char *s)
{
while (s && *s) {
switch (toupper(*s)) {
case 'B': s = ParseParameter(s, bandwidth, BandwidthValues); break;
case 'C': s = ParseParameter(s, coderateH, CoderateValues); break;
case 'D': s = ParseParameter(s, coderateL, CoderateValues); break;
case 'G': s = ParseParameter(s, guard, GuardValues); break;
case 'H': polarization = *s++; break;
case 'I': s = ParseParameter(s, inversion, InversionValues); break;
case 'L': polarization = *s++; break;
case 'M': s = ParseParameter(s, modulation, ModulationValues); break;
case 'R': polarization = *s++; break;
case 'T': s = ParseParameter(s, transmission, TransmissionValues); break;
case 'V': polarization = *s++; break;
case 'Y': s = ParseParameter(s, hierarchy, HierarchyValues); break;
default: esyslog("ERROR: unknown parameter key '%c'", *s);
return false;
}
}
return true;
}
static void ParseArgListDef(FScanner &sc, PClassActor *cls,
TArray<PType *> &args, TArray<DWORD> &argflags)
{
if (!sc.CheckToken(')'))
{
while (sc.TokenType != ')')
{
int flags = 0;
PType *type = NULL;
PClass *restrict = NULL;
// Retrieve flags before type name
for (;;)
{
if (sc.CheckToken(TK_Coerce) || sc.CheckToken(TK_Native))
{
}
else
{
break;
}
}
// Read the variable type
sc.MustGetAnyToken();
switch (sc.TokenType)
{
case TK_Bool:
type = TypeBool;
break;
case TK_Int:
type = TypeSInt32;
break;
case TK_Float:
type = TypeFloat64;
break;
case TK_Sound: type = TypeSound; break;
case TK_String: type = TypeString; break;
case TK_Name: type = TypeName; break;
case TK_State: type = TypeState; break;
case TK_Color: type = TypeColor; break;
case TK_Class:
sc.MustGetToken('<');
sc.MustGetToken(TK_Identifier); // Get class name
restrict = PClass::FindClass(sc.String);
if (restrict == NULL)
{
sc.ScriptMessage("Unknown class type %s", sc.String);
FScriptPosition::ErrorCounter++;
}
else
{
type = NewClassPointer(restrict);
}
sc.MustGetToken('>');
break;
case TK_Ellipsis:
// Making the final type NULL signals a varargs function.
type = NULL;
sc.MustGetToken(')');
sc.UnGet();
break;
default:
sc.ScriptMessage ("Unknown variable type %s", sc.TokenName(sc.TokenType, sc.String).GetChars());
type = TypeSInt32;
FScriptPosition::ErrorCounter++;
break;
}
// Read the optional variable name
if (!sc.CheckToken(',') && !sc.CheckToken(')'))
{
sc.MustGetToken(TK_Identifier);
}
else
{
sc.UnGet();
}
if (sc.CheckToken('='))
{
flags |= VARF_Optional;
FxExpression *def = ParseParameter(sc, cls, type, true);
delete def;
}
args.Push(type);
argflags.Push(flags);
sc.MustGetAnyToken();
if (sc.TokenType != ',' && sc.TokenType != ')')
{
sc.ScriptError ("Expected ',' or ')' but got %s instead", sc.TokenName(sc.TokenType, sc.String).GetChars());
}
}
}
sc.MustGetToken(';');
}
void Window_Message::UpdateMessage() {
// Message Box Show Message rendering loop
// Contains at what frame the sleep is over
static int sleep_until = -1;
bool instant_speed = false;
if (Player::debug_flag && Input::IsPressed(Input::SHIFT)) {
sleep_until = -1;
instant_speed = true;
}
if (sleep_until > -1) {
if (Player::GetFrames() >= sleep_until) {
// Sleep over
sleep_until = -1;
} else {
return;
}
}
int loop_count = 0;
int loop_max = speed_table[speed_modifier] == 0 ? 2 : 1;
while (instant_speed || loop_count < loop_max) {
if (!instant_speed) {
// It's assumed that speed_modifier is between 0 and 20
++speed_frame_counter;
if (speed_table[speed_modifier] != 0 &&
speed_table[speed_modifier] != speed_frame_counter) {
break;
}
speed_frame_counter = 0;
}
++loop_count;
if (text_index == end) {
FinishMessageProcessing();
break;
} else if (line_count == 4) {
pause = true;
new_page_after_pause = true;
break;
} else if (pause) {
break;
}
if (*text_index == '\n') {
if (instant_speed) {
// instant_speed stops at the end of the line, unless
// there's a /> at the beginning of the next line
if (std::distance(text_index, end) > 2 &&
*(text_index + 1) == escape_char &&
*(text_index + 2) == '>') {
text_index += 2;
} else {
instant_speed = false;
}
}
InsertNewLine();
} else if (*text_index == '\f') {
instant_speed = false;
++text_index;
if (*text_index == '\n') {
++text_index;
}
if (text_index != end) {
pause = true;
new_page_after_pause = true;
}
break;
} else if (*text_index == escape_char && std::distance(text_index, end) > 1) {
// Special message codes
++text_index;
int parameter;
bool is_valid;
switch (tolower(*text_index)) {
case 'c':
// Color
parameter = ParseParameter(is_valid);
text_color = parameter > 19 ? 0 : parameter;
break;
case 's':
// Speed modifier
parameter = ParseParameter(is_valid);
speed_modifier = max(0, min(parameter, 20));
break;
case '_':
// Insert half size space
contents_x += contents->GetFont()->GetSize(" ").width / 2;
break;
case '$':
// Show Gold Window
ShowGoldWindow();
break;
case '!':
// Text pause
pause = true;
break;
case '^':
// Force message close
// The close happens at the end of the message, not where
// the ^ is encountered
kill_message = true;
break;
case '>':
// Instant speed start
instant_speed = true;
break;
case '<':
// Instant speed stop
instant_speed = false;
break;
case '.':
// 1/4 second sleep
if (instant_speed) break;
sleep_until = Player::GetFrames() + 60 / 4;
++text_index;
return;
case '|':
// Second sleep
if (instant_speed) break;
sleep_until = Player::GetFrames() + 60;
++text_index;
return;
case '\n':
case '\f':
// \ followed by linebreak, don't skip them
--text_index;
break;
default:
if (*text_index == escape_char) {
// Show Escape Symbol
contents->TextDraw(contents_x, contents_y, text_color, Player::escape_symbol);
contents_x += contents->GetFont()->GetSize(Player::escape_symbol).width;
}
}
} else if (*text_index == '$'
&& std::distance(text_index, end) > 1
&& std::isalpha(*std::next(text_index))) {
// ExFont
std::string const glyph(Utils::EncodeUTF(std::u32string(text_index, std::next(text_index, 2))));
contents->TextDraw(contents_x, contents_y, text_color, glyph);
contents_x += 12;
++loop_count;
++text_index;
} else {
std::string const glyph(Utils::EncodeUTF(std::u32string(text_index, std::next(text_index))));
contents->TextDraw(contents_x, contents_y, text_color, glyph);
int glyph_width = contents->GetFont()->GetSize(glyph).width;
// Show full-width characters twice as slow as half-width characters
if (glyph_width >= 12)
loop_count++;
contents_x += glyph_width;
}
++text_index;
}
}
//==========================================================================
//***
// ParseStates
// parses a state block
//
//==========================================================================
void ParseStates(FScanner &sc, FActorInfo * actor, AActor * defaults, Baggage &bag)
{
FString statestring;
FState state;
char lastsprite[5]="";
sc.MustGetStringName ("{");
sc.SetEscape(false); // disable escape sequences in the state parser
while (!sc.CheckString ("}") && !sc.End)
{
memset(&state,0,sizeof(state));
statestring = ParseStateString(sc);
if (!statestring.CompareNoCase("GOTO"))
{
do_goto:
statestring = ParseStateString(sc);
if (sc.CheckString ("+"))
{
sc.MustGetNumber ();
statestring += '+';
statestring += sc.String;
}
if (!bag.statedef.SetGotoLabel(statestring))
{
sc.ScriptError("GOTO before first state");
}
}
else if (!statestring.CompareNoCase("STOP"))
{
do_stop:
if (!bag.statedef.SetStop())
{
sc.ScriptError("STOP before first state");
continue;
}
}
else if (!statestring.CompareNoCase("WAIT") || !statestring.CompareNoCase("FAIL"))
{
if (!bag.statedef.SetWait())
{
sc.ScriptError("%s before first state", sc.String);
continue;
}
}
else if (!statestring.CompareNoCase("LOOP"))
{
if (!bag.statedef.SetLoop())
{
sc.ScriptError("LOOP before first state");
continue;
}
}
else
{
sc.MustGetString();
if (sc.Compare (":"))
{
do
{
bag.statedef.AddStateLabel(statestring);
statestring = ParseStateString(sc);
if (!statestring.CompareNoCase("GOTO"))
{
goto do_goto;
}
else if (!statestring.CompareNoCase("STOP"))
{
goto do_stop;
}
sc.MustGetString ();
} while (sc.Compare (":"));
// continue;
}
sc.UnGet ();
if (statestring.Len() != 4)
{
sc.ScriptError ("Sprite names must be exactly 4 characters\n");
}
state.sprite = GetSpriteIndex(statestring);
state.Misc1 = state.Misc2 = 0;
state.ParameterIndex = 0;
sc.MustGetString();
statestring = sc.String;
if (sc.CheckString("RANDOM"))
{
int min, max;
sc.MustGetStringName("(");
sc.MustGetNumber();
min = clamp<int>(sc.Number, -1, SHRT_MAX);
sc.MustGetStringName(",");
sc.MustGetNumber();
max = clamp<int>(sc.Number, -1, SHRT_MAX);
sc.MustGetStringName(")");
if (min > max)
{
swapvalues(min, max);
}
state.Tics = min;
state.TicRange = max - min;
}
else
{
sc.MustGetNumber();
state.Tics = clamp<int>(sc.Number, -1, SHRT_MAX);
state.TicRange = 0;
}
while (sc.GetString() && !sc.Crossed)
{
if (sc.Compare("BRIGHT"))
{
state.Fullbright = true;
continue;
}
if (sc.Compare("FAST"))
{
state.Fast = true;
continue;
}
if (sc.Compare("SLOW"))
{
state.Slow = true;
continue;
}
if (sc.Compare("NODELAY"))
{
if (bag.statedef.GetStateLabelIndex(NAME_Spawn) == bag.statedef.GetStateCount())
{
state.NoDelay = true;
}
else
{
sc.ScriptMessage("NODELAY may only be used immediately after Spawn:");
}
continue;
}
if (sc.Compare("OFFSET"))
{
// specify a weapon offset
sc.MustGetStringName("(");
sc.MustGetNumber();
state.Misc1 = sc.Number;
sc.MustGetStringName (",");
sc.MustGetNumber();
state.Misc2 = sc.Number;
sc.MustGetStringName(")");
continue;
}
if (sc.Compare("LIGHT"))
{
sc.MustGetStringName("(");
do
{
sc.MustGetString();
#ifdef DYNLIGHT
AddStateLight(&state, sc.String);
#endif
}
while (sc.CheckString(","));
sc.MustGetStringName(")");
continue;
}
if (sc.Compare("CANRAISE"))
{
state.CanRaise = true;
continue;
}
// Make the action name lowercase
strlwr (sc.String);
if (DoActionSpecials(sc, state, bag))
{
goto endofstate;
}
FName funcname = FName(sc.String, true);
PSymbol *sym = bag.Info->Class->Symbols.FindSymbol (funcname, true);
if (sym != NULL && sym->SymbolType == SYM_ActionFunction)
{
PSymbolActionFunction *afd = static_cast<PSymbolActionFunction *>(sym);
state.SetAction(afd, false);
if (!afd->Arguments.IsEmpty())
{
const char *params = afd->Arguments.GetChars();
int numparams = (int)afd->Arguments.Len();
int v;
if (!islower(*params))
{
sc.MustGetStringName("(");
}
else
{
if (!sc.CheckString("("))
{
state.ParameterIndex = afd->defaultparameterindex+1;
goto endofstate;
}
}
int paramindex = PrepareStateParameters(&state, numparams, bag.Info->Class);
int paramstart = paramindex;
bool varargs = params[numparams - 1] == '+';
int varargcount = 0;
if (varargs)
{
paramindex++;
}
else if (afd->defaultparameterindex > -1)
{
StateParams.Copy(paramindex, afd->defaultparameterindex, int(afd->Arguments.Len()));
}
while (*params)
{
FxExpression *x;
if ((*params == 'l' || *params == 'L') && sc.CheckNumber())
{
// Special case: State label as an offset
if (sc.Number > 0 && statestring.Len() > 1)
{
sc.ScriptError("You cannot use state jumps commands with a jump offset on multistate definitions\n");
}
v=sc.Number;
if (v<0)
{
sc.ScriptError("Negative jump offsets are not allowed");
}
if (v > 0)
{
x = new FxStateByIndex(bag.statedef.GetStateCount() + v, sc);
}
else
{
x = new FxConstant((FState*)NULL, sc);
}
}
else
{
// Use the generic parameter parser for everything else
x = ParseParameter(sc, bag.Info->Class, *params, false);
}
StateParams.Set(paramindex++, x);
params++;
if (varargs)
{
varargcount++;
}
if (*params)
{
if (*params == '+')
{
if (sc.CheckString(")"))
{
StateParams.Set(paramstart, new FxConstant(varargcount, sc));
goto endofstate;
}
params--;
StateParams.Reserve(1, bag.Info->Class);
}
else if ((islower(*params) || *params=='!') && sc.CheckString(")"))
{
goto endofstate;
}
sc.MustGetStringName (",");
}
}
sc.MustGetStringName(")");
}
else
{
sc.MustGetString();
if (sc.Compare("("))
{
sc.ScriptError("You cannot pass parameters to '%s'\n", funcname.GetChars());
}
sc.UnGet();
}
goto endofstate;
}
sc.ScriptError("Invalid state parameter %s\n", sc.String);
}
sc.UnGet();
endofstate:
if (!bag.statedef.AddStates(&state, statestring))
{
sc.ScriptError ("Invalid frame character string '%s'", statestring.GetChars());
}
}
}
sc.SetEscape(true); // re-enable escape sequences
}
static void ParseActionDef (FScanner &sc, PClass *cls)
{
enum
{
OPTIONAL = 1
};
unsigned int error = 0;
const AFuncDesc *afd;
FName funcname;
FString args;
TArray<FxExpression *> DefaultParams;
bool hasdefaults = false;
if (sc.LumpNum == -1 || Wads.GetLumpFile(sc.LumpNum) > 0)
{
sc.ScriptMessage ("Action functions can only be imported by internal class and actor definitions!");
++error;
}
sc.MustGetToken(TK_Native);
sc.MustGetToken(TK_Identifier);
funcname = sc.String;
afd = FindFunction(sc.String);
if (afd == NULL)
{
sc.ScriptMessage ("The function '%s' has not been exported from the executable.", sc.String);
++error;
}
sc.MustGetToken('(');
if (!sc.CheckToken(')'))
{
while (sc.TokenType != ')')
{
int flags = 0;
char type = '@';
// Retrieve flags before type name
for (;;)
{
if (sc.CheckToken(TK_Coerce) || sc.CheckToken(TK_Native))
{
}
else
{
break;
}
}
// Read the variable type
sc.MustGetAnyToken();
switch (sc.TokenType)
{
case TK_Bool:
case TK_Int:
type = 'x';
break;
case TK_Float:
type = 'y';
break;
case TK_Sound: type = 's'; break;
case TK_String: type = 't'; break;
case TK_Name: type = 't'; break;
case TK_State: type = 'l'; break;
case TK_Color: type = 'c'; break;
case TK_Class:
sc.MustGetToken('<');
sc.MustGetToken(TK_Identifier); // Skip class name, since the parser doesn't care
sc.MustGetToken('>');
type = 'm';
break;
case TK_Ellipsis:
type = '+';
sc.MustGetToken(')');
sc.UnGet();
break;
default:
sc.ScriptMessage ("Unknown variable type %s", sc.TokenName(sc.TokenType, sc.String).GetChars());
type = 'x';
FScriptPosition::ErrorCounter++;
break;
}
// Read the optional variable name
if (!sc.CheckToken(',') && !sc.CheckToken(')'))
{
sc.MustGetToken(TK_Identifier);
}
else
{
sc.UnGet();
}
FxExpression *def;
if (sc.CheckToken('='))
{
hasdefaults = true;
flags |= OPTIONAL;
def = ParseParameter(sc, cls, type, true);
}
else
{
def = NULL;
}
DefaultParams.Push(def);
if (!(flags & OPTIONAL) && type != '+')
{
type -= 'a' - 'A';
}
args += type;
sc.MustGetAnyToken();
if (sc.TokenType != ',' && sc.TokenType != ')')
{
sc.ScriptError ("Expected ',' or ')' but got %s instead", sc.TokenName(sc.TokenType, sc.String).GetChars());
}
}
}
sc.MustGetToken(';');
if (afd != NULL)
{
PSymbolActionFunction *sym = new PSymbolActionFunction(funcname);
sym->Arguments = args;
sym->Function = afd->Function;
if (hasdefaults)
{
sym->defaultparameterindex = StateParams.Size();
for(unsigned int i = 0; i < DefaultParams.Size(); i++)
{
StateParams.Add(DefaultParams[i], cls, true);
}
}
else
{
sym->defaultparameterindex = -1;
}
if (error)
{
FScriptPosition::ErrorCounter += error;
}
else if (cls->Symbols.AddSymbol (sym) == NULL)
{
delete sym;
sc.ScriptMessage ("'%s' is already defined in class '%s'.",
funcname.GetChars(), cls->TypeName.GetChars());
FScriptPosition::ErrorCounter++;
}
}
}
/////////////////////////////////////////////////////////////////////
//
// Function:
//
// Description:
//
/////////////////////////////////////////////////////////////////////
UINT CACreateProjectInitFile::OnExecution()
{
tstring strSetupExeName;
tstring strDataDirectory;
tstring strProjectInitUrl;
tstring strProjectInitName;
tstring strProjectInitTeamName;
tstring strProjectInitAuthenticator;
tstring strProjectInitSetupCookie;
PROJECT_INIT pi;
UINT uiReturnValue = -1;
uiReturnValue = GetProperty( _T("DATADIR"), strDataDirectory );
if ( uiReturnValue ) return uiReturnValue;
uiReturnValue = GetProperty( _T("PROJINIT_URL"), strProjectInitUrl );
if ( uiReturnValue ) return uiReturnValue;
uiReturnValue = GetProperty( _T("PROJINIT_AUTH"), strProjectInitAuthenticator );
if ( uiReturnValue ) return uiReturnValue;
uiReturnValue = GetProperty( _T("PROJINIT_TEAMNAME"), strProjectInitTeamName );
if ( uiReturnValue ) return uiReturnValue;
uiReturnValue = GetProperty( _T("SETUPEXENAME"), strSetupExeName );
if ( uiReturnValue ) return uiReturnValue;
LogMessage(
INSTALLMESSAGE_INFO,
NULL,
NULL,
NULL,
NULL,
_T("Changing to the data directory")
);
_tchdir(strDataDirectory.c_str());
if (!strProjectInitUrl.empty()) {
LogMessage(
INSTALLMESSAGE_INFO,
NULL,
NULL,
NULL,
NULL,
_T("Detected command line parameters")
);
pi.init();
strncpy(pi.url, CW2A(strProjectInitUrl.c_str()), sizeof(pi.url)-1);
strncpy(pi.name, CW2A(strProjectInitUrl.c_str()), sizeof(pi.name)-1);
strncpy(pi.account_key, CW2A(strProjectInitAuthenticator.c_str()), sizeof(pi.account_key)-1);
strncpy(pi.team_name, CW2A(strProjectInitTeamName.c_str()), sizeof(pi.team_name)-1);
pi.embedded = false;
pi.write();
} else {
LogMessage(
INSTALLMESSAGE_INFO,
NULL,
NULL,
NULL,
NULL,
_T("Checking for file name parameters")
);
strProjectInitUrl = ParseParameter(strSetupExeName, tstring(_T("amu")));
strProjectInitName = ParseParameter(strSetupExeName, tstring(_T("an")));
strProjectInitAuthenticator = ParseParameter(strSetupExeName, tstring(_T("aa")));
strProjectInitSetupCookie = ParseParameter(strSetupExeName, tstring(_T("asc")));
if (!strProjectInitUrl.empty() || !strProjectInitName.empty() || !strProjectInitAuthenticator.empty() || !strProjectInitSetupCookie.empty()) {
LogMessage(
INSTALLMESSAGE_INFO,
NULL,
NULL,
NULL,
NULL,
_T("Detected file name parameters")
);
pi.init();
if (!strProjectInitUrl.empty()) {
LogMessage(
INSTALLMESSAGE_INFO,
NULL,
NULL,
NULL,
NULL,
_T("Detected project url")
);
strncpy(pi.url, CW2A(strProjectInitUrl.c_str()), sizeof(pi.url)-1);
pi.embedded = false;
}
if (!strProjectInitName.empty()) {
LogMessage(
INSTALLMESSAGE_INFO,
NULL,
NULL,
NULL,
NULL,
_T("Detected project name")
);
strncpy(pi.name, CW2A(strProjectInitName.c_str()), sizeof(pi.name)-1);
}
if (!strProjectInitAuthenticator.empty()) {
LogMessage(
INSTALLMESSAGE_INFO,
NULL,
NULL,
NULL,
NULL,
_T("Detected project authenticator")
);
strncpy(pi.account_key, CW2A(strProjectInitAuthenticator.c_str()), sizeof(pi.account_key)-1);
}
if (!strProjectInitSetupCookie.empty()) {
LogMessage(
INSTALLMESSAGE_INFO,
NULL,
NULL,
NULL,
NULL,
_T("Detected setup cookie")
);
strncpy(pi.setup_cookie, CW2A(strProjectInitSetupCookie.c_str()), sizeof(pi.setup_cookie)-1);
}
pi.write();
}
}
return ERROR_SUCCESS;
}