uppsrc_excluded_macros.diff - U++ - Redmine

     	raw_string.Cat('\"');
     	n = int(s + 1 - p);
     	return true;
     };
+    }
     void CSyntax::Highlight(const wchar *ltext, const wchar *e, HighlightOutput& hls, CodeEditor *editor, int line, int64 pos)
+    {

uppsrc/CodeEditor/CSyntax.cpp
369	369	s % spar;
370	370
371	371	s % highlight;
372		};
	372	}
373	373
374	374	}

     Value  Convert::Scan(const Value& text) const {
     	return text;
     };
+    }
     int    Convert::Filter(int chr) const {
     	return chr;

     	INI_BOOL(HttpRequest_Trace, false, "Activates HTTP requests tracing")
     	INI_BOOL(HttpRequest_TraceBody, false, "Activates HTTP requests body tracing")
     	INI_BOOL(HttpRequest_TraceShort, false, "Activates HTTP requests short tracing")
     };
+    }
     #define LLOG(x)      LOG_(Ini::HttpRequest_Trace, x)
     #define LLOGB(x)     LOG_(Ini::HttpRequest_TraceBody, x)

uppsrc/Core/Ini.cpp
422	422	return Null;
423	423	}
424	424
425		};
	425	}

     			lang = SetLNGCharset(lang, CharsetByName(q + 1));
     	};
     	return lang;
     };
+    }
     #endif

uppsrc/Core/LangInfo.cpp
853	853	"Malayalam\t\340\264\256\340\264\262\340\264\257\340\264\276\340\264\263\340\264\202\t\004L",
854	854	};
855	855
856		};
	856	}

uppsrc/Core/Log.cpp
454	454
455	455	namespace Ini {
456	456	INI_BOOL(user_log, false, "Activates logging of user actions");
457		};
	457	}
458	458
459	459	}

     	INI_BOOL(Smtp_Trace, false, "Activates HTTP requests tracing")
     	INI_BOOL(Smtp_TraceBody, false, "Activates HTTP requests body tracing")
     	INI_BOOL(Smtp_CompressLog, false, "Activates log compression (removes long hex/encode64-like data)")
     };
+    }
     #define LLOG(x)      do { if(Ini::Smtp_Trace) { if(Ini::Smtp_CompressLog) RLOG(CompressLog(String().Cat() << x)); else RLOG(x); } } while(0)
     #define LLOGB(x)      do { if(Ini::Smtp_TraceBody) { if(Ini::Smtp_CompressLog) RLOG(CompressLog(String().Cat() << x)); else RLOG(x); } } while(0)

uppsrc/Core/SSH/SFtpStream.cpp
76	76	Close();
77	77	}
78	78
79		};
	79	}

uppsrc/Core/Speller.cpp
430	430	return r;
431	431	}
432	432
433		};
	433	}

uppsrc/Core/UnicodeInfo.cpp
244	244	return Single<UnicodeInfo>().ismark.Find(c) >= 0;
245	245	}
246	246
247		};
	247	}

uppsrc/Core/Utf.cpp
176	176	return r;
177	177	}
178	178
179		};
	179	}

uppsrc/Core/xxHsh.cpp
72	72	return xxHash64(~s, s.GetCount());
73	73	}
74	74
75		};
	75	}

     inline bool IsCppCode(int i) {
     	return i >= CONSTRUCTOR && i <= INLINEFRIEND;
     };
+    }
     inline bool IsCppData(int i) {
     	return i >= VARIABLE && i <= ENUM;

uppsrc/CppBase/Expression.cpp
542	542	return xp;
543	543	}
544	544
545		};
	545	}

uppsrc/CppBase/ppconfig.cpp
48	48	return defs;
49	49	}
50	50
51		};
	51	}

     	Update();
     	Action();
     	Refresh();
     };
+    }
     void  Ctrl::CancelModeDeep() {
     	GuiLock __;

uppsrc/CtrlLib/ChCoco.h
13	13
14	14	Color CocoBrush(int k);
15	15
16		};
	16	}
17	17
18	18	#endif

uppsrc/CtrlLib/ChGtk.h
155	155	Value ubutton2, Value ubutton,
156	156	int i_larrow, int i_uarrow, bool horz);
157	157
158		};
	158	}
