StringBufferPatch.diff - U++ - Redmine

CodeEditor/CSyntax.cpp (working copy)
79	79	else
80	80	wbuf.Cat(*p++);
81	81	}
82		return wbuf;
	82	return WString(wbuf);
83	83	}
84	84
85	85	int LastC(const wchar b, const wchar e)

     		return FromUtf8(src, l);
     	WStringBuffer result(l);
     	ToUnicode(result, src, l, charset);
     	return result;
     	return WString(result);
+    }
     WString ToUnicode(const String& src, byte charset)
-...
     		return ToUtf8(src, len);
     	StringBuffer result(len);
     	FromUnicode(result, src, len, charset, defchar);
     	return result;
     	return String(result);
+    }
     String FromUnicodeBuffer(const wchar *src)
-...
     		return ToUtf8(ToUnicode(src, scharset));
     	StringBuffer result(slen);
     	ConvertCharset(result, charset, src, scharset, slen);
     	return result;
     	return String(result);
+    }
     WString InitCaps(const wchar *s)
-...
     			r[i] = ToLower(c);
     		spc = !IsLeNum(c);
+    	}
     	return r;
     	return WString(r);
+    }
     WString ToUpper(const WString& w)
-...
     	int l = w.GetLength();
     	WStringBuffer r(l);
     	ToUpper(r, w, l);
     	return r;
     	return WString(r);
+    }
     WString ToLower(const WString& w)
-...
     	int l = w.GetLength();
     	WStringBuffer r(l);
     	ToLower(r, w, l);
     	return r;
     	return WString(r);
+    }
     WString ToAscii(const WString& w)
-...
     	int l = w.GetLength();
     	WStringBuffer r(l);
     	ToAscii(r, w, l);
     	return r;
     	return WString(r);
+    }
     String InitCaps(const char *s, byte charset)
-...
     	int l = (int)strlen(s);
     	StringBuffer r(l);
     	ToUpper(r, s, l, charset);
     	return r;
     	return String(r);
+    }
     String ToLower(const char *s, byte charset)
-...
     	int l = (int)strlen(s);
     	StringBuffer r(l);
     	ToLower(r, s, l, charset);
     	return r;
     	return String(r);
+    }
     String ToAscii(const char *s, byte charset)
-...
     	int l = (int)strlen(s);
     	StringBuffer r(l);
     	ToAscii(r, s, l, charset);
     	return r;
     	return String(r);
+    }
     String ToUpper(const String& s, byte charset)
-...
     	int l = s.GetLength();
     	StringBuffer r(l);
     	ToUpper(r, s, l, charset);
     	return r;
     	return String(r);
+    }
     String ToLower(const String& s, byte charset)
-...
     	int l = s.GetLength();
     	StringBuffer r(l);
     	ToLower(r, s, l, charset);
     	return r;
     	return String(r);
+    }
     String ToAscii(const String& s, byte charset)
-...
     	int l = s.GetLength();
     	StringBuffer r(l);
     	ToAscii(r, s, l, charset);
     	return r;
     	return String(r);
+    }
     String ToUpperAscii(const String& s, byte charset)
-...
     	int l = s.GetLength();
     	StringBuffer r(l);
     	ToAscii(r, s, l, charset);
     	return r;
     	return String(r);
+    }
     String ToLowerAscii(const String& s, byte charset)
-...
     	int l = s.GetLength();
     	StringBuffer r(l);
     	ToAscii(r, s, l, charset);
     	return r;
     	return String(r);
+    }
     bool IsDoubleWidth(int c)

Core/Format.cpp (working copy)
64	64	if(dwd < width)
65	65	memset(o, lpad, pad);
66	66	memcpy8(o + pad, p, dwd);
67		return out;
	67	return String(out);
68	68	}
69	69
70	70	String FormatInt(int i)
...	...
382	382	}
383	383	out.Cat(flags & FD_CAP_E ? 'E' : 'e');
384	384	out.Cat(FormatIntDec(exp, fill_exp, '0', flags & FD_SIGN_EXP));
385		return out;
	385	return String(out);
386	386	}
387	387
388	388	String FormatDate(Date date, const char *format, int language)
...	...
577	577	StringBuffer q;
578	578	q.SetLength(1000);
579	579	q.SetLength(sprintf(q, '%' + f.format + f.id, (int)f.arg));
580		return q;
	580	return String(q);
581	581	}
582	582
583	583	String Int64Formatter(const Formatting& f)
...	...
585	585	StringBuffer q;
586	586	q.SetLength(1000);
587	587	q.SetLength(sprintf(q, '%' + f.format + f.id, (int64)f.arg));
588		return q;
	588	return String(q);
