void SearchOptions::deserializeSettings(const QString allOptions)
{
setMatchEntireString();
setMatchAsString();
setCaseSensitive(false);
setBackwards(false);
setAllColumns(false);
setWrap(false);
setIsReplace(false);
setIsReplaceAll(false);
QStringList list = allOptions.split(",");
for (int i=0; i<list.count(); ++i) {
QString s = list.at(i);
if (s.compare("MatchEntireString", Qt::CaseInsensitive) == 0) {
setMatchEntireString();
} else if (s.compare("Contains", Qt::CaseInsensitive) == 0) {
setContains();
} else if (s.compare("StartsWith", Qt::CaseInsensitive) == 0) {
setStartsWith();
} else if (s.compare("EndsWith", Qt::CaseInsensitive) == 0) {
setEndsWith();
} else if (s.compare("AsString", Qt::CaseInsensitive) == 0) {
setMatchAsString();
} else if (s.compare("RegExp", Qt::CaseInsensitive) == 0) {
setRegularExpression();
} else if (s.compare("Wildcard", Qt::CaseInsensitive) == 0) {
setWildCard();
} else if (s.compare("CaseSensitive", Qt::CaseInsensitive) == 0) {
setCaseSensitive();
} else if (s.compare("CaseInSensitive", Qt::CaseInsensitive) == 0) {
setCaseSensitive(false);
} else if (s.compare("Wrap", Qt::CaseInsensitive) == 0) {
setWrap(true);
} else if (s.compare("NoWrap", Qt::CaseInsensitive) == 0) {
setWrap(false);
} else if (s.compare("Backward", Qt::CaseInsensitive) == 0) {
setBackwards(true);
} else if (s.compare("Forward", Qt::CaseInsensitive) == 0) {
setBackwards(false);
} else if (s.compare("AllColumns", Qt::CaseInsensitive) == 0) {
setAllColumns(true);
} else if (s.compare("OneColumn", Qt::CaseInsensitive) == 0) {
setAllColumns(false);
} else if (s.compare("Replace", Qt::CaseInsensitive) == 0) {
setIsReplace(true);
} else if (s.compare("ReplaceAll", Qt::CaseInsensitive) == 0) {
setIsReplaceAll(true);
}
}
}
void SearchOptions::setToDefault()
{
setContains();
setMatchAsString();
setCaseSensitive(false);
setWrap(true);
setBackwards(false);
setAllColumns(false);
m_isReplace = false;
setIsReplaceAll(false);
}
bool QCompletionEdit::qt_invoke( int _id, QUObject* _o )
{
switch ( _id - staticMetaObject()->slotOffset() ) {
case 0: setCompletionList((const QStringList&)*((const QStringList*)static_QUType_ptr.get(_o+1))); break;
case 1: setAutoAdd((bool)static_QUType_bool.get(_o+1)); break;
case 2: clear(); break;
case 3: addCompletionEntry((const QString&)static_QUType_QString.get(_o+1)); break;
case 4: removeCompletionEntry((const QString&)static_QUType_QString.get(_o+1)); break;
case 5: setCaseSensitive((bool)static_QUType_bool.get(_o+1)); break;
case 6: textDidChange((const QString&)static_QUType_QString.get(_o+1)); break;
default:
return QLineEdit::qt_invoke( _id, _o );
}
return TRUE;
}
bool QCompletionEdit::qt_property( int id, int f, QVariant* v)
{
switch ( id - staticMetaObject()->propertyOffset() ) {
case 0: switch( f ) {
case 0: setAutoAdd(v->asBool()); break;
case 1: *v = QVariant( this->autoAdd(), 0 ); break;
case 3: case 4: case 5: break;
default: return FALSE;
} break;
case 1: switch( f ) {
case 0: setCaseSensitive(v->asBool()); break;
case 1: *v = QVariant( this->isCaseSensitive(), 0 ); break;
case 3: case 4: case 5: break;
default: return FALSE;
} break;
default:
return QLineEdit::qt_property( id, f, v );
}
return TRUE;
}
void SearchOptions::setMatchFlags(const Qt::MatchFlags flags)
{
if ((flags & Qt::MatchWildcard) == Qt::MatchWildcard) {
setWildCard();
} else if ((flags & Qt::MatchRegExp) == Qt::MatchRegExp) {
setRegularExpression();
} else {
setMatchAsString();
}
if ((flags & Qt::MatchEndsWith) == Qt::MatchEndsWith) {
setEndsWith();
} else if ((flags & Qt::MatchStartsWith) == Qt::MatchStartsWith) {
setStartsWith();
} else if ((flags & Qt::MatchContains) == Qt::MatchContains) {
setContains();
} else {
setMatchEntireString();
}
setCaseSensitive((flags & Qt::MatchCaseSensitive) == Qt::MatchCaseSensitive);
setWrap((flags & Qt::MatchWrap) == Qt::MatchWrap);
}
TagComparator::TagComparator()
{
setCaseSensitive(ConfigOptions().getDuplicateNameCaseSensitive());
}
// -----------------------------------------------------------------------------
// Reads in a text definition of a language. See slade.pk3 for
// formatting examples
// -----------------------------------------------------------------------------
bool TextLanguage::readLanguageDefinition(MemChunk& mc, string_view source)
{
Tokenizer tz;
// Open the given text data
if (!tz.openMem(mc, source))
{
Log::warning("Unable to open language definition {}", source);
return false;
}
// Parse the definition text
ParseTreeNode root;
if (!root.parse(tz))
return false;
// Get parsed data
for (unsigned a = 0; a < root.nChildren(); a++)
{
auto node = root.childPTN(a);
// Create language
auto lang = new TextLanguage(node->name());
// Check for inheritance
if (!node->inherit().empty())
{
auto inherit = fromId(node->inherit());
if (inherit)
inherit->copyTo(lang);
else
Log::warning("Warning: Language {} inherits from undefined language {}", node->name(), node->inherit());
}
// Parse language info
for (unsigned c = 0; c < node->nChildren(); c++)
{
auto child = node->childPTN(c);
auto pn_lower = StrUtil::lower(child->name());
// Language name
if (pn_lower == "name")
lang->setName(child->stringValue());
// Comment begin
else if (pn_lower == "comment_begin")
{
lang->setCommentBeginList(child->stringValues());
}
// Comment end
else if (pn_lower == "comment_end")
{
lang->setCommentEndList(child->stringValues());
}
// Line comment
else if (pn_lower == "comment_line")
{
lang->setLineCommentList(child->stringValues());
}
// Preprocessor
else if (pn_lower == "preprocessor")
lang->setPreprocessor(child->stringValue());
// Case sensitive
else if (pn_lower == "case_sensitive")
lang->setCaseSensitive(child->boolValue());
// Doc comment
else if (pn_lower == "comment_doc")
lang->setDocComment(child->stringValue());
// Keyword lookup link
else if (pn_lower == "keyword_link")
lang->word_lists_[WordType::Keyword].lookup_url = child->stringValue();
// Constant lookup link
else if (pn_lower == "constant_link")
lang->word_lists_[WordType::Constant].lookup_url = child->stringValue();
// Function lookup link
else if (pn_lower == "function_link")
lang->f_lookup_url_ = child->stringValue();
// Jump blocks
else if (pn_lower == "blocks")
{
for (unsigned v = 0; v < child->nValues(); v++)
lang->jump_blocks_.push_back(child->stringValue(v));
}
else if (pn_lower == "blocks_ignore")
{
for (unsigned v = 0; v < child->nValues(); v++)
lang->jb_ignore_.push_back(child->stringValue(v));
}
// Block begin
else if (pn_lower == "block_begin")
lang->block_begin_ = child->stringValue();
// Block end
else if (pn_lower == "block_end")
lang->block_end_ = child->stringValue();
// Preprocessor block begin
else if (pn_lower == "pp_block_begin")
{
for (unsigned v = 0; v < child->nValues(); v++)
lang->pp_block_begin_.push_back(child->stringValue(v));
}
// Preprocessor block end
else if (pn_lower == "pp_block_end")
{
for (unsigned v = 0; v < child->nValues(); v++)
lang->pp_block_end_.push_back(child->stringValue(v));
}
// Word block begin
else if (pn_lower == "word_block_begin")
{
for (unsigned v = 0; v < child->nValues(); v++)
lang->word_block_begin_.push_back(child->stringValue(v));
}
// Word block end
else if (pn_lower == "word_block_end")
{
for (unsigned v = 0; v < child->nValues(); v++)
lang->word_block_end_.push_back(child->stringValue(v));
}
// Keywords
else if (pn_lower == "keywords")
{
// Go through values
for (unsigned v = 0; v < child->nValues(); v++)
{
auto val = child->stringValue(v);
// Check for '$override'
if (StrUtil::equalCI(val, "$override"))
{
// Clear any inherited keywords
lang->clearWordList(WordType::Keyword);
}
// Not a special symbol, add as keyword
else
lang->addWord(WordType::Keyword, val);
}
}
// Constants
else if (pn_lower == "constants")
{
// Go through values
for (unsigned v = 0; v < child->nValues(); v++)
{
auto val = child->stringValue(v);
// Check for '$override'
if (StrUtil::equalCI(val, "$override"))
{
// Clear any inherited constants
lang->clearWordList(WordType::Constant);
}
// Not a special symbol, add as constant
else
lang->addWord(WordType::Constant, val);
}
}
// Types
else if (pn_lower == "types")
{
// Go through values
for (unsigned v = 0; v < child->nValues(); v++)
{
auto val = child->stringValue(v);
// Check for '$override'
if (StrUtil::equalCI(val, "$override"))
{
// Clear any inherited constants
lang->clearWordList(WordType::Type);
}
// Not a special symbol, add as constant
else
lang->addWord(WordType::Type, val);
}
}
// Properties
else if (pn_lower == "properties")
{
// Go through values
for (unsigned v = 0; v < child->nValues(); v++)
{
auto val = child->stringValue(v);
// Check for '$override'
if (StrUtil::equalCI(val, "$override"))
{
// Clear any inherited constants
lang->clearWordList(WordType::Property);
}
// Not a special symbol, add as constant
else
lang->addWord(WordType::Property, val);
}
}
// Functions
else if (pn_lower == "functions")
{
bool lang_has_void = lang->isWord(Keyword, "void") || lang->isWord(Type, "void");
if (lang->id_ != "zscript")
{
// Go through children (functions)
for (unsigned f = 0; f < child->nChildren(); f++)
{
auto child_func = child->childPTN(f);
string params;
// Simple definition
if (child_func->nChildren() == 0)
{
if (child_func->stringValue(0).empty())
{
if (lang_has_void)
params = "void";
else
params = "";
}
else
{
params = child_func->stringValue(0);
}
// Add function
lang->addFunction(
child_func->name(),
params,
"",
"",
!StrUtil::contains(child_func->name(), '.'),
child_func->type());
// Add args
for (unsigned v = 1; v < child_func->nValues(); v++)
lang->addFunction(child_func->name(), child_func->stringValue(v));
}
// Full definition
else
{
string name = child_func->name();
vector<string> args;
string desc;
string deprecated;
for (unsigned p = 0; p < child_func->nChildren(); p++)
{
auto child_prop = child_func->childPTN(p);
if (child_prop->name() == "args")
{
for (unsigned v = 0; v < child_prop->nValues(); v++)
args.push_back(child_prop->stringValue(v));
}
else if (child_prop->name() == "description")
desc = child_prop->stringValue();
else if (child_prop->name() == "deprecated")
deprecated = child_prop->stringValue();
}
if (args.empty() && lang_has_void)
args.emplace_back("void");
for (unsigned as = 0; as < args.size(); as++)
lang->addFunction(name, args[as], desc, deprecated, as == 0, child_func->type());
}
}
}
// ZScript function info which cannot be parsed from (g)zdoom.pk3
else
{
ZFuncExProp ex_prop;
for (unsigned f = 0; f < child->nChildren(); f++)
{
auto child_func = child->childPTN(f);
for (unsigned p = 0; p < child_func->nChildren(); ++p)
{
auto child_prop = child_func->childPTN(p);
if (child_prop->name() == "description")
ex_prop.description = child_prop->stringValue();
else if (child_prop->name() == "deprecated_f")
ex_prop.deprecated_f = child_prop->stringValue();
}
lang->zfuncs_ex_props_.emplace(child_func->name(), ex_prop);
}
}
}
}
}
return true;
}