159	159
160	160	#endif

     	if(peak)
     		text << "\r\n=== Peak memory profile\r\n" << sProfile(*peak);
     	PromptOK("[C " + DeQtfLf(text));
     };
+    }
     FileSelButton::FileSelButton(MODE mode, const char *title)
     : title(title), mode(mode)

     	out[13] = Color(0xFF, 0x00, 0xFF);
     	out[14] = Color(0x00, 0x80, 0x80);
     	out[15] = Color(0x00, 0xFF, 0xFF);
     };
+    }
     PalCtrl::Config& PalCtrl::GlobalConfig()
+    {

uppsrc/CtrlLib/DropTree.cpp
225	225	dropwidth = 0;
226	226	}
227	227
228		};
	228	}

uppsrc/CtrlLib/Static.cpp
316	316	ChPaint(w, q - 1, lmargin, 1, sz.cy - (lmargin + rmargin), style->l1);
317	317	ChPaint(w, q, lmargin, 1, sz.cy - (lmargin + rmargin), style->l2);
318	318	}
319		};
	319	}
320	320
321	321	SeparatorCtrl& SeparatorCtrl::Margin(int l, int r)
322	322	{

uppsrc/CtrlLib/StatusBar.cpp
119	119
120	120	void InfoCtrl::FrameLayout(Rect& r) {
121	121	(right ? LayoutFrameRight : LayoutFrameLeft)(r, this, cx ? cx : r.Height());
122		};
	122	}
123	123
124	124	class VCenterDisplay : public Display
125	125	{
...	...
277	277	w.DrawRect(r.left + pos - 1, r.top + 1, 1, r.Height() - 1, SColorLight);
278	278	}
279	279	w.DrawRect(r.left + pos, r.top, r.Width() - pos, r.Height(), SColorPaper);
280		};
	280	}
281	281
282	282	Display& ProgressDisplay()
283	283	{

     #include KEYFILE
     #ifdef KEYNAMESPACE
     };
+    }
     #endif
     #ifdef KEYNAMESPACE

uppsrc/Draw/Uhd.cpp
16	16	+ 7 * (r * -169 + g * -331 + b * 500)
17	17	+ 6 * (r * 500 + g * -419 + b * -81);
18	18	}
19		};
	19	}
20	20
21	21	Image Upscale2x(const Image& src, RGBA bg)
22	22	{
...	...
157	157	return img;
158	158	}
159	159
160		};
	160	}

     		SKIP_CURRENT_ROW = BIT(0),
     		SKIP_HIDDEN = BIT(1)
     	};
     };
+    }
     class GridFind : public EditString
+    {

     namespace Ini {
     	INI_BOOL(skylark_log, false, "Trace of Skylark");
     };
+    }
     #ifdef PLATFORM_WIN32
     BOOL WINAPI SkylarkApp::CtrlCHandlerRoutine(DWORD dwCtrlType)
-...
     INI_INT(caching, 1, "Agressivity of caching on static/** "
                         "(0=no caching, 1=use ETag header, 2=use versioned path)");
     #endif
     };
+    }
     SkylarkApp::SkylarkApp()
+    {
-...
     	app = NULL;
+    }
     };
+    }

uppsrc/Skylark/Compile.cpp
436	436	return exe;
437	437	}
438	438
439		};
	439	}

uppsrc/Skylark/Dispatch.cpp
518	518	}
519	519	}
520	520
521		};
	521	}

uppsrc/Skylark/Exe.cpp
426	426	return x.out;
427	427	}
428	428
429		};
	429	}

uppsrc/Skylark/Http.cpp
436	436	return Ux("!", js_code);
437	437	}
438	438
439		};
	439	}

uppsrc/Skylark/Iml/Lib.icpp
30	30	Compiler::Register("ImlImg", ImlImg);
31	31	};
32	32
33		};
	33	}

uppsrc/Skylark/Optimize.cpp
157	157	optimized = optimized2;
158	158	}
159	159
160		};
	160	}

uppsrc/Skylark/Preprocess.cpp
129	129	return Join(Split(r, '\n', false), "\r\n");
130	130	}
131	131
132		};
	132	}

uppsrc/Skylark/Renderer.cpp
106	106	{
107	107	}
108	108
109		};
	109	}

     INI_STRING(session_data_column, "DATA", "Name of SQL 'text' column used to store Skylark sessions data");
     INI_STRING(session_lastwrite_column, "LASTWRITE", "Name of SQL timestamp column used to store Skylark session last update time");
     INI_INT(session_expire, 3600 * 24 * 365, "Number of seconds after which Skylark session expires and can be deleted");
     };