589	589	}
590	590
591	591	String IntLowerAlphaFormatter(const Formatting& f)
...	...
1148	1148	x.Cat('%');
1149	1149	x.Cat(*text++);
1150	1150	}
1151		return x;
	1151	return String(x);
1152	1152	}
1153	1153
1154	1154	}

Core/Huge.cpp (working copy)
41	41	Panic("String is too big!");
42	42	StringBuffer sb((int)size);
43	43	Get(~sb, 0, size);
44		return sb;
	44	return String(sb);
45	45	}
46	46
47	47	}

Core/InetUtil.cpp (working copy)
124	124	else
125	125	out << '%' << hex_digits[(p >> 4) & 15] << hex_digits[p & 15];
126	126	}
127		return out;
	127	return String(out);
128	128	}
129	129
130	130	String UrlEncode(const char *s, int len)
...	...
156	156	}
157	157	else
158	158	out.Cat(*p);
159		return out;
	159	return String(out);
160	160	}
161	161
162	162	String UrlDecode(const char *s, int len)
...	...
179	179	r.Cat(s[0]);
180	180	len++;
181	181	}
182		else
	182	else
183	183	if(s[0] == '\r')
184	184	;
185	185	else
...	...
209	209	}
210	210	s++;
211	211	}
212		return r;
	212	return String(r);
213	213	}
214	214
215	215	String QPDecode(const char *s, bool underscore_to_space)
...	...
232	232	else
233	233	r.Cat(c);
234	234	}
235		return r;
	235	return String(r);
236	236	}
237	237
238	238	String Base64Encode(const char _b, const char _e)
...	...
272	272	p[2] = encoder[(b[1] << 2) & 0x3C];
273	273	p[3] = '=';
274	274	}
275		return s;
	275	return String(s);
276	276	}
277	277
278	278	String Base64Encode(const char *b, int len)
...	...
330	330	out.Cat((c[2] << 6) \| (c[3] >> 0));
331	331	}
332	332	}
333		return out;
	333	return String(out);
334	334	}
335	335
336	336	String Base64Decode(const char *s, int len)

     	if(!done && IsEof())
     		return String::GetVoid();
     	out.SetLength(done);
     	return out;
     	return String(out);
+    }
     bool  TcpSocket::GetAll(void *buffer, int len)

Core/SplitMerge.cpp (working copy)
173	173	r.Cat(im[i]);
174	174	next = true;
175	175	}
176		return r;
	176	return T(r);
177	177	}
178	178
179	179	String Join(const Vector<String>& im, const String& delim, bool ignoreempty) {

     	StringBuffer b(size);
     	int n = Get(~b, size);
     	b.SetCount(n);
     	return b;
     	return String(b);
+    }
     String Stream::GetAll(int size)
-...
     			StringBuffer s((int)size);
     			in.Get(s, (int)size);
     			if(!in.IsError())
     				return s;
     				return String(s);
+    		}
+    	}
     	return String::GetVoid();

     	StringBuffer r;
     	r.Reserve(len);
     	FromUtf16_([&](const wchar *, dword code) { ToUtf8_([&](char c) { r.Cat(c); }, code); }, s, len);
     	return r;
     	return String(r);
+    }
     int Utf16Len(const dword *s, int len)
-...
     	r.Reserve(len);
     	for(const dword *lim = s + len; s < lim; s++)
     		ToUtf16_([&](wchar c) { r.Cat(c); }, *s);
     	return r;
     	return WString(r);
+    }
     int Utf16Len(const char *s, int len)
-...
+    {
     	WStringBuffer r;
     	FromUtf8_([&](const byte *, dword code) { ToUtf16_([&](wchar c) { r.Cat(c); }, code); }, s, len);
     	return r;
     	return WString(r);
+    }
     int Utf32Len(const char *s, int len)
-...
     	while(s < lim)
     		*t++ = (byte)*s < 128 ? *s++ : ToAscii(FetchUtf8(s, lim));
     	r.SetLength(int(t - ~r));
     	return r;
     	return String(r);
+    }
     String Utf8ToUpperAscii(const String& src)
-...
     		*t++ = (byte)*s <= 'Z' ? *s++ : ToUpperAscii(FetchUtf8(s, lim));
+    	}
     	r.SetLength(int(t - ~r));
     	return r;
     	return String(r);
+    }
     String Utf8ToLowerAscii(const String& src)
