TEST(mnemonics, all_languages)
{
srand(time(NULL));
std::vector<Language::Base*> languages({
Language::Singleton<Language::Chinese_Simplified>::instance(),
Language::Singleton<Language::English>::instance(),
Language::Singleton<Language::Spanish>::instance(),
Language::Singleton<Language::Portuguese>::instance(),
Language::Singleton<Language::Japanese>::instance(),
Language::Singleton<Language::German>::instance(),
Language::Singleton<Language::Italian>::instance(),
Language::Singleton<Language::Russian>::instance(),
Language::Singleton<Language::French>::instance(),
Language::Singleton<Language::Dutch>::instance()
});
for (std::vector<Language::Base*>::iterator it = languages.begin(); it != languages.end(); it++)
{
try {
test_language(*(*it));
}
catch (const std::exception &e) {
std::cout << "Error testing " << (*it)->get_language_name() << " language: " << e.what() << std::endl;
ASSERT_TRUE(false);
}
}
}
void FullInfoMetaRequestPrivate::handleMoreInfo(const DataUnit &data)
{
quint16 age = data.read<quint16>(LittleEndian);
if (age != 0)
values.insert(Age, age);
{
quint8 genderId = data.read<quint8>();
if (genderId)
values.insert(Gender, genders().value(genderId));
}
readString(Homepage, data);
{
quint16 y = data.read<quint16>(LittleEndian);
quint8 m = data.read<quint8>();
quint8 d = data.read<quint8>();
if (QDate::isValid(y, m, d))
values.insert(Birthday, QDate(y, m, d));
}
{
QStringList langList;
for (int i = 0; i < 3; ++i) {
QString lang = languages().value(data.read<quint8>());
if (!lang.isEmpty())
langList << lang;
}
if (!langList.isEmpty())
values.insert(Languages, langList);
}
data.skipData(2); // 0x0000 unknown
readString(OriginalCity, data);
readString(OriginalState, data);
readField<quint16>(OriginalCountry, data, countries());
values.insert(GMT, data.read<qint8>());
}
void bmct::show_vcc_plain(std::ostream &out)
{
out << "\n" << "VERIFICATION CONDITIONS:" << "\n" << "\n";
languagest languages(ns, new_ansi_c_language());
bool has_threads=equation.has_threads();
for(symex_target_equationt::SSA_stepst::iterator
s_it=equation.SSA_steps.begin();
s_it!=equation.SSA_steps.end();
s_it++)
{
if(!s_it->is_assert())
continue;
if(s_it->source.pc->source_location.is_not_nil())
out << s_it->source.pc->source_location << "\n";
if(s_it->comment!="")
out << s_it->comment << "\n";
symex_target_equationt::SSA_stepst::const_iterator
p_it=equation.SSA_steps.begin();
// we show everything in case there are threads
symex_target_equationt::SSA_stepst::const_iterator
last_it=has_threads?equation.SSA_steps.end():s_it;
for(unsigned count=1; p_it!=last_it; p_it++)
if(p_it->is_assume() || p_it->is_assignment() || p_it->is_constraint())
{
if(!p_it->ignore)
{
std::string string_value;
languages.from_expr(p_it->cond_expr, string_value);
out << "{-" << count << "} " << string_value << "\n";
#if 0
languages.from_expr(p_it->guard_expr, string_value);
out << "GUARD: " << string_value << "\n";
out << "\n";
#endif
count++;
}
}
out << "|--------------------------" << "\n";
std::string string_value;
languages.from_expr(s_it->cond_expr, string_value);
out << "{" << 1 << "} " << string_value << "\n";
out << "\n";
}
}
void bmct::show_vcc_json(std::ostream &out)
{
json_objectt json_result;
json_arrayt &json_vccs=json_result["vccs"].make_array();
languagest languages(ns, new_ansi_c_language());
bool has_threads=equation.has_threads();
for(symex_target_equationt::SSA_stepst::iterator
s_it=equation.SSA_steps.begin();
s_it!=equation.SSA_steps.end();
s_it++)
{
if(!s_it->is_assert())
continue;
// vcc object
json_objectt &object=json_vccs.push_back(jsont()).make_object();
const source_locationt &source_location=s_it->source.pc->source_location;
if(source_location.is_not_nil())
object["sourceLocation"]=json(source_location);
const std::string &s=s_it->comment;
if(!s.empty())
object["comment"]=json_stringt(s);
// we show everything in case there are threads
symex_target_equationt::SSA_stepst::const_iterator
last_it=has_threads?equation.SSA_steps.end():s_it;
json_arrayt &json_constraints=object["constraints"].make_array();
for(symex_target_equationt::SSA_stepst::const_iterator p_it
=equation.SSA_steps.begin();
p_it!=last_it; p_it++)
{
if((p_it->is_assume() ||
p_it->is_assignment() ||
p_it->is_constraint()) &&
!p_it->ignore)
{
std::string string_value;
languages.from_expr(p_it->cond_expr, string_value);
json_constraints.push_back(json_stringt(string_value));
}
}
std::string string_value;
languages.from_expr(s_it->cond_expr, string_value);
object["expression"]=json_stringt(string_value);
}
out << ",\n" << json_result;
}
void bmc_baset::show_vcc(std::ostream &out)
{
switch(ui)
{
case ui_message_handlert::OLD_GUI:
case ui_message_handlert::XML_UI:
error("not supported");
return;
case ui_message_handlert::PLAIN:
break;
default:
assert(false);
}
out << std::endl << "VERIFICATION CONDITIONS:" << std::endl << std::endl;
languagest languages(ns, new_ansi_c_language());
for(symex_target_equationt::SSA_stepst::iterator
it=equation.SSA_steps.begin();
it!=equation.SSA_steps.end(); it++)
{
if(!it->is_assert()) continue;
if(it->source.pc->location.is_not_nil())
out << it->source.pc->location << std::endl;
if(it->comment!="")
out << it->comment << std::endl;
symex_target_equationt::SSA_stepst::const_iterator
p_it=equation.SSA_steps.begin();
for(unsigned count=1; p_it!=it; p_it++)
if(p_it->is_assume() || p_it->is_assignment())
if(!p_it->ignore)
{
std::string string_value;
languages.from_expr(p_it->cond_expr, string_value);
out << "{-" << count << "} " << string_value << std::endl;
count++;
}
out << "|--------------------------" << std::endl;
std::string string_value;
languages.from_expr(it->cond_expr, string_value);
out << "{" << 1 << "} " << string_value << std::endl;
out << std::endl;
}
}
QStringList Loader::languageNames() const
{
/* For whatever reason languages() might change. So,
* to be in sync with it let's do the following check.
*/
if (d->languagesNameCache.count() == languages().count()) {
return d->languagesNameCache;
}
QStringList allLocalizedDictionaries;
Q_FOREACH (const QString& langCode, languages()) {
allLocalizedDictionaries.append(languageNameForCode(langCode));
}
TEST(mnemonics, all_languages)
{
srand(time(NULL));
std::vector<Language::Base*> languages({
Language::Singleton<Language::English>::instance(),
Language::Singleton<Language::Spanish>::instance(),
Language::Singleton<Language::Portuguese>::instance(),
Language::Singleton<Language::Japanese>::instance(),
});
for (std::vector<Language::Base*>::iterator it = languages.begin(); it != languages.end(); it++)
{
test_language(*(*it));
}
}
/*!
Returns a deep-copied clone of the QUmlOpaqueExpression.
*/
QModelingElement *QUmlOpaqueExpression::clone() const
{
QUmlOpaqueExpression *c = new QUmlOpaqueExpression;
c->asQModelingObject()->setObjectName(this->asQModelingObject()->objectName());
c->asQModelingObject()->setProperty("role", this->asQModelingObject()->property("role"));
foreach (QUmlComment *element, ownedComments())
c->addOwnedComment(dynamic_cast<QUmlComment *>(element->clone()));
c->setName(name());
if (nameExpression())
c->setNameExpression(dynamic_cast<QUmlStringExpression *>(nameExpression()->clone()));
c->setVisibility(visibility());
foreach (QString element, bodies())
c->addBody(element);
foreach (QString element, languages())
c->addLanguage(element);
return c;
}
/** Returns a list of all supported language names (e.g., "English"). */
QStringList
LanguageSupport::languageNames()
{
return languages().values();
}
/** Returns the language name for a given language code. */
QString
LanguageSupport::languageName(const QString &languageCode)
{
return languages().value(languageCode);
}
/** Returns a list of all supported language codes. (e.g., "en"). */
QStringList
LanguageSupport::languageCodes()
{
return languages().keys();
}
/** Returns the language code for a given language name. */
QString
LanguageSupport::languageCode(const QString &languageName)
{
return languages().key(languageName);
}
int dlgLanguage::Go(bool modal)
{
if (!connection->BackendMinimumVersion(8, 3))
cbOwner->Disable();
if (!connection->BackendMinimumVersion(7, 5))
txtComment->Disable();
if (!connection->BackendMinimumVersion(9, 0))
cbInline->Disable();
if (connection->BackendMinimumVersion(9, 1))
{
seclabelPage->SetConnection(connection);
seclabelPage->SetObject(language);
this->Connect(EVT_SECLABELPANEL_CHANGE, wxCommandEventHandler(dlgLanguage::OnChange));
}
else
seclabelPage->Disable();
if (language)
{
// edit mode
chkTrusted->SetValue(language->GetTrusted());
cbHandler->Append(language->GetHandlerProc());
cbHandler->SetSelection(0);
if (connection->BackendMinimumVersion(9, 0))
{
cbInline->Append(language->GetInlineProc());
cbInline->SetSelection(0);
}
wxString val = language->GetValidatorProc();
if (!val.IsEmpty())
{
cbValidator->Append(val);
cbValidator->SetSelection(0);
}
cbName->SetValue(language->GetName());
if (!connection->BackendMinimumVersion(7, 4))
cbName->Disable();
chkTrusted->Disable();
cbHandler->Disable();
cbInline->Disable();
cbValidator->Disable();
}
else
{
// create mode
if (connection->BackendMinimumVersion(8, 1))
{
pgSetIterator languages(connection,
wxT("SELECT tmplname FROM pg_pltemplate\n")
wxT(" LEFT JOIN pg_language ON tmplname=lanname\n")
wxT(" WHERE lanname IS NULL\n")
wxT(" ORDER BY tmplname"));
while (languages.RowsLeft())
cbName->Append(languages.GetVal(wxT("tmplname")));
}
else
{
// to clear drop down list
cbName->Append(wxT(" "));
cbName->Delete(0);
}
cbValidator->Append(wxT(""));
pgSet *set = connection->ExecuteSet(
wxT("SELECT nspname, proname, prorettype, proargtypes[0] AS argtype\n")
wxT(" FROM pg_proc p\n")
wxT(" JOIN pg_namespace nsp ON nsp.oid=pronamespace\n")
wxT(" WHERE prorettype=") + NumToStr(PGOID_TYPE_LANGUAGE_HANDLER) + wxT("\n")
wxT(" OR (prorettype=") + NumToStr(PGOID_TYPE_VOID) +
wxT(" AND proargtypes[0]=") + NumToStr(PGOID_TYPE_LANGUAGE_HANDLER) + wxT(")")
wxT(" OR (prorettype=") + NumToStr(PGOID_TYPE_VOID) +
wxT(" AND proargtypes[0]=") + NumToStr(PGOID_TYPE_INTERNAL) + wxT(")"));
if (set)
{
while (!set->Eof())
{
wxString procname = database->GetSchemaPrefix(set->GetVal(wxT("nspname"))) + set->GetVal(wxT("proname"));
if (set->GetOid(wxT("prorettype")) == PGOID_TYPE_LANGUAGE_HANDLER)
cbHandler->Append(procname);
else
{
if (set->GetOid(wxT("argtype")) == PGOID_TYPE_LANGUAGE_HANDLER)
cbValidator->Append(procname);
else
cbInline->Append(procname);
}
set->MoveNext();
}
delete set;
}
cbHandler->SetSelection(0);
cbInline->SetSelection(0);
cbValidator->SetSelection(0);
}
return dlgSecurityProperty::Go(modal);
}