+    }
     SkylarkSessionConfig::SkylarkSessionConfig()
+    {
-...
     	return *this;
+    }
     };
+    }

     namespace Ini {
     extern IniBool skylark_log;
     };
+    }
     String GetThreadName();
-...
     #include "Witz.h"
     #include "Http.h"
     };
+    }
     #endif

uppsrc/Skylark/Sql.cpp
79	79	return y;
80	80	}
81	81
82		};
	82	}

uppsrc/Skylark/Static.icpp
68	68	http.Content(type, LoadFile(path));
69	69	}
70	70
71		};
	71	}

     	Compiler::Register("cycle", Cycle);
     	Compiler::Register("raw", RawFn);
     	Compiler::Register("count", CountFn);
     	Compiler::Register("post_identity", PostIdentity);
     	Compiler::Register("js_identity", JsIdentity);
     	Compiler::Register("set", VariablesSet);
     	Compiler::Register("render", Render);
     };
     };
     	Compiler::Register("post_identity", PostIdentity);
     	Compiler::Register("js_identity", JsIdentity);
     	Compiler::Register("set", VariablesSet);
     	Compiler::Register("render", Render);
     };
+    }

uppsrc/TextDiffCtrl/DiffCtrl.cpp
190	190	return fs;
191	191	}
192	192
193		};
	193	}

     	WhenIcon = [](const char *path) -> Image { return NativePathIcon(path); };
     	Title("Compare directories");
     };
+    }
     void DirDiffDlg::GatherFilesDeep(Index<String>& files, const String& base, const String& path)
+    {
-...
     	return false;
+    }
     };
+    }

uppsrc/TextDiffCtrl/PatchDiff.cpp
172	172	rfile <<= p2;
173	173	}
174	174
175		};
	175	}

uppsrc/TextDiffCtrl/TextCtrl.cpp
512	512	SetSb(l + pos.y);
513	513	}
514	514
515		};
	515	}

uppsrc/TextDiffCtrl/TextDiff.cpp
210	210	dest.Add(TextSection(start1, end1 - start1, start2, end2 - start2, false));
211	211	}
212	212
213		};
	213	}

uppsrc/TextDiffCtrl/TextDiffCtrl.h
322	322	PatchDiff();
323	323	};
324	324
325		};
	325	}
326	326
327	327	#endif

uppsrc/TextDiffCtrl/patch.cpp
206	206	return Join(lines, crlf ? "\r\n" : "\n");
207	207	}
208	208
209		};
	209	}

     	int nc = CompareNoCase(a, b);
     	if(nc) return nc < 0;
     	return a < b;
     };
+    }
     struct SelectPackageDlg : public WithSelectPackageLayout<TopWindow> {
     	virtual bool Key(dword key, int count);

uppsrc/ide/UppWspc.cpp
19	19	Font WorkspaceWork::ListFont()
20	20	{
21	21	return StdFont();
22		};
	22	}
23	23
24	24	void WorkspaceWork::SetErrorFiles(const Vector<String>& files)
25	25	{

     GLOBALREF const char *FtpError(netbuf *nControl);
     #ifdef __cplusplus
     };
+    }
     #endif
     #endif /* __FTPLIB_H */

uppsrc/plugin/lz4/Compress.cpp
149	149	Close();
150	150	}
151	151
152		};
	152	}

uppsrc/plugin/lz4/Decompress.cpp
223	223	return b;
224	224	}
225	225
226		};
	226	}

uppsrc/plugin/lz4/lz4.h
133	133
134	134	bool IsLZ4(Stream& s);
135	135
136		};
	136	}
137	137
138	138	#endif

uppsrc/plugin/lz4/util.cpp
126	126
127	127	#endif
128	128
129		};
	129	}

uppsrc/plugin/zstd/Compress.cpp
128	128	Close();
129	129	}
130	130
131		};
	131	}

uppsrc/plugin/zstd/Decompress.cpp
195	195	return b;
196	196	}
197	197
198		};
	198	}

uppsrc/plugin/zstd/Util.cpp
104	104
105	105	#endif
106	106
107		};
	107	}