void LibOMF::addSymbol(ObjModule *om, const char *name, int pickAny)
{
#if LOG
printf("LibOMF::addSymbol(%s, %s, %d)\n", om->name, name, pickAny);
#endif
StringValue *s = tab.insert(name, strlen(name));
if (!s)
{ // already in table
if (!pickAny)
{ s = tab.lookup(name, strlen(name));
assert(s);
ObjSymbol *os = (ObjSymbol *)s->ptrvalue;
error("multiple definition of %s: %s and %s: %s",
om->name, name, os->om->name, os->name);
}
}
else
{
ObjSymbol *os = new ObjSymbol();
os->name = strdup(name);
os->om = om;
s->ptrvalue = (void *)os;
objsymbols.push(os);
}
}
/***********************************************************************************
**
**
** MailRecovery::CheckAndFixLexicon
***********************************************************************************/
OP_STATUS MailRecovery::CheckAndFixLexicon()
{
OpString path;
RETURN_IF_ERROR(MailFiles::GetLexiconPath(path));
StringTable lexicon;
// Open the string table
if (lexicon.Open(path.CStr(), LEXICON_FILENAME) == OpBoolean::IS_TRUE)
{
OpStringC8 log_heading("Lexicon");
OpStatus::Ignore(DesktopFileLogger::Log(m_recovery_log,log_heading,"Checking consistency"));
if (lexicon.CheckConsistency(FALSE) == OpBoolean::IS_FALSE)
{
OpStatus::Ignore(DesktopFileLogger::Log(m_recovery_log,log_heading,"Database not consistent, deleting file and reindexing."));
// close Lexicon stringtable and delete file
RETURN_IF_ERROR(lexicon.Close(1));
OpFile lexicon_file;
RETURN_IF_ERROR(lexicon_file.Construct(path.CStr()));
RETURN_IF_ERROR(lexicon_file.Delete(TRUE));
}
else
{
OpStatus::Ignore(DesktopFileLogger::Log(m_recovery_log,log_heading,"Database consistent"));
RETURN_IF_ERROR(lexicon.Close());
}
}
return OpStatus::OK;
}
GameString text(const GameStringKey& id) const {
auto a = m_strings.find(id);
if (a != m_strings.end()) {
return a->second;
}
return GameStringUtil::fromString("MISSING: " + id);
}
void SaveSettings()
{
/*
* NOTE! This code needs to stay in sync with the preference setting
* code in in nsExceptionHandler.cpp.
*/
StringTable settings;
ReadStringsFromFile(gSettingsPath + "/" + kIniFile, settings, true);
if (!gEmailFieldHint)
settings["Email"] = gtk_entry_get_text(GTK_ENTRY(gEmailEntry));
else
settings.erase("Email");
settings["EmailMe"] =
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gEmailMeCheck)) ? "1" : "0";
if (gIncludeURLCheck != 0)
settings["IncludeURL"] =
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gIncludeURLCheck))
? "1" : "0";
settings["SubmitReport"] =
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gSubmitReportCheck))
? "1" : "0";
WriteStringsToFile(gSettingsPath + "/" + kIniFile,
"Crash Reporter", settings, true);
}
StyleProviderImpl(const StyleSheet& stylesheet, StringTable& stringTable) :
stringTable(stringTable),
filters(),
gradients()
{
filters.nodes.reserve(24);
filters.ways.reserve(24);
filters.areas.reserve(24);
filters.relations.reserve(24);
filters.canvases.reserve(24);
for (const Rule& rule : stylesheet.rules) {
for (const Selector& selector : rule.selectors) {
for (const std::string& name : selector.names) {
FilterMap* filtersPtr = nullptr;
if (name == "node") filtersPtr = &filters.nodes;
else if (name == "way") filtersPtr = &filters.ways;
else if (name == "area") filtersPtr = &filters.areas;
else if (name == "relation") filtersPtr = &filters.relations;
else if (name == "canvas") filtersPtr = &filters.canvases;
else
std::domain_error("Unexpected selector name:" + name);
Filter filter = Filter();
filter.conditions.reserve(selector.conditions.size());
for (const Condition& condition : selector.conditions) {
ConditionType c;
if (condition.operation == "") c.type = OpType::Exists;
else if (condition.operation == "=") c.type = OpType::Equals;
else if (condition.operation == "!=") c.type = OpType::NotEquals;
else
std::domain_error("Unexpected condition operation:" + condition.operation);
c.key = stringTable.getId(condition.key);
c.value = stringTable.getId(condition.value);
filter.conditions.push_back(c);
}
filter.declarations.reserve(rule.declarations.size());
for (auto i = 0; i < rule.declarations.size(); ++i) {
Declaration declaration = rule.declarations[i];
uint32_t key = stringTable.getId(declaration.key);
if (utymap::utils::GradientUtils::isGradient(declaration.value))
addGradient(declaration.value);
filter.declarations[key] = Style::value_type(new StyleDeclaration(key, declaration.value));
}
std::sort(filter.conditions.begin(), filter.conditions.end(),
[](const ConditionType& c1, const ConditionType& c2) { return c1.key > c2.key; });
for (int i = selector.zoom.start; i <= selector.zoom.end; ++i) {
(*filtersPtr)[i].push_back(filter);
}
}
}
}
}
int main()
{
StringTable st;
assert(st.GetIndexByName("test1")==0);
assert(st.GetIndexByName("test2")==1);
assert(st.GetIndexByName("test1")==0);
assert(st.GetNameByIndex(1)=="test2");
cout<<"PASS"<<endl;
}
void StringTable::mergeTables(const StringTable& other)
{
TableIterator iter = other.getBegin();
const TableIterator endIter = other.getEnd();
while (iter!=endIter)
{
m_Strings[iter->first] = iter->second;
++iter;
}//while
}
//---------------------------------------------------------------------------
const char* StringValue( const unsigned int stringID )
{
const char* errorValue = "empty!";
StringTable::iterator iter;
for ( iter = s_theStringTable.begin(); iter != s_theStringTable.end(); ++ iter )
{
if ( iter->second.m_id == stringID ) return iter->second.m_originalString.c_str();
}
return errorValue;
}
static void LoadSettings()
{
/*
* NOTE! This code needs to stay in sync with the preference checking
* code in in nsExceptionHandler.cpp.
*/
StringTable settings;
if (ReadStringsFromFile(gSettingsPath + "/" + kIniFile, settings, true)) {
if (settings.find("Email") != settings.end()) {
gtk_entry_set_text(GTK_ENTRY(gEmailEntry), settings["Email"].c_str());
gEmailFieldHint = false;
}
if (settings.find("EmailMe") != settings.end()) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gEmailMeCheck),
settings["EmailMe"][0] != '0');
}
if (settings.find("IncludeURL") != settings.end() &&
gIncludeURLCheck != 0) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gIncludeURLCheck),
settings["IncludeURL"][0] != '0');
}
bool enabled;
if (settings.find("SubmitReport") != settings.end())
enabled = settings["SubmitReport"][0] != '0';
else
enabled = ShouldEnableSending();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gSubmitReportCheck),
enabled);
}
}
void initTraitsStringTable()
{
traitsStringTable._init();
for (size_t idx = 0; ; idx++)
{
const char *s = traits[idx];
if (!s) break;
StringValue *sv = traitsStringTable.insert(s, strlen(s));
sv->ptrvalue = (void *)traits[idx];
}
}
QuadKeyBuilderImpl(GeoStore& geoStore, StringTable& stringTable) :
geoStore_(geoStore),
stringTable_(stringTable),
builderKeyId_(stringTable.getId(BuilderKeyName)),
builderFactory_()
{
}
static void CountOccurrences(int nthreads) {
StringTable table;
tick_count t0 = tick_count::now();
parallel_for( blocked_range<MyString*>( Data, Data+N, 1000 ), Tally(table) );
tick_count t1 = tick_count::now();
int n = 0;
for( StringTable::iterator i=table.begin(); i!=table.end(); ++i ) {
if( verbose && nthreads )
printf("%s %d\n",i->first.c_str(),i->second);
n += i->second;
}
if ( !silent ) printf("total = %d unique = %u time = %g\n", n, unsigned(table.size()), (t1-t0).seconds());
}
static void UpdateURL()
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gIncludeURLCheck))) {
gQueryParameters["URL"] = gURLParameter;
} else {
gQueryParameters.erase("URL");
}
}
//---------------------------------------------------------------------------
unsigned int StringID( const std::string& stringValue )
{
std::string value( stringValue );
ToLower( value );
StringTable::iterator iter = s_theStringTable.find( value );
if ( iter != s_theStringTable.end() )
{
return iter->second.m_id;
}
else
{
StringTableEntry newEntry;
newEntry.m_id = s_nextStringID;
newEntry.m_originalString = stringValue;
s_theStringTable.insert( std::make_pair( value, newEntry ) );
++ s_nextStringID;
return newEntry.m_id;
}
}
void Save(const char* filename)
{
const std::string header("String #");
const std::string header_next(" is ");
const char splitter = '~';
if(_origin.empty())
return;
std::ofstream fin(filename);
fin << "// Total:" << _origin.size() << std::endl;
StringTable::iterator itr = _origin.begin();
for(;itr!=_origin.end();itr++)
{
fin << header << itr->first << header_next << splitter
<< itr->second << splitter << std::endl;
}
}
void *trait_search_fp(void *arg, const char *seed)
{
//printf("trait_search_fp('%s')\n", seed);
size_t len = strlen(seed);
if (!len)
return NULL;
StringValue *sv = traitsStringTable.lookup(seed, len);
return sv ? (void*)sv->ptrvalue : NULL;
}
unsigned int PushString(unsigned int index, const std::string& content)
{
StringTable::iterator ot = _origin.find(index);
if(ot != _origin.end())
throw std::runtime_error( "String ID conflict." );
StringTableRev::iterator otr = _origin_rev.find(content);
if(otr != _origin_rev.end())
return otr->second; // duplicated string
// got unique string
_origin[index] = content;
_origin_rev[content] = index;
if(_max_id < index)
_max_id = index;
return index;
}
bool WriteStrings(ostream& out,
const string& header,
StringTable& strings,
bool escape)
{
out << "[" << header << "]" << std::endl;
for (StringTable::iterator iter = strings.begin();
iter != strings.end();
iter++) {
out << iter->first << "=";
if (escape)
out << Escape(iter->second);
else
out << iter->second;
out << std::endl;
}
return true;
}
TEST(scanner, token) {
StringTable table;
Pos start(1, 1);
Pos end(2, 2);
// test for bool literal token
auto boolToken = Token::makeBoolLiteral(true, start, end);
EXPECT_EQ(true, boolToken.getBoolValue());
EXPECT_EQ(TK_BOOL_CONST, boolToken.getTokenKind());
// test for string literal token
auto symbol = table.addString("zhang");
auto stringLiteralToken = Token::makeStrLiteral(symbol, start, end);
EXPECT_EQ(TK_STR_CONST, stringLiteralToken.getTokenKind());
EXPECT_TRUE(stringLiteralToken.getSymbol()->equalString("zhang"));
// test for identifier token
auto idToken = Token::makeIdentifier(symbol, start, end);
EXPECT_EQ(TK_ID, idToken.getTokenKind());
EXPECT_TRUE(idToken.getSymbol()->equalString("zhang"));
}
static void CountOccurrences(int nthreads) {
StringTable table;
tick_count t0 = tick_count::now();
parallel_for( blocked_range<mystring*>( Data, Data+N, 1000 ), Tally(table) );
tick_count t1 = tick_count::now();
int n = 0;
for( StringTable::iterator i=table.begin(); i!=table.end(); ++i ) {
if( Verbose && nthreads )
printf("%s %d\n",i->first.c_str(),i->second);
n += i->second;
}
if (is_number_of_threads_set) {
printf("threads = %d total = %d unique = %u time = %g\n", nthreads, n, unsigned(table.size()), (t1-t0).seconds());
} else {
if ( nthreads == 1 ) {
printf("serial run total = %d unique = %u time = %g\n", n, unsigned(table.size()), (t1-t0).seconds());
} else {
printf("parallel run total = %d unique = %u time = %g\n", n, unsigned(table.size()), (t1-t0).seconds());
}
}
}
unsigned int Load(const char* filename)
{
_origin.clear();
_origin_rev.clear();
_max_id = 0;
const std::string header("String #");
const std::string header_next(" is ");
const char splitter = '~';
std::ifstream fin(filename);
std::string line;
unsigned int index = INDEX_INVALID;
std::string content;
std::stringstream ss(content);
while(std::getline(fin, line))
{
//not including the \n
if( line.length() >= header.length() &&
line.substr(0, header.length()) == header)
{
if(index != INDEX_INVALID)
{
PushString(ss, splitter, index);
}
int pos = line.find_first_of(splitter);
std::string index_str = line.substr(header.length(), pos - header_next.length() - header.length());
index = atoi(index_str.c_str());
ss << line.substr(pos + 1);
}
else if(index != INDEX_INVALID)
{
ss << std::endl;
ss << line;
}
}
if(index != INDEX_INVALID)
{
PushString(ss, splitter, index);
}
return _max_id;
}
bool LogicTable::CreateLogicTable(wstring name, vector<wstring> inputs, vector<wstring> outputs)
{
bool retval = false;
try
{
BuildDataSet(name);
if (m_ds.TableCount() > 0)
{
//input table, inputs listed along left col downward
StringTable<wstring>* inputTable = m_ds.GetTable(INPUT_TABLE);
inputTable->AddColumn(INPUT_COL);
for (vector<wstring>::iterator it = inputs.begin(); it != inputs.end(); it++)
{
vector<wstring> newRow = inputTable->NewRow();
newRow[0] = *it;
inputTable->AddRow(newRow);
}
//output table, outputs listed along left col downward
StringTable<wstring>* outputTable = m_ds.GetTable(OUTPUT_TABLE);
outputTable->AddColumn(OUTPUT_COL);
for (vector<wstring>::iterator it = outputs.begin(); it != outputs.end(); it++)
{
vector<wstring> newRow = outputTable->NewRow();
newRow[0] = *it;
outputTable->AddRow(newRow);
}
}
}
catch(...)
{
ReportError("CreateLogicTable");
m_ds.Clear();
}
return retval;
}
void LoadStrings(const json_t* root, StringTable& stringTable)
{
auto jsonStrings = json_object_get(root, "strings");
const char* key;
json_t* jlanguages;
json_object_foreach(jsonStrings, key, jlanguages)
{
auto stringId = ParseStringId(key);
if (stringId != OBJ_STRING_ID_UNKNOWN)
{
const char* locale;
json_t* jstring;
json_object_foreach(jlanguages, locale, jstring)
{
auto langId = language_get_id_from_locale(locale);
if (langId != LANGUAGE_UNDEFINED)
{
auto string = json_string_value(jstring);
stringTable.SetString(stringId, langId, string);
}
}
}
SymbolRef
ElfSymbol::CreateSymbol(Object& object, const StringTable& strtab) const
{
SymbolRef sym(0);
std::string name = strtab.getString(m_name_index);
if (m_bind == STB_GLOBAL || m_bind == STB_WEAK)
{
sym = object.getSymbol(name);
if (m_index == SHN_UNDEF)
sym->Declare(Symbol::EXTERN);
else
sym->Declare(Symbol::GLOBAL);
}
else
{
// don't index by name, just append
sym = object.AppendSymbol(name);
}
if (m_index == SHN_ABS)
{
if (hasSize())
sym->DefineEqu(m_size);
else
sym->DefineEqu(Expr(0));
}
else if (m_index == SHN_COMMON)
{
sym->Declare(Symbol::COMMON);
}
else if (m_sect != 0)
{
Location loc = {&m_sect->bytecodes_front(), m_value.getUInt()};
sym->DefineLabel(loc);
}
return sym;
}
static bool AddSubmittedReport(const string& serverResponse)
{
StringTable responseItems;
istringstream in(serverResponse);
ReadStrings(in, responseItems, false);
if (responseItems.find("StopSendingReportsFor") != responseItems.end()) {
// server wants to tell us to stop sending reports for a certain version
string reportPath =
gSettingsPath + UI_DIR_SEPARATOR + "EndOfLife" +
responseItems["StopSendingReportsFor"];
ofstream* reportFile = UIOpenWrite(reportPath);
if (reportFile->is_open()) {
// don't really care about the contents
*reportFile << 1 << "\n";
reportFile->close();
}
delete reportFile;
}
if (responseItems.find("Discarded") != responseItems.end()) {
// server discarded this report... save it so the user can resubmit it
// manually
return false;
}
if (responseItems.find("CrashID") == responseItems.end())
return false;
string submittedDir =
gSettingsPath + UI_DIR_SEPARATOR + "submitted";
if (!UIEnsurePathExists(submittedDir)) {
return false;
}
string path = submittedDir + UI_DIR_SEPARATOR +
responseItems["CrashID"] + ".txt";
ofstream* file = UIOpenWrite(path);
if (!file->is_open()) {
delete file;
return false;
}
char buf[1024];
UI_SNPRINTF(buf, 1024,
gStrings["CrashID"].c_str(),
responseItems["CrashID"].c_str());
*file << buf << "\n";
if (responseItems.find("ViewURL") != responseItems.end()) {
UI_SNPRINTF(buf, 1024,
gStrings["CrashDetailsURL"].c_str(),
responseItems["ViewURL"].c_str());
*file << buf << "\n";
}
file->close();
delete file;
WriteSubmissionEvent(Succeeded, responseItems["CrashID"]);
return true;
}
ElementStore::ElementStore(StringTable& stringTable) :
clipKeyId_(stringTable.getId(ClipKey)),
skipKeyId_(stringTable.getId(SkipKey)),
sizeKeyId_(stringTable.getId(SizeKey))
{
}
Expression *BinExp::arrayOp(Scope *sc)
{
//printf("BinExp::arrayOp() %s\n", toChars());
if (type->toBasetype()->nextOf()->toBasetype()->ty == Tvoid)
{
error("Cannot perform array operations on void[] arrays");
return new ErrorExp();
}
Expressions *arguments = new Expressions();
/* The expression to generate an array operation for is mangled
* into a name to use as the array operation function name.
* Mangle in the operands and operators in RPN order, and type.
*/
OutBuffer buf;
buf.writestring("_array");
buildArrayIdent(&buf, arguments);
buf.writeByte('_');
/* Append deco of array element type
*/
#if DMDV2
buf.writestring(type->toBasetype()->nextOf()->toBasetype()->mutableOf()->deco);
#else
buf.writestring(type->toBasetype()->nextOf()->toBasetype()->deco);
#endif
size_t namelen = buf.offset;
buf.writeByte(0);
char *name = (char *)buf.extractData();
/* Look up name in hash table
*/
StringValue *sv = arrayfuncs.update(name, namelen);
FuncDeclaration *fd = (FuncDeclaration *)sv->ptrvalue;
if (!fd)
{
/* Some of the array op functions are written as library functions,
* presumably to optimize them with special CPU vector instructions.
* List those library functions here, in alpha order.
*/
static const char *libArrayopFuncs[] =
{
"_arrayExpSliceAddass_a",
"_arrayExpSliceAddass_d", // T[]+=T
"_arrayExpSliceAddass_f", // T[]+=T
"_arrayExpSliceAddass_g",
"_arrayExpSliceAddass_h",
"_arrayExpSliceAddass_i",
"_arrayExpSliceAddass_k",
"_arrayExpSliceAddass_s",
"_arrayExpSliceAddass_t",
"_arrayExpSliceAddass_u",
"_arrayExpSliceAddass_w",
"_arrayExpSliceDivass_d", // T[]/=T
"_arrayExpSliceDivass_f", // T[]/=T
"_arrayExpSliceMinSliceAssign_a",
"_arrayExpSliceMinSliceAssign_d", // T[]=T-T[]
"_arrayExpSliceMinSliceAssign_f", // T[]=T-T[]
"_arrayExpSliceMinSliceAssign_g",
"_arrayExpSliceMinSliceAssign_h",
"_arrayExpSliceMinSliceAssign_i",
"_arrayExpSliceMinSliceAssign_k",
"_arrayExpSliceMinSliceAssign_s",
"_arrayExpSliceMinSliceAssign_t",
"_arrayExpSliceMinSliceAssign_u",
"_arrayExpSliceMinSliceAssign_w",
"_arrayExpSliceMinass_a",
"_arrayExpSliceMinass_d", // T[]-=T
"_arrayExpSliceMinass_f", // T[]-=T
"_arrayExpSliceMinass_g",
"_arrayExpSliceMinass_h",
"_arrayExpSliceMinass_i",
"_arrayExpSliceMinass_k",
"_arrayExpSliceMinass_s",
"_arrayExpSliceMinass_t",
"_arrayExpSliceMinass_u",
"_arrayExpSliceMinass_w",
"_arrayExpSliceMulass_d", // T[]*=T
"_arrayExpSliceMulass_f", // T[]*=T
"_arrayExpSliceMulass_i",
"_arrayExpSliceMulass_k",
"_arrayExpSliceMulass_s",
"_arrayExpSliceMulass_t",
"_arrayExpSliceMulass_u",
"_arrayExpSliceMulass_w",
"_arraySliceExpAddSliceAssign_a",
"_arraySliceExpAddSliceAssign_d", // T[]=T[]+T
"_arraySliceExpAddSliceAssign_f", // T[]=T[]+T
"_arraySliceExpAddSliceAssign_g",
"_arraySliceExpAddSliceAssign_h",
"_arraySliceExpAddSliceAssign_i",
"_arraySliceExpAddSliceAssign_k",
"_arraySliceExpAddSliceAssign_s",
"_arraySliceExpAddSliceAssign_t",
"_arraySliceExpAddSliceAssign_u",
"_arraySliceExpAddSliceAssign_w",
"_arraySliceExpDivSliceAssign_d", // T[]=T[]/T
"_arraySliceExpDivSliceAssign_f", // T[]=T[]/T
"_arraySliceExpMinSliceAssign_a",
"_arraySliceExpMinSliceAssign_d", // T[]=T[]-T
"_arraySliceExpMinSliceAssign_f", // T[]=T[]-T
"_arraySliceExpMinSliceAssign_g",
"_arraySliceExpMinSliceAssign_h",
"_arraySliceExpMinSliceAssign_i",
"_arraySliceExpMinSliceAssign_k",
"_arraySliceExpMinSliceAssign_s",
"_arraySliceExpMinSliceAssign_t",
"_arraySliceExpMinSliceAssign_u",
"_arraySliceExpMinSliceAssign_w",
"_arraySliceExpMulSliceAddass_d", // T[] += T[]*T
"_arraySliceExpMulSliceAddass_f",
"_arraySliceExpMulSliceAddass_r",
"_arraySliceExpMulSliceAssign_d", // T[]=T[]*T
"_arraySliceExpMulSliceAssign_f", // T[]=T[]*T
"_arraySliceExpMulSliceAssign_i",
"_arraySliceExpMulSliceAssign_k",
"_arraySliceExpMulSliceAssign_s",
"_arraySliceExpMulSliceAssign_t",
"_arraySliceExpMulSliceAssign_u",
"_arraySliceExpMulSliceAssign_w",
"_arraySliceExpMulSliceMinass_d", // T[] -= T[]*T
"_arraySliceExpMulSliceMinass_f",
"_arraySliceExpMulSliceMinass_r",
"_arraySliceSliceAddSliceAssign_a",
"_arraySliceSliceAddSliceAssign_d", // T[]=T[]+T[]
"_arraySliceSliceAddSliceAssign_f", // T[]=T[]+T[]
"_arraySliceSliceAddSliceAssign_g",
"_arraySliceSliceAddSliceAssign_h",
"_arraySliceSliceAddSliceAssign_i",
"_arraySliceSliceAddSliceAssign_k",
"_arraySliceSliceAddSliceAssign_r", // T[]=T[]+T[]
"_arraySliceSliceAddSliceAssign_s",
"_arraySliceSliceAddSliceAssign_t",
"_arraySliceSliceAddSliceAssign_u",
"_arraySliceSliceAddSliceAssign_w",
"_arraySliceSliceAddass_a",
"_arraySliceSliceAddass_d", // T[]+=T[]
"_arraySliceSliceAddass_f", // T[]+=T[]
"_arraySliceSliceAddass_g",
"_arraySliceSliceAddass_h",
"_arraySliceSliceAddass_i",
"_arraySliceSliceAddass_k",
"_arraySliceSliceAddass_s",
"_arraySliceSliceAddass_t",
"_arraySliceSliceAddass_u",
"_arraySliceSliceAddass_w",
"_arraySliceSliceMinSliceAssign_a",
"_arraySliceSliceMinSliceAssign_d", // T[]=T[]-T[]
"_arraySliceSliceMinSliceAssign_f", // T[]=T[]-T[]
"_arraySliceSliceMinSliceAssign_g",
"_arraySliceSliceMinSliceAssign_h",
"_arraySliceSliceMinSliceAssign_i",
"_arraySliceSliceMinSliceAssign_k",
"_arraySliceSliceMinSliceAssign_r", // T[]=T[]-T[]
"_arraySliceSliceMinSliceAssign_s",
"_arraySliceSliceMinSliceAssign_t",
"_arraySliceSliceMinSliceAssign_u",
"_arraySliceSliceMinSliceAssign_w",
"_arraySliceSliceMinass_a",
"_arraySliceSliceMinass_d", // T[]-=T[]
"_arraySliceSliceMinass_f", // T[]-=T[]
"_arraySliceSliceMinass_g",
"_arraySliceSliceMinass_h",
"_arraySliceSliceMinass_i",
"_arraySliceSliceMinass_k",
"_arraySliceSliceMinass_s",
"_arraySliceSliceMinass_t",
"_arraySliceSliceMinass_u",
"_arraySliceSliceMinass_w",
"_arraySliceSliceMulSliceAssign_d", // T[]=T[]*T[]
"_arraySliceSliceMulSliceAssign_f", // T[]=T[]*T[]
"_arraySliceSliceMulSliceAssign_i",
"_arraySliceSliceMulSliceAssign_k",
"_arraySliceSliceMulSliceAssign_s",
"_arraySliceSliceMulSliceAssign_t",
"_arraySliceSliceMulSliceAssign_u",
"_arraySliceSliceMulSliceAssign_w",
"_arraySliceSliceMulass_d", // T[]*=T[]
"_arraySliceSliceMulass_f", // T[]*=T[]
"_arraySliceSliceMulass_i",
"_arraySliceSliceMulass_k",
"_arraySliceSliceMulass_s",
"_arraySliceSliceMulass_t",
"_arraySliceSliceMulass_u",
"_arraySliceSliceMulass_w",
};
int i = binary(name, libArrayopFuncs, sizeof(libArrayopFuncs) / sizeof(char *));
if (i == -1)
{
#ifdef DEBUG // Make sure our array is alphabetized
for (i = 0; i < sizeof(libArrayopFuncs) / sizeof(char *); i++)
{
if (strcmp(name, libArrayopFuncs[i]) == 0)
assert(0);
}
#endif
/* Not in library, so generate it.
* Construct the function body:
* foreach (i; 0 .. p.length) for (size_t i = 0; i < p.length; i++)
* loopbody;
* return p;
*/
Arguments *fparams = new Arguments();
Expression *loopbody = buildArrayLoop(fparams);
Argument *p = (Argument *)fparams->data[0 /*fparams->dim - 1*/];
#if DMDV1
// for (size_t i = 0; i < p.length; i++)
Initializer *init = new ExpInitializer(0, new IntegerExp(0, 0, Type::tsize_t));
Dsymbol *d = new VarDeclaration(0, Type::tsize_t, Id::p, init);
Statement *s1 = new ForStatement(0,
new DeclarationStatement(0, d),
new CmpExp(TOKlt, 0, new IdentifierExp(0, Id::p), new ArrayLengthExp(0, new IdentifierExp(0, p->ident))),
new PostExp(TOKplusplus, 0, new IdentifierExp(0, Id::p)),
new ExpStatement(0, loopbody));
#else
// foreach (i; 0 .. p.length)
Statement *s1 = new ForeachRangeStatement(0, TOKforeach,
new Argument(0, NULL, Id::p, NULL),
new IntegerExp(0, 0, Type::tint32),
new ArrayLengthExp(0, new IdentifierExp(0, p->ident)),
new ExpStatement(0, loopbody));
#endif
Statement *s2 = new ReturnStatement(0, new IdentifierExp(0, p->ident));
//printf("s2: %s\n", s2->toChars());
Statement *fbody = new CompoundStatement(0, s1, s2);
/* Construct the function
*/
TypeFunction *ftype = new TypeFunction(fparams, type, 0, LINKc);
//printf("ftype: %s\n", ftype->toChars());
fd = new FuncDeclaration(0, 0, Lexer::idPool(name), STCundefined, ftype);
fd->fbody = fbody;
fd->protection = PROTpublic;
fd->linkage = LINKc;
sc->module->importedFrom->members->push(fd);
sc = sc->push();
sc->parent = sc->module->importedFrom;
sc->stc = 0;
sc->linkage = LINKc;
fd->semantic(sc);
fd->semantic2(sc);
fd->semantic3(sc);
sc->pop();
}
else
{ /* In library, refer to it.
*/
fd = FuncDeclaration::genCfunc(type, name);
}
sv->ptrvalue = fd; // cache symbol in hash table
}
/* Call the function fd(arguments)
*/
Expression *ec = new VarExp(0, fd);
Expression *e = new CallExp(loc, ec, arguments);
e->type = type;
return e;
}
static FIBITMAP * DLL_CALLCONV
Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
if( data == NULL ) {
return NULL;
}
GIFinfo *info = (GIFinfo *)data;
if( page == -1 ) {
page = 0;
}
if( page < 0 || page >= (int)info->image_descriptor_offsets.size() ) {
return NULL;
}
FIBITMAP *dib = NULL;
try {
bool have_transparent = false, no_local_palette = false, interlaced = false;
int disposal_method = GIF_DISPOSAL_LEAVE, delay_time = 0, transparent_color = 0;
WORD left, top, width, height;
BYTE packed, b;
WORD w;
//playback pages to generate what the user would see for this frame
if( (flags & GIF_PLAYBACK) == GIF_PLAYBACK ) {
//Logical Screen Descriptor
io->seek_proc(handle, 6, SEEK_SET);
WORD logicalwidth, logicalheight;
io->read_proc(&logicalwidth, 2, 1, handle);
io->read_proc(&logicalheight, 2, 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
SwapShort(&logicalwidth);
SwapShort(&logicalheight);
#endif
//set the background color with 0 alpha
RGBQUAD background;
if( info->global_color_table_offset != 0 && info->background_color < info->global_color_table_size ) {
io->seek_proc(handle, info->global_color_table_offset + (info->background_color * 3), SEEK_SET);
io->read_proc(&background.rgbRed, 1, 1, handle);
io->read_proc(&background.rgbGreen, 1, 1, handle);
io->read_proc(&background.rgbBlue, 1, 1, handle);
} else {
background.rgbRed = 0;
background.rgbGreen = 0;
background.rgbBlue = 0;
}
background.rgbReserved = 0;
//allocate entire logical area
dib = FreeImage_Allocate(logicalwidth, logicalheight, 32);
if( dib == NULL ) {
throw "DIB allocated failed";
}
//fill with background color to start
int x, y;
RGBQUAD *scanline;
for( y = 0; y < logicalheight; y++ ) {
scanline = (RGBQUAD *)FreeImage_GetScanLine(dib, y);
for( x = 0; x < logicalwidth; x++ ) {
*scanline++ = background;
}
}
//cache some info about each of the pages so we can avoid decoding as many of them as possible
std::vector<PageInfo> pageinfo;
int start = page, end = page;
while( start >= 0 ) {
//Graphic Control Extension
io->seek_proc(handle, info->graphic_control_extension_offsets[start] + 1, SEEK_SET);
io->read_proc(&packed, 1, 1, handle);
have_transparent = (packed & GIF_PACKED_GCE_HAVETRANS) ? true : false;
disposal_method = (packed & GIF_PACKED_GCE_DISPOSAL) >> 2;
//Image Descriptor
io->seek_proc(handle, info->image_descriptor_offsets[page], SEEK_SET);
io->read_proc(&left, 2, 1, handle);
io->read_proc(&top, 2, 1, handle);
io->read_proc(&width, 2, 1, handle);
io->read_proc(&height, 2, 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
SwapShort(&left);
SwapShort(&top);
SwapShort(&width);
SwapShort(&height);
#endif
pageinfo.push_back(PageInfo(disposal_method, left, top, width, height));
if( start != end ) {
if( left == 0 && top == 0 && width == logicalwidth && height == logicalheight ) {
if( disposal_method == GIF_DISPOSAL_BACKGROUND ) {
pageinfo.pop_back();
start++;
break;
} else if( disposal_method != GIF_DISPOSAL_PREVIOUS ) {
if( !have_transparent ) {
break;
}
}
}
}
start--;
}
if( start < 0 ) {
start = 0;
}
//draw each page into the logical area
for( page = start; page <= end; page++ ) {
PageInfo &info = pageinfo[end - page];
//things we can skip having to decode
if( page != end ) {
if( info.disposal_method == GIF_DISPOSAL_PREVIOUS ) {
continue;
}
if( info.disposal_method == GIF_DISPOSAL_BACKGROUND ) {
for( y = 0; y < info.height; y++ ) {
scanline = (RGBQUAD *)FreeImage_GetScanLine(dib, logicalheight - (y + info.top) - 1) + info.left;
for( x = 0; x < info.width; x++ ) {
*scanline++ = background;
}
}
}
}
//decode page
FIBITMAP *pagedib = Load(io, handle, page, GIF_LOAD256, data);
if( pagedib != NULL ) {
RGBQUAD *pal = FreeImage_GetPalette(pagedib);
have_transparent = false;
if( FreeImage_IsTransparent(pagedib) ) {
int count = FreeImage_GetTransparencyCount(pagedib);
BYTE *table = FreeImage_GetTransparencyTable(pagedib);
for( int i = 0; i < count; i++ ) {
if( table[i] == 0 ) {
have_transparent = true;
transparent_color = i;
break;
}
}
}
//copy page data into logical buffer, with full alpha opaqueness
for( y = 0; y < info.height; y++ ) {
scanline = (RGBQUAD *)FreeImage_GetScanLine(dib, logicalheight - (y + info.top) - 1) + info.left;
BYTE *pageline = FreeImage_GetScanLine(pagedib, info.height - y - 1);
for( x = 0; x < info.width; x++ ) {
if( !have_transparent || *pageline != transparent_color ) {
*scanline = pal[*pageline];
scanline->rgbReserved = 255;
}
scanline++;
pageline++;
}
}
FreeImage_Unload(pagedib);
}
}
return dib;
}
//get the actual frame image data for a single frame
//Image Descriptor
io->seek_proc(handle, info->image_descriptor_offsets[page], SEEK_SET);
io->read_proc(&left, 2, 1, handle);
io->read_proc(&top, 2, 1, handle);
io->read_proc(&width, 2, 1, handle);
io->read_proc(&height, 2, 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
SwapShort(&left);
SwapShort(&top);
SwapShort(&width);
SwapShort(&height);
#endif
io->read_proc(&packed, 1, 1, handle);
interlaced = (packed & GIF_PACKED_ID_INTERLACED) ? true : false;
no_local_palette = (packed & GIF_PACKED_ID_HAVELCT) ? false : true;
int bpp = 8;
if( (flags & GIF_LOAD256) == 0 ) {
if( !no_local_palette ) {
int size = 2 << (packed & GIF_PACKED_ID_LCTSIZE);
if( size <= 2 ) bpp = 1;
else if( size <= 16 ) bpp = 4;
} else if( info->global_color_table_offset != 0 ) {
if( info->global_color_table_size <= 2 ) bpp = 1;
else if( info->global_color_table_size <= 16 ) bpp = 4;
}
}
dib = FreeImage_Allocate(width, height, bpp);
if( dib == NULL ) {
throw "DIB allocated failed";
}
FreeImage_SetMetadataEx(FIMD_ANIMATION, dib, "FrameLeft", ANIMTAG_FRAMELEFT, FIDT_SHORT, 1, 2, &left);
FreeImage_SetMetadataEx(FIMD_ANIMATION, dib, "FrameTop", ANIMTAG_FRAMETOP, FIDT_SHORT, 1, 2, &top);
b = no_local_palette ? 1 : 0;
FreeImage_SetMetadataEx(FIMD_ANIMATION, dib, "NoLocalPalette", ANIMTAG_NOLOCALPALETTE, FIDT_BYTE, 1, 1, &b);
b = interlaced ? 1 : 0;
FreeImage_SetMetadataEx(FIMD_ANIMATION, dib, "Interlaced", ANIMTAG_INTERLACED, FIDT_BYTE, 1, 1, &b);
//Palette
RGBQUAD *pal = FreeImage_GetPalette(dib);
if( !no_local_palette ) {
int size = 2 << (packed & GIF_PACKED_ID_LCTSIZE);
int i = 0;
while( i < size ) {
io->read_proc(&pal[i].rgbRed, 1, 1, handle);
io->read_proc(&pal[i].rgbGreen, 1, 1, handle);
io->read_proc(&pal[i].rgbBlue, 1, 1, handle);
i++;
}
} else if( info->global_color_table_offset != 0 ) {
long pos = io->tell_proc(handle);
io->seek_proc(handle, info->global_color_table_offset, SEEK_SET);
int i = 0;
while( i < info->global_color_table_size ) {
io->read_proc(&pal[i].rgbRed, 1, 1, handle);
io->read_proc(&pal[i].rgbGreen, 1, 1, handle);
io->read_proc(&pal[i].rgbBlue, 1, 1, handle);
i++;
}
io->seek_proc(handle, pos, SEEK_SET);
} else {
//its legal to have no palette, but we're going to generate *something*
for( int i = 0; i < 256; i++ ) {
pal[i].rgbRed = i;
pal[i].rgbGreen = i;
pal[i].rgbBlue = i;
}
}
//LZW Minimum Code Size
io->read_proc(&b, 1, 1, handle);
StringTable stringtable;
stringtable.Initialize(b);
//Image Data Sub-blocks
int x = 0, xpos = 0, y = 0, shift = 8 - bpp, mask = (1 << bpp) - 1, interlacepass = 0;
BYTE *scanline = FreeImage_GetScanLine(dib, height - 1);
BYTE buf[1024];
io->read_proc(&b, 1, 1, handle);
while( b ) {
io->read_proc(stringtable.FillInputBuffer(b), b, 1, handle);
int size = sizeof(buf);
while( stringtable.Decompress(buf, &size) ) {
for( int i = 0; i < size; i++ ) {
scanline[xpos] |= (buf[i] & mask) << shift;
if( shift > 0 ) {
shift -= bpp;
} else {
xpos++;
shift = 8 - bpp;
}
if( ++x >= width ) {
if( interlaced ) {
y += g_GifInterlaceIncrement[interlacepass];
if( y >= height && interlacepass < GIF_INTERLACE_PASSES ) {
y = g_GifInterlaceOffset[++interlacepass];
}
} else {
y++;
}
if( y >= height ) {
stringtable.Done();
break;
}
x = xpos = 0;
shift = 8 - bpp;
scanline = FreeImage_GetScanLine(dib, height - y - 1);
}
}
size = sizeof(buf);
}
io->read_proc(&b, 1, 1, handle);
}
if( page == 0 ) {
size_t idx;
//Logical Screen Descriptor
io->seek_proc(handle, 6, SEEK_SET);
WORD logicalwidth, logicalheight;
io->read_proc(&logicalwidth, 2, 1, handle);
io->read_proc(&logicalheight, 2, 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
SwapShort(&logicalwidth);
SwapShort(&logicalheight);
#endif
FreeImage_SetMetadataEx(FIMD_ANIMATION, dib, "LogicalWidth", ANIMTAG_LOGICALWIDTH, FIDT_SHORT, 1, 2, &logicalwidth);
FreeImage_SetMetadataEx(FIMD_ANIMATION, dib, "LogicalHeight", ANIMTAG_LOGICALHEIGHT, FIDT_SHORT, 1, 2, &logicalheight);
//Global Color Table
if( info->global_color_table_offset != 0 ) {
RGBQUAD globalpalette[256];
io->seek_proc(handle, info->global_color_table_offset, SEEK_SET);
int i = 0;
while( i < info->global_color_table_size ) {
io->read_proc(&globalpalette[i].rgbRed, 1, 1, handle);
io->read_proc(&globalpalette[i].rgbGreen, 1, 1, handle);
io->read_proc(&globalpalette[i].rgbBlue, 1, 1, handle);
globalpalette[i].rgbReserved = 0;
i++;
}
FreeImage_SetMetadataEx(FIMD_ANIMATION, dib, "GlobalPalette", ANIMTAG_GLOBALPALETTE, FIDT_PALETTE, info->global_color_table_size, info->global_color_table_size * 4, globalpalette);
//background color
if( info->background_color < info->global_color_table_size ) {
FreeImage_SetBackgroundColor(dib, &globalpalette[info->background_color]);
}
}
//Application Extension
LONG loop = 1; //If no AE with a loop count is found, the default must be 1
for( idx = 0; idx < info->application_extension_offsets.size(); idx++ ) {
io->seek_proc(handle, info->application_extension_offsets[idx], SEEK_SET);
io->read_proc(&b, 1, 1, handle);
if( b == 11 ) { //All AEs start with an 11 byte sub-block to determine what type of AE it is
char buf[11];
io->read_proc(buf, 11, 1, handle);
if( !memcmp(buf, "NETSCAPE2.0", 11) || !memcmp(buf, "ANIMEXTS1.0", 11) ) { //Not everybody recognizes ANIMEXTS1.0 but it is valid
io->read_proc(&b, 1, 1, handle);
if( b == 3 ) { //we're supposed to have a 3 byte sub-block now
io->read_proc(&b, 1, 1, handle); //this should be 0x01 but isn't really important
io->read_proc(&w, 2, 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
SwapShort(&w);
#endif
loop = w;
if( loop > 0 ) loop++;
break;
}
}
}
}
FreeImage_SetMetadataEx(FIMD_ANIMATION, dib, "Loop", ANIMTAG_LOOP, FIDT_LONG, 1, 4, &loop);
//Comment Extension
for( idx = 0; idx < info->comment_extension_offsets.size(); idx++ ) {
io->seek_proc(handle, info->comment_extension_offsets[idx], SEEK_SET);
std::string comment;
char buf[255];
io->read_proc(&b, 1, 1, handle);
while( b ) {
io->read_proc(buf, b, 1, handle);
comment.append(buf, b);
io->read_proc(&b, 1, 1, handle);
}
comment.append(1, '\0');
sprintf(buf, "Comment%d", idx);
FreeImage_SetMetadataEx(FIMD_COMMENTS, dib, buf, 1, FIDT_ASCII, comment.size(), comment.size(), comment.c_str());
}
}
//Graphic Control Extension
if( info->graphic_control_extension_offsets[page] != 0 ) {
io->seek_proc(handle, info->graphic_control_extension_offsets[page] + 1, SEEK_SET);
io->read_proc(&packed, 1, 1, handle);
io->read_proc(&w, 2, 1, handle);
#ifdef FREEIMAGE_BIGENDIAN
SwapShort(&w);
#endif
io->read_proc(&b, 1, 1, handle);
have_transparent = (packed & GIF_PACKED_GCE_HAVETRANS) ? true : false;
disposal_method = (packed & GIF_PACKED_GCE_DISPOSAL) >> 2;
delay_time = w * 10; //convert cs to ms
transparent_color = b;
if( have_transparent ) {
int size = 1 << bpp;
if( transparent_color <= size ) {
BYTE table[256];
memset(table, 0xFF, size);
table[transparent_color] = 0;
FreeImage_SetTransparencyTable(dib, table, size);
}
}
}
inline void save_string_table(BinaryFile &bf, const StringTable &st)
{
bf.save_pod_vector(st.indices());
bf.save_pod_vector(st.strings());
}
int main(int argc, char** argv)
{
gArgc = argc;
gArgv = argv;
if (!ReadConfig()) {
UIError("Couldn't read configuration.");
return 0;
}
if (!UIInit())
return 0;
if (argc > 1) {
gReporterDumpFile = argv[1];
}
if (gReporterDumpFile.empty()) {
// no dump file specified, run the default UI
UIShowDefaultUI();
} else {
// Start by running minidump analyzer to gather stack traces.
string reporterDumpFile = gReporterDumpFile;
vector<string> args = { reporterDumpFile };
UIRunProgram(GetProgramPath(UI_MINIDUMP_ANALYZER_FILENAME),
args, /* wait */ true);
// go ahead with the crash reporter
gExtraFile = GetAdditionalFilename(gReporterDumpFile, kExtraDataExtension);
if (gExtraFile.empty()) {
UIError(gStrings[ST_ERROR_BADARGUMENTS]);
return 0;
}
if (!UIFileExists(gExtraFile)) {
UIError(gStrings[ST_ERROR_EXTRAFILEEXISTS]);
return 0;
}
gMemoryFile = GetAdditionalFilename(gReporterDumpFile,
kMemoryReportExtension);
if (!UIFileExists(gMemoryFile)) {
gMemoryFile.erase();
}
StringTable queryParameters;
if (!ReadStringsFromFile(gExtraFile, queryParameters, true)) {
UIError(gStrings[ST_ERROR_EXTRAFILEREAD]);
return 0;
}
if (queryParameters.find("ProductName") == queryParameters.end()) {
UIError(gStrings[ST_ERROR_NOPRODUCTNAME]);
return 0;
}
// There is enough information in the extra file to rewrite strings
// to be product specific
RewriteStrings(queryParameters);
if (queryParameters.find("ServerURL") == queryParameters.end()) {
UIError(gStrings[ST_ERROR_NOSERVERURL]);
return 0;
}
// Hopefully the settings path exists in the environment. Try that before
// asking the platform-specific code to guess.
gSettingsPath = UIGetEnv("MOZ_CRASHREPORTER_DATA_DIRECTORY");
if (gSettingsPath.empty()) {
string product = queryParameters["ProductName"];
string vendor = queryParameters["Vendor"];
if (!UIGetSettingsPath(vendor, product, gSettingsPath)) {
gSettingsPath.clear();
}
}
if (gSettingsPath.empty() || !UIEnsurePathExists(gSettingsPath)) {
UIError(gStrings[ST_ERROR_NOSETTINGSPATH]);
return 0;
}
OpenLogFile();
gEventsPath = UIGetEnv("MOZ_CRASHREPORTER_EVENTS_DIRECTORY");
gPingPath = UIGetEnv("MOZ_CRASHREPORTER_PING_DIRECTORY");
// Assemble and send the crash ping
string hash;
string pingUuid;
hash = ComputeDumpHash();
if (!hash.empty()) {
AppendToEventFile("MinidumpSha256Hash", hash);
}
if (SendCrashPing(queryParameters, hash, pingUuid, gPingPath)) {
AppendToEventFile("CrashPingUUID", pingUuid);
}
// Update the crash event with stacks if they are present
auto stackTracesItr = queryParameters.find("StackTraces");
if (stackTracesItr != queryParameters.end()) {
AppendToEventFile(stackTracesItr->first, stackTracesItr->second);
}
if (!UIFileExists(gReporterDumpFile)) {
UIError(gStrings[ST_ERROR_DUMPFILEEXISTS]);
return 0;
}
string pendingDir = gSettingsPath + UI_DIR_SEPARATOR + "pending";
if (!MoveCrashData(pendingDir, gReporterDumpFile, gExtraFile,
gMemoryFile)) {
return 0;
}
string sendURL = queryParameters["ServerURL"];
// we don't need to actually send this
queryParameters.erase("ServerURL");
queryParameters["Throttleable"] = "1";
// re-set XUL_APP_FILE for xulrunner wrapped apps
const char *appfile = getenv("MOZ_CRASHREPORTER_RESTART_XUL_APP_FILE");
if (appfile && *appfile) {
const char prefix[] = "XUL_APP_FILE=";
char *env = (char*) malloc(strlen(appfile) + strlen(prefix) + 1);
if (!env) {
UIError("Out of memory");
return 0;
}
strcpy(env, prefix);
strcat(env, appfile);
putenv(env);
free(env);
}
vector<string> restartArgs;
ostringstream paramName;
int i = 0;
paramName << "MOZ_CRASHREPORTER_RESTART_ARG_" << i++;
const char *param = getenv(paramName.str().c_str());
while (param && *param) {
restartArgs.push_back(param);
paramName.str("");
paramName << "MOZ_CRASHREPORTER_RESTART_ARG_" << i++;
param = getenv(paramName.str().c_str());
}
// allow override of the server url via environment variable
//XXX: remove this in the far future when our robot
// masters force everyone to use XULRunner
char* urlEnv = getenv("MOZ_CRASHREPORTER_URL");
if (urlEnv && *urlEnv) {
sendURL = urlEnv;
}
// see if this version has been end-of-lifed
if (queryParameters.find("Version") != queryParameters.end() &&
CheckEndOfLifed(queryParameters["Version"])) {
UIError(gStrings[ST_ERROR_ENDOFLIFE]);
DeleteDump();
return 0;
}
StringTable files;
files["upload_file_minidump"] = gReporterDumpFile;
if (!gMemoryFile.empty()) {
files["memory_report"] = gMemoryFile;
}
if (!UIShowCrashUI(files, queryParameters, sendURL, restartArgs))
DeleteDump();
}
UIShutdown();
return 0;
}