-...
     	while(s < lim)
     		*t++ = ToLowerAscii(FetchUtf8(s, lim));
     	r.SetLength(int(t - ~r));
     	return r;
     	return String(r);
+    }
     };

Core/Util.cpp (working copy)
392	392	for(;;) {
393	393	for(int q = 0; q < sep; q++) {
394	394	if(i >= count)
395		return b;
	395	return String(b);
396	396	*t++ = itoc[(s[i] & 0xf0) >> 4];
397	397	*t++ = itoc[s[i] & 0x0f];
398	398	i++;
399	399	}
400	400	if(i >= count)
401		return b;
	401	return String(b);
402	402	*t++ = sepchr;
403	403	}
404	404	}
...	...
467	467	else
468	468	r.Cat(*s++);
469	469	}
470		return r;
	470	return String(r);
471	471	}
472	472
473	473	String NormalizeSpaces(const char s, const char end)
...	...
485	485	else
486	486	r.Cat(*s++);
487	487	}
488		return r;
	488	return String(r);
489	489	}
490	490
491	491	String CsvString(const String& text)
...	...
569	569	else
570	570	result.Cat(b, s);
571	571	}
572		return result;
	572	return String(result);
573	573	}
574	574
575	575	int ChNoInvalid(int c)
...	...
599	599	if(q <= 0)
600	600	return src;
601	601	b.SetCount(q);
602		return b;
	602	return String(b);
603	603	}
604	604
605	605	String ToSystemCharset(const String& src)

     	StringBuffer ss;
     	for(int i = GetLast(); i >= 0; i--)
     		ss << FormatIntHex(bp[i]);
     	return ss;
     	return String(ss);
+    }
     void Bits::Serialize(Stream& s)

     	StringBuffer temp(count);
     	for(char *p = temp, *e = p + count; p < e;)
     		*p++ = (char)*buffer++;
     	return temp;
     	return String(temp);
+    }
     String AsString(const wchar_t *buffer, const wchar_t *end) {
-...
     		len--;
     	raw_len.SetLength(len);
     	RegCloseKey(key);
     	return raw_len;
     	return String(raw_len);
+    }
     int GetWinRegInt(const char *value, const char *path, HKEY base_key, dword wow) {

     	StringBuffer result;
     	for(; *s; s++)
     		sDeXmlChar(result, *s, charset, escapelf);
     	return result;
     	return String(result);
+    }
     String DeXml(const char *s, const char *end, byte charset, bool escapelf)
-...
     	StringBuffer result;
     	for(; s < end; s++)
     		sDeXmlChar(result, *s, charset, escapelf);
     	return result;
     	return String(result);
+    }
     String DeXml(const String& s, byte charset, bool escapelf)
-...
     	if(standalone)
     		r << " standalone=\"" << standalone << "\"";
     	r << " ?>\r\n";
     	return r;
     	return String(r);
+    }
     String XmlPI(const char *text)
+    {
     	StringBuffer r;
     	r << "<?" << text << "?>\r\n";
     	return r;
     	return String(r);
+    }
     String XmlDecl(const char *text)
+    {
     	StringBuffer r;
     	r << "<!" << text << ">\r\n";
     	return r;
     	return String(r);
+    }
     String XmlDocType(const char *text)
-...
+    {
     	StringBuffer out;
     	out << "<!-- " << text << " -->\r\n";
     	return out;
     	return String(out);
+    }
     String  XmlTag::operator()()
-...
     		else
     		if(first) {
     			r << text << end;
     			return r;
     			return String(r);
+    		}
     		first = false;
     		wasslash = false;
-...
     	if(!first)
     		r << "\r\n";
     	r << end;
     	return r;
     	return String(r);
+    }
     String  XmlTag::Text(const char *text, byte charset)
-...
     			out.Cat(t);
     		else if(IsEnd()) {
     			PassEnd();
     			return out;
     			return String(out);
+    		}
     		else
     			Skip();

Core/parser.cpp (working copy)
196	196	result.Cat(*term++);
197	197	}
198	198	DoSpaces();
199		return result;
	199	return String(result);
200	200	}
201	201
202	202	bool CParser::IsInt() const {
...	...
381	381	if(*term == delim) {
382	382	term++;
383	383	DoSpaces();
384		return result;
	384	return String(result);
385	385	}
386	386	else
387	387	if(*term == '\\') {
...	...
452	452	if((byte)term < ' ' && term != '\t') {
453	453	if(chkend) {
454	454	ThrowError("Unterminated string");
455		return result;
	455	return String(result);
456	456	}
457	457	if(*term == '\0')
458		return result;
	458	return String(result);
459	459	}
460	460	result.Cat(*term++);
461	461	}
462	462	}
463	463	DoSpaces();
464		return result;
	464	return String(result);
