/*! Client side method call that converts an argument of type to its corresponding value as a valid type supported by the QtDBus type system. Supports conversion from a QVariant, QList, QMap, QHash, and custom user-defined types. */ QVariant ObjectEndPoint::toDBusVariant(const QByteArray& typeName, const QVariant& arg) { QVariant dbusVariant = arg; int type = QMetaType::type(typeName); if (type == QMetaType::QVariant) { // Wrap QVariants in a QDBusVariant QDBusVariant replacement(arg); dbusVariant = QVariant::fromValue(replacement); } else if (type >= QMetaType::User) { // Wrap custom types in a QDBusVariant of the type name and // a buffer of its variant-wrapped data QByteArray buffer; QDataStream stream(&buffer, QIODevice::ReadWrite | QIODevice::Append); stream << arg; QServiceUserTypeDBus customType; customType.typeName = typeName; customType.variantBuffer = buffer; QDBusVariant replacement(QVariant::fromValue(customType)); dbusVariant = QVariant::fromValue(replacement); } return dbusVariant; }
void KReplaceDialog::slotOk() { // If regex and backrefs are enabled, do a sanity check. if(m_regExp->isChecked() && m_backRef->isChecked()) { QRegExp r(pattern()); int caps = r.numCaptures(); QRegExp check(QString("((?:\\\\)+)(\\d+)")); int p = 0; QString rep = replacement(); while((p = check.search(rep, p)) > -1) { if(check.cap(1).length() % 2 && check.cap(2).toInt() > caps) { KMessageBox::information( this, i18n("Your replacement string is referencing a capture greater than '\\%1', ").arg(caps) + (caps ? i18n("but your pattern only defines 1 capture.", "but your pattern only defines %n captures.", caps) : i18n("but your pattern defines no captures.")) + i18n("\nPlease correct.")); return; // abort OKing } p += check.matchedLength(); } } KFindDialog::slotOk(); m_replace->addToHistory(replacement()); }
//--------------------------------------------------------------------------------------------------------------------// //Afairese tis perites parenthesis apo ena dentro parenthesis * simplify(parenthesis * input) { int i=0; parenthesis ** kids=input->subparenthesis; parenthesis * temporal; char * temp=(char*) malloc(MAX); if(temp== NULL) { fprintf(stderr, "out of memory\n"); return NULL; } if((input->kids)==1) { strcpy(temp,kids[0]->content); wrapwithparenthesis(temp); if(!strcmp(temp,input->content)) { replacement(input->content,input->content, kids[0]->content); temporal=addpar(input->content,input->parent,NULL,input->num,input->depth); removetree(input); free(input); } else { return input; } temporal=simplify(temporal); free(temp); return temporal; } else if ((input->kids)>1) { for(i=0;i<input->kids;i++) { strcpy(temp,(kids[i]->content)); kids[i]= simplify(kids[i]); replacement(input->content,temp, kids[i]->content); temporal=addpar(input->content,input->parent,NULL,input->num,input->depth); removetree(input); free(input); input=temporal; kids=input->subparenthesis; } free(temp); } else { free(temp); return input; } return input; }
static void NativeConverter_setCallbackDecode(JNIEnv* env, jclass, jlong address, jint onMalformedInput, jint onUnmappableInput, jstring javaReplacement) { UConverter* cnv = toUConverter(address); if (cnv == NULL) { maybeThrowIcuException(env, "toConverter", U_ILLEGAL_ARGUMENT_ERROR); return; } UConverterToUCallback oldCallback; const void* oldCallbackContext; ucnv_getToUCallBack(cnv, &oldCallback, &oldCallbackContext); DecoderCallbackContext* callbackContext = const_cast<DecoderCallbackContext*>( reinterpret_cast<const DecoderCallbackContext*>(oldCallbackContext)); if (callbackContext == NULL) { callbackContext = new DecoderCallbackContext; } callbackContext->onMalformedInput = getToUCallback(onMalformedInput); callbackContext->onUnmappableInput = getToUCallback(onUnmappableInput); ScopedStringChars replacement(env, javaReplacement); if (replacement.get() == NULL) { maybeThrowIcuException(env, "replacement", U_ILLEGAL_ARGUMENT_ERROR); return; } u_strncpy(callbackContext->replacementChars, replacement.get(), replacement.size()); callbackContext->replacementCharCount = replacement.size(); UErrorCode errorCode = U_ZERO_ERROR; ucnv_setToUCallBack(cnv, CHARSET_DECODER_CALLBACK, callbackContext, NULL, NULL, &errorCode); maybeThrowIcuException(env, "ucnv_setToUCallBack", errorCode); }
int myFunction(int arg1, int arg2) { int intermediate = arg1 + arg2; int anotherVal = arg1*arg2; int functionVal = replacement(); return intermediate + anotherVal + functionVal; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int ModifiedLambertProjectionArray::eraseTuples(QVector<size_t>& idxs) { int err = 0; // If nothing is to be erased just return if(idxs.size() == 0) { return 0; } if (static_cast<size_t>(idxs.size()) >= getNumberOfTuples() ) { resize(0); return 0; } // Sanity Check the Indices in the vector to make sure we are not trying to remove any indices that are // off the end of the array and return an error code. for(QVector<size_t>::size_type i = 0; i < idxs.size(); ++i) { if (idxs[i] >= static_cast<size_t>(m_ModifiedLambertProjectionArray.size())) { return -100; } } QVector<ModifiedLambertProjection::Pointer> replacement(m_ModifiedLambertProjectionArray.size() - idxs.size()); qint32 idxsIndex = 0; size_t rIdx = 0; size_t count = static_cast<size_t>(m_ModifiedLambertProjectionArray.size()); for(size_t dIdx = 0; dIdx < count; ++dIdx) { if (dIdx != idxs[idxsIndex]) { replacement[rIdx] = m_ModifiedLambertProjectionArray[dIdx]; ++rIdx; } else { ++idxsIndex; if (idxsIndex == idxs.size() ) { idxsIndex--; } } } m_ModifiedLambertProjectionArray = replacement; return err; }
void XML_Element::set_string(const String &s) { if(!good()) { std::cerr << "Bad XML_Element_c attempted set_string(...)\n"; throw XML_Element_Ungood(); } TiXmlNode * const node = first_child(); if(!node) m_handle.ToNode()->LinkEndChild(new TiXmlText(s.c_str())); else if(node->ToText()) { TiXmlText replacement(s.c_str()); m_handle.ToNode()->ReplaceChild(node, replacement); } else { std::cerr << "XML_Element_c attempted set_string(...) on non-leaf node\n"; throw XML_Element_Nonleaf(); } }
/** * @brief Removes Tuples from the Array. If the size of the vector is Zero nothing is done. If the size of the * vector is greater than or Equal to the number of Tuples then the Array is Resized to Zero. If there are * indices that are larger than the size of the original (before erasing operations) then an error code (-100) is * returned from the program. * @param idxs The indices to remove * @return error code. */ virtual int EraseTuples(std::vector<size_t> &idxs) { int err = 0; // If nothing is to be erased just return if(idxs.size() == 0) { return 0; } if (idxs.size() >= GetNumberOfTuples() ) { Resize(0); return 0; } // Sanity Check the Indices in the vector to make sure we are not trying to remove any indices that are // off the end of the array and return an error code. for(std::vector<size_t>::size_type i = 0; i < idxs.size(); ++i) { if (idxs[i] >= _data.size()) { return -100; } } std::vector<SharedVectorType> replacement(_data.size() - idxs.size()); size_t idxsIndex = 0; size_t rIdx = 0; for(size_t dIdx = 0; dIdx < _data.size(); ++dIdx) { if (dIdx != idxs[idxsIndex]) { replacement[rIdx] = _data[dIdx]; ++rIdx; } else { ++idxsIndex; if (idxsIndex == idxs.size() ) { idxsIndex--;} } } _data = replacement; return err; }
bool CLReplacePattern(const wxString& in, const wxString& pattern, const wxString& replaceWith, wxString &outStr) { int where = pattern.Find(wxT("%0")); if(where != wxNOT_FOUND) { wxString replacement(replaceWith); // a patterened expression wxString searchFor = pattern.BeforeFirst(wxT('(')); where = in.Find(searchFor); if(where == wxNOT_FOUND) { return false; } wxString initList; wxArrayString initListArr; if(PPToken::readInitList(in, searchFor.Length() + where, initList, initListArr) == false) return false; outStr = in; // update the 'replacement' with the actual values ( replace %0..%n) for(size_t i=0; i<initListArr.size(); i++) { wxString placeHolder; placeHolder << wxT("%") << i; replacement.Replace(placeHolder, initListArr.Item(i)); } outStr.Remove(where, searchFor.Length() + initList.Length()); outStr.insert(where, replacement); return true; } else { if(in.Find(pattern) == wxNOT_FOUND) { return false; } // simple replacement outStr = ReplaceWord(in, pattern, replaceWith); return outStr != in; } }
QgsStringReplacementCollection QgsSubstitutionListWidget::substitutions() const { QList< QgsStringReplacement > result; for ( int i = 0; i < mTableSubstitutions->rowCount(); ++i ) { if ( !mTableSubstitutions->item( i, 0 ) ) continue; if ( mTableSubstitutions->item( i, 0 )->text().isEmpty() ) continue; QCheckBox *chkCaseSensitive = qobject_cast<QCheckBox *>( mTableSubstitutions->cellWidget( i, 2 ) ); QCheckBox *chkWholeWord = qobject_cast<QCheckBox *>( mTableSubstitutions->cellWidget( i, 3 ) ); QgsStringReplacement replacement( mTableSubstitutions->item( i, 0 )->text(), mTableSubstitutions->item( i, 1 )->text(), chkCaseSensitive->isChecked(), chkWholeWord->isChecked() ); result << replacement; } return QgsStringReplacementCollection( result ); }
Command *parser(char *path, int *size_com, int *num_str, int *err) { Command *commands; Label *labels; int point_com = 0, point_lbl = 0; FILE *input; *num_str = 0; input = fopen(path, "r"); commands = (Command *)malloc(sizeof(Command) * SIZE_COMMAND); labels = (Label *)malloc(sizeof(Label) * SIZE_LABEL); while(!feof(input)) { char str[SIZE_STRING], *lexeme; int point_str = 0; str[0] = 0; ++(*num_str); if ((point_com - 1) % SIZE_COMMAND == 0) commands = (Command *)realloc(commands, sizeof(Command) * (point_com + SIZE_COMMAND)); if ((point_lbl - 1) % SIZE_LABEL == 0) labels = (Label *)realloc(labels, sizeof(Label) * (point_lbl + SIZE_LABEL)); fgets(str, SIZE_STRING - 1, input); lexeme = read_word(str, &point_str, err); if (*err != 0) { clean_arrays(commands, point_com, labels, point_lbl); return NULL; } commands[point_com].opcode = is_command(lexeme); if (commands[point_com].opcode == LDC) commands[point_com].number = read_number(str, &point_str, err); else if ((commands[point_com].opcode == LD) || (commands[point_com].opcode == ST)) commands[point_com].address = read_address(str, &point_str, err); else if ((commands[point_com].opcode == BR) || (commands[point_com].opcode == JMP)) { commands[point_com].label = read_word(str, &point_str, err); if (*err == 1) *err = 5; if (*err == 0) { if (is_command(commands[point_com].label) == LBL) put_in_array(labels, &point_lbl, commands[point_com].label, -1, *num_str, err); else *err = 5; } } else if (commands[point_com].opcode == LBL) { while ((str[point_str] == ' ') || (str[point_str] == 9)) ++point_str; if (str[point_str++] == ':') put_in_array(labels, &point_lbl, lexeme, point_com, *num_str, err); else *err = 6; } if (*err != 0) { clean_arrays(commands, point_com + 1, labels, point_lbl); return NULL; } while ((str[point_str] == ' ') || (str[point_str] == 9)) ++point_str; if ((str[point_str] != ';') && (str[point_str] != 0) && (str[point_str] != '\n')) { *err = 8; clean_arrays(commands, point_com + 1, labels, point_lbl); return NULL; } if ((commands[point_com].opcode != LBL) && (commands[point_com].opcode != NUL)) { commands[point_com].num_str = *num_str; ++point_com; } } replacement(commands, point_com, labels, point_lbl, num_str, err); if (*err != 0) { clean_arrays(commands, point_com, labels, point_lbl); return NULL; } else { *size_com = point_com; return commands; } }
Symbol* Converter::primitive_convert(STATE, Object* source, String* target, Fixnum* offset, Fixnum* size, Fixnum* options) { String* src = 0; if(!source->nil_p()) { if(!(src = try_as<String>(source))) { return force_as<Symbol>(Primitives::failure()); } } OnStack<3> os(state, source, src, target); const unsigned char* source_ptr = 0; const unsigned char* source_end = 0; native_int byte_offset = offset->to_native(); native_int byte_size = size->to_native(); retry: if(!converter_) { size_t num_converters = converters()->size(); converter_ = rb_econv_alloc(num_converters); for(size_t i = 0; i < num_converters; i++) { Transcoding* transcoding = as<Transcoding>(converters()->get(state, i)); rb_transcoder* tr = transcoding->get_transcoder(); if(rb_econv_add_transcoder_at(converter_, tr, i) == -1) { rb_econv_free(converter_); converter_ = NULL; return force_as<Symbol>(Primitives::failure()); } } } /* It would be nice to have a heuristic that avoids having to reconvert * after growing the destination buffer. This is complicated, however, as * a converter may contain more than one transcoder. So, the heuristic * would need to be transitive. This requires getting the encoding objects * for every stage of the converter to check the min/max byte values. */ if(byte_size == -1) { byte_size = src ? src->byte_size() : 4096; } int flags = converter_->flags = options->to_native(); if(!replacement()->nil_p()) { native_int byte_size = replacement()->byte_size(); char* buf = (char*)XMALLOC(byte_size + 1); strncpy(buf, replacement()->c_str(state), byte_size + 1); converter_->replacement_str = (const unsigned char*)buf; converter_->replacement_len = replacement()->byte_size(); String* name = replacement()->encoding()->name(); byte_size = name->byte_size(); buf = (char*)XMALLOC(byte_size + 1); strncpy(buf, name->c_str(state), byte_size + 1); converter_->replacement_enc = (const char*)buf; converter_->replacement_allocated = 1; size_t num_converters = replacement_converters()->size(); rb_econv_alloc_replacement_converters(converter_, num_converters / 2); for(size_t i = 0, k = 0; i < num_converters; k++, i += 2) { rb_econv_replacement_converters* repl_converter; repl_converter = converter_->replacement_converters + k; name = as<String>(replacement_converters()->get(state, i)); byte_size = name->byte_size(); buf = (char*)XMALLOC(byte_size + 1); strncpy(buf, name->c_str(state), byte_size + 1); repl_converter->destination_encoding_name = (const char*)buf; Array* trs = as<Array>(replacement_converters()->get(state, i + 1)); size_t num_transcoders = trs->size(); repl_converter->num_transcoders = num_transcoders; repl_converter->transcoders = ALLOC_N(rb_transcoder*, num_transcoders); for(size_t j = 0; j < num_transcoders; j++) { Transcoding* transcoding = as<Transcoding>(trs->get(state, j)); rb_transcoder* tr = transcoding->get_transcoder(); repl_converter->transcoders[j] = tr; } } }
Symbol* Converter::primitive_convert(STATE, Object* source, String* target, Fixnum* offset, Fixnum* size, Fixnum* options) { String* src = 0; if(!source->nil_p()) { if(!(src = try_as<String>(source))) { return force_as<Symbol>(Primitives::failure()); } } if(!converter_) { size_t num_converters = converters()->size(); converter_ = rb_econv_alloc(num_converters); for(size_t i = 0; i < num_converters; i++) { Transcoding* transcoding = as<Transcoding>(converters()->get(state, i)); rb_transcoder* tr = transcoding->get_transcoder(); if(rb_econv_add_transcoder_at(converter_, tr, i) == -1) { rb_econv_free(converter_); converter_ = NULL; return force_as<Symbol>(Primitives::failure()); } } } if(!replacement()->nil_p()) { native_int byte_size = replacement()->byte_size(); char* buf = (char*)XMALLOC(byte_size + 1); strncpy(buf, replacement()->c_str(state), byte_size + 1); converter_->replacement_str = (const unsigned char*)buf; converter_->replacement_len = replacement()->byte_size(); String* name = replacement()->encoding()->name(); byte_size = name->byte_size(); buf = (char*)XMALLOC(byte_size + 1); strncpy(buf, name->c_str(state), byte_size + 1); converter_->replacement_enc = (const char*)buf; converter_->replacement_allocated = 1; size_t num_converters = replacement_converters()->size(); rb_econv_alloc_replacement_converters(converter_, num_converters / 2); for(size_t i = 0, k = 0; i < num_converters; k++, i += 2) { rb_econv_replacement_converters* repl_converter; repl_converter = converter_->replacement_converters + k; name = as<String>(replacement_converters()->get(state, i)); byte_size = name->byte_size(); buf = (char*)XMALLOC(byte_size + 1); strncpy(buf, name->c_str(state), byte_size + 1); repl_converter->destination_encoding_name = (const char*)buf; Array* trs = as<Array>(replacement_converters()->get(state, i + 1)); size_t num_transcoders = trs->size(); repl_converter->num_transcoders = num_transcoders; repl_converter->transcoders = ALLOC_N(rb_transcoder*, num_transcoders); for(size_t j = 0; j < num_transcoders; j++) { Transcoding* transcoding = as<Transcoding>(trs->get(state, j)); rb_transcoder* tr = transcoding->get_transcoder(); repl_converter->transcoders[j] = tr; } } }
bool SkSVGPaint::flush(SkSVGParser& parser, bool isFlushable, bool isDef) { SkSVGPaint current; SkSVGPaint* walking = parser.fHead; int index; while (walking != NULL) { for (index = kInitial + 1; index < kTerminal; index++) { SkString* lastAttr = (*walking)[index]; if (lastAttr->size() == 0) continue; if (current[index]->size() > 0) continue; current[index]->set(*lastAttr); } walking = walking->fNext; } bool paintChanged = false; SkSVGPaint& lastState = parser.fLastFlush; if (isFlushable == false) { if (isDef == true) { if (current.f_mask.size() > 0 && current.f_mask.equals(lastState.f_mask) == false) { SkSVGElement* found; const char* idStart = strchr(current.f_mask.c_str(), '#'); SkASSERT(idStart); SkString id(idStart + 1, strlen(idStart) - 2); bool itsFound = parser.fIDs.find(id.c_str(), &found); SkASSERT(itsFound); SkSVGElement* gradient = found->getGradient(); if (gradient) { gradient->write(parser, current.f_fill); gradient->write(parser, current.f_stroke); } } } goto setLast; } { bool changed[kTerminal]; memset(changed, 0, sizeof(changed)); for (index = kInitial + 1; index < kTerminal; index++) { if (index == kTransform || index == kClipPath || index == kStopColor || index == kStopOpacity || index == kClipRule || index == kFillRule) continue; SkString* lastAttr = lastState[index]; SkString* currentAttr = current[index]; paintChanged |= changed[index] = lastAttr->equals(*currentAttr) == false; } if (paintChanged) { if (current.f_mask.size() > 0) { if (current.f_fill.equals("none") == false && strncmp(current.f_fill.c_str(), "url(#", 5) != 0) { SkASSERT(current.f_fill.c_str()[0] == '#'); SkString replacement("url(#mask"); replacement.append(current.f_fill.c_str() + 1); replacement.appendUnichar(')'); current.f_fill.set(replacement); } if (current.f_stroke.equals("none") == false && strncmp(current.f_stroke.c_str(), "url(#", 5) != 0) { SkASSERT(current.f_stroke.c_str()[0] == '#'); SkString replacement("url(#mask"); replacement.append(current.f_stroke.c_str() + 1); replacement.appendUnichar(')'); current.f_stroke.set(replacement); } } if (current.f_fill.equals("none") && current.f_stroke.equals("none")) current.f_opacity.set("0"); if (parser.fSuppressPaint == false) { parser._startElement("paint"); bool success = writeChangedAttributes(parser, current, changed); if (success == false) return paintChanged; success = writeChangedElements(parser, current, changed); if (success == false) return paintChanged; parser._endElement(); // paint } } } setLast: for (index = kInitial + 1; index < kTerminal; index++) { SkString* lastAttr = lastState[index]; SkString* currentAttr = current[index]; lastAttr->set(*currentAttr); } return paintChanged; }
int main(int argc, char *argv[]) { // Need to change to 3. need to remove the logging. if (argc != 4) { printf("Usage: ./maxcut <input data path> <output data path> <log file>\n"); exit(-1); } // Need to remove when submitting. log_file = fopen(argv[3], "w"); fprintf(log_file, "rate, elasped time (s), max val, avg val\n"); start_time = get_seconds(); in = fopen(argv[1], "r"); out = fopen(argv[2], "w"); int i, j, v1, v2, w; // (v1, v2) is the vertex and w is the weight fscanf(in, "%d %d\n", &num_of_vertex, &num_of_edge); int edge[num_of_vertex+1][num_of_vertex+1]; for (i=0; i<=SIZE; i++) for (j=0; j<=SIZE; j++) edge[i][j] = 0; while (fscanf(in, "%d %d %d\n", &v1, &v2, &w) != EOF) { edge[v1][v2] = w; edge[v2][v1] = w; } init_population(); init_offsprings(); init_cost(edge); sort_population(); init_crossover(); int p1, p2; while (!(stop_condition())) { generation++; for (i=1; i<=K; i++) { selection(&p1, &p2); crossover(i, p1, p2); mutation(i); local_optimization(i, edge); } replacement(edge); sort_population(); } for (i=1; i<=SIZE; i++) { if (population[N]->ch[i] == 1) fprintf(out, "%d ", i); } free_population(); fclose(in); fclose(out); printf("N: %d, K: %d, S_RATE: %lf, M_THRE: %lf, P0: %lf, POINTS: %d, K_FIT: %d, T: %lf\n", N, K, S_RATE, M_THRE, P0, POINTS, K_FIT, T); return 0; }
QSet<int> DirectoryDAO::relocateDirectory(const QString& oldFolder, const QString& newFolder) { // TODO(rryan): This method could use error reporting. It can fail in // mysterious ways for example if a track in the oldFolder also has a zombie // track location in newFolder then the replace query will fail because the // location column becomes non-unique. ScopedTransaction transaction(m_database); QSqlQuery query(m_database); query.prepare("UPDATE " % DIRECTORYDAO_TABLE % " SET " % DIRECTORYDAO_DIR % "=" ":newFolder WHERE " % DIRECTORYDAO_DIR % " = :oldFolder"); query.bindValue(":newFolder", newFolder); query.bindValue(":oldFolder", oldFolder); if (!query.exec()) { LOG_FAILED_QUERY(query) << "coud not relocate directory" << oldFolder << "to" << newFolder; return QSet<int>(); } FieldEscaper escaper(m_database); QString startsWithOldFolder = escaper.escapeString(escaper.escapeStringForLike(oldFolder % '/', '%') + '%'); // Also update information in the track_locations table. This is where mixxx // gets the location information for a track. query.prepare(QString("SELECT library.id, track_locations.id, track_locations.location " "FROM library INNER JOIN track_locations ON " "track_locations.id = library.location WHERE " "track_locations.location LIKE %1 ESCAPE '%'") .arg(startsWithOldFolder)); if (!query.exec()) { LOG_FAILED_QUERY(query) << "coud not relocate path of tracks"; return QSet<int>(); } QSet<int> ids; QList<int> loc_ids; QStringList old_locs; while (query.next()) { ids.insert(query.value(0).toInt()); loc_ids.append(query.value(1).toInt()); old_locs.append(query.value(2).toString()); } QString replacement("UPDATE track_locations SET location = :newloc " "WHERE id = :id"); query.prepare(replacement); for (int i = 0; i < loc_ids.size(); ++i) { QString newloc = old_locs.at(i); newloc.replace(0, oldFolder.size(), newFolder); query.bindValue("newloc", newloc); query.bindValue("id", loc_ids.at(i)); if (!query.exec()) { LOG_FAILED_QUERY(query) << "coud not relocate path of tracks"; return QSet<int>(); } } qDebug() << "Relocated tracks:" << ids.size(); transaction.commit(); return ids; }
bool wxExEx::Substitute( const wxString& begin_address, const wxString& end_address, const wxString& patt, const wxString& repl) { if (m_STC->GetReadOnly()) { return false; } if (m_STC->HexMode()) { wxLogStatus(_("Not allowed in hex mode")); return false; } const int begin_line = ToLineNumber(begin_address); const int end_line = ToLineNumber(end_address); if (begin_line == 0 || end_line == 0 || end_line < begin_line) { return false; } if (!MarkerAdd('$', end_line - 1)) { return false; } const wxString pattern = (patt == "~" ? m_Replacement: patt); wxString replacement(repl); m_Replacement = replacement; m_STC->SetSearchFlags(m_SearchFlags); int nr_replacements = 0; m_STC->BeginUndoAction(); m_STC->SetTargetStart(m_STC->PositionFromLine(begin_line - 1)); m_STC->SetTargetEnd(m_STC->GetLineEndPosition(MarkerLine('$'))); while (m_STC->SearchInTarget(pattern) > 0) { const int target_start = m_STC->GetTargetStart(); if (target_start >= m_STC->GetTargetEnd()) { break; } if (replacement.Contains("&")) { wxString target = m_STC->GetTextRange( m_STC->GetTargetStart(), m_STC->GetTargetEnd()); if (replacement.StartsWith("\\L")) { target.MakeLower(); replacement.Replace("\\L", wxEmptyString); } else if (replacement.StartsWith("\\U")) { target.MakeUpper(); replacement.Replace("\\U", wxEmptyString); } replacement.Replace("&", target); } m_STC->MarkTargetChange(); const int length = m_STC->ReplaceTargetRE(replacement); // always RE! m_STC->SetTargetStart(target_start + length); m_STC->SetTargetEnd(m_STC->GetLineEndPosition(MarkerLine('$'))); nr_replacements++; } m_STC->EndUndoAction(); MarkerDelete('$'); m_Frame->ShowExMessage(wxString::Format(_("Replaced: %d occurrences of: %s"), nr_replacements, pattern.c_str())); return true; }