465	465	}
466	466
467	467	String CParser::ReadOneString(bool chkend)
...	...
700	700	s++;
701	701	}
702	702	t.Cat('\"');
703		return t;
	703	return String(t);
704	704	}
705	705
706	706	String AsCString(const char s, int linemax, const char linepfx, dword flags)

     	int clen = LZ4_compress_default((const char *)s, ~b + sizeof(int), sz, (int)maxsize);
     	b.SetCount(clen + sizeof(int));
     	b.Shrink();
     	return b;
     	return String(b);
+    }
     String FastCompress(const String& s)
-...
     	int sz = *(int *)~data;
     	StringBuffer b(sz);
     	LZ4_decompress_safe(~data + sizeof(int), b, data.GetCount() - sizeof(int), sz);
     	return b;
     	return String(b);
+    }
     // following function is used in both plugin/lz4 and plugin/zstd

CppBase/Parser.cpp (working copy)
483	483	spc = true;
484	484	p++;
485	485	}
486		return r;
	486	return String(r);
487	487	}
488	488
489	489	String Parser::Name(String& name, bool& castoper, bool& oper)

     										prefix_macro = bid;
     									else
     										prefix_macro = String(' ', 1) + bid; // do not want to emit grounding in body
     									return r;
     									return String(r);
+    								}
     								else
     								if(*s == '\"' || *s == '\'')
-...
     		else
     			r.Cat(*s++);
+    	}
     	return r;
     	return String(r);
+    }
     void Cpp::DoFlatInclude(const String& header_path)

     	int size = ::GetEnhMetaFileBits(hemf, 0, 0);
     	StringBuffer b(size);
     	::GetEnhMetaFileBits(hemf, size, (BYTE *)~b);
     	return b;
     	return String(b);
+    }
     void WinMetaFile::Serialize(Stream& s) {

     	byte *p = (byte *)~b;
     	memcpy(p, &header, sizeof(header));
     	memcpy(p + sizeof(header), ~img, 4 * img.GetLength());
     	return b;
     	return String(b);
+    }
     String sImage(const Value& image)

     		RawCat(key, part);
     		RawCat(key, state);
     		RawCat(key, sz);
     		return key;
     		return String(key);
+    	}
     	virtual Image Make() const {
     		Rect rr(sz);

CtrlLib/Text.cpp (working copy)
678	678	if(size == 0) break;
679	679	pos = 0;
680	680	}
681		return r;
	681	return WString(r);
682	682	}
683	683
684	684	String TextCtrl::Get(int64 pos, int size, byte charset) const
...	...
707	707	if(size == 0) break;
708	708	pos = 0;
709	709	}
710		return r;
	710	return String(r);
711	711	}
712	712	return FromUnicode(GetW(pos, size), charset);
713	713	}

Draw/DrawText.cpp (working copy)
17	17	t++ = s++;
18	18	n--;
19	19	}
20		return b;
	20	return WString(b);
21	21	}
22	22	#endif
23	23	return ToUnicode(s, n, cs);

Draw/ImageBlit.cpp (working copy)
79	79	}
80	80	}
81	81	}
82		return r;
	82	return String(r);
83	83	}
84	84
85	85	int Premultiply(RGBA t, const RGBA s, int len)

     		s.Cat(typeid(*m).name());
     		RawCat(s, paintonly);
     		s.Cat(m->Key());
     		return s;
     		return String(s);
+    	}
     	virtual int    Make(Value& object) const {
     		Image img = m->Make();
-...
     		RawCat(h, sz.cy);
     		RawCat(h, img.GetSerialId());
     		RawCat(h, filter);
     		return h;
     		return String(h);
+    	}
     	virtual Image Make() const {
-...
     		StringBuffer h;
     		RawCat(h, color);
     		RawCat(h, img.GetSerialId());
     		return h;
     		return String(h);
+    	}
     	virtual Image Make() const {

     		RawCat(h, angle);
     		RawCat(h, color);
     		RawCat(h, yy);
     		return h;
     		return String(h);
+    	}
     	virtual Image Make() const {

Esc/EscArray.cpp (working copy)
106	106	s.Cat(c);
107	107	}
108	108	}
109		return s;
	109	return WString(s);
110	110	}
111	111
112	112	void EscValue::InitString(const WString& s)

     			r << lambda->arg[i];
+    		}
     		r << ")\n" << lambda->code;
     		return r;
     		return String(r);
     	case ESC_MAP:
     		r << ind << "{ ";
     		int c = min(map->map.GetCount(), 100);

     	out.SetCount(nchars);
     	Seek(0);
     	Stream::Get(out, 2 * nchars);
     	return out;
     	return WString(out);
+    }
     void OracleClob::Write(const WString& w)

PdfDraw/PdfDraw.cpp (working copy)
277	277	b.Cat(*s++);
278	278	}
279	279	b.Cat(')');
280		return b;
	280	return String(b);
281	281	}
282	282
283	283	void PdfDraw::PutFontHeight(int fi, double ht)

RichText/EncodeHTML.cpp (working copy)
363	363	PNGEncoder png;
364	364	png.SaveFile(AppendFileName(outdir, lname), object.ToImage(psz));
365	365	}
366		return html;
	366	return String(html);
367	367	}
368	368
369	369	String EncodeHtml(const RichText& text, Index<String>& css,

RichText/EncodeQtf.cpp (working copy)
562	562	r.Cat(*s);
563	563	}
564	564	}
565		return r;
	565	return String(r);
566	566	}
567	567
568	568	String DeQtfLf(const char *s) {
...	...
580	580	r.Cat("-\|");
581	581	s++;
582	582	}
583		return r;
	583	return String(r);
584	584	}
585	585
586	586	RichText AsRichText(const RichObject& obj)

     	RawCat(b, object.GetSerialId());
     	RawCat(b, sz);
     	RawCat(b, context);
     	return b;
     	return String(b);
+    }
     Image RichObjectImageMaker::Make() const

     	StringBuffer b(sizeof(T) + 1);
     	b[0] = code;
     	memcpy(~b + 1, &value, sizeof(T));
     	return b;
     	return String(b);
+    }
     template <class T>
-...
     	b.Reserve(s.GetLength() + 100);
     	const char *q = s;
     	SqlCompile(q, &b, dialect, NULL);
     	return b;
     	return String(b);
+    }
     #ifndef NOAPPSQL
-...
     	b[0] = code;
     	memcpy(~b + 1, &l, sizeof(int));
     	memcpy(~b + 1 + sizeof(int), s, l);
     	return b;
     	return String(b);
+    }
     String SqlFormat(const char *s, int l)

     		return text;
     	StringBuffer out;
     	out << SqlCode(cond, "(")() << text << SqlCode(cond, ")")();
     	return out;
     	return String(out);
+    }
     SqlSet& SqlSet::Cat(const SqlVal& val) {

     		return text;
     	StringBuffer out;
     	out << SqlCode(cond, "(")() << text << SqlCode(cond, ")")();
     	return out;
     	return String(out);
+    }
     void SqlS::Init(const SqlS& a, const char *o, int olen, const SqlS& b, int pr, int prb)

ide/Browser/CodeRef.cpp (working copy)
158	158	}
159	159	s++;
160	160	}
161		return r;
	161	return String(r);
162	162	}
163	163
164	164	static int sSplitT(int c) {

     	StringBuffer r;
     	r << "topic " << AsCString(title) << ";\r\n";
     	r << AsQTF(text, CHARSET_UTF8, QTF_BODY|QTF_ALL_STYLES|QTF_CRLF);
     	return r;
     	return String(r);
+    }
     String WriteTopicI(const char *title, const RichText& text)
-...
     			r << "\r\n";
+    	}
     	r << "\r\n\r\n";
     	return r;
     	return String(r);
+    }
     void SaveGroupInc(const String& grouppath)

ide/Core/Core.cpp (working copy)
532	532	"int " << ident << "_length = " << b_length << ";\n\n";
533	533	}
534	534	}
535		return fo;
	535	return String(fo);
536	536	}
537	537
538	538	void CopyFile(const String& d, const String& s, bool brc)

     	while(IsUppValueChar(p.PeekChar()))
     		v.Cat(p.GetChar());
     	p.Spaces();
     	return v;
     	return String(v);
+    }
     static bool sMatchOr(CParser& p, const Vector<String>& flag);

     	r.SetCount(s.GetCount());
     	for(int i = 0; i < s.GetCount(); i++)
     		r[i] = IsUpper(s[i]) ? ToLower(s[i]) : ToUpper(s[i]);
     	return r;
     	return WString(r);
+    }
     void Ide::SwapCase()

plugin/bmp/Icon.cpp (working copy)
216	216	Poke32le(entry + OFFSETOF(BMP_ICONDIRENTRY, dwImageOffset), out_offset);
217	217	}
218	218	}
219		return out;
	219	return String(out);
220	220	}
221	221
222	222	}