uppsrc.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
453	453	}
454	454
455	455	namespace Ini {
456		INI_BOOL(user_log, false, "Activates logging of user actions");
457		};
	456	INI_BOOL(user_log, false, "Activates logging of user actions")
	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	}

     namespace Upp {
     INITIALIZE(SSH);
     INITIALIZE(SSH)
     using SFtpHandle   = LIBSSH2_SFTP_HANDLE*;
     using SFtpAttrs    = LIBSSH2_SFTP_ATTRIBUTES;

     namespace Upp {
     INITIALIZE(SSL);
     INITIALIZE(SSLSocket);
     INITIALIZE(P7S);
     INITIALIZE(SSL)
     INITIALIZE(SSLSocket)
     INITIALIZE(P7S)
     void SslInitThread();

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	}

     String AsStringIniDefault_##var() { return AsString(DefIni_##var()); } \
     INITBLOCK { AddIniInfo(#var, AsStringIniCurrent_##var, AsStringIniDefault_##var, info); }
     #define INI_BOOL(var, def, info)   INI_TYPE(var, def, info, bool, IniBool, 0);
     #define INI_INT(var, def, info)    INI_TYPE(var, def, info, int, IniInt, 0);
     #define INI_INT64(var, def, info)  INI_TYPE(var, def, info, int64, IniInt64, 0);
     #define INI_DOUBLE(var, def, info) INI_TYPE(var, def, info, double, IniDouble, 0);
     #define INI_BOOL(var, def, info)   INI_TYPE(var, def, info, bool, IniBool, 0)
     #define INI_INT(var, def, info)    INI_TYPE(var, def, info, int, IniInt, 0)
     #define INI_INT64(var, def, info)  INI_TYPE(var, def, info, int64, IniInt64, 0)
     #define INI_DOUBLE(var, def, info) INI_TYPE(var, def, info, double, IniDouble, 0)
     #define INI_STRING(var, def, info) String& DefRef_##var() { static String x; return x; }\
                                        INI_TYPE(var, def, info, String, IniString, DefRef_##var);
                                        INI_TYPE(var, def, info, String, IniString, DefRef_##var)
     VectorMap<String, String> LoadIniStream(Stream &in);
     VectorMap<String, String> LoadIniFile(const char *filename);

     	return NameNdx()[q];
+    }
     SVO_FN(s_String, String);
     SVO_FN(s_int, int);
     SVO_FN(s_double, double);
     SVO_FN(s_int64, int64);
     SVO_FN(s_bool, bool);
     SVO_FN(s_date, Date);
     SVO_FN(s_time, Time);
     SVO_FN(s_String, String)
     SVO_FN(s_int, int)
     SVO_FN(s_double, double)
     SVO_FN(s_int64, int64)
     SVO_FN(s_bool, bool)
     SVO_FN(s_date, Date)
     SVO_FN(s_time, Time)
     struct SvoVoidFn {
     	static bool       IsNull(const void *p)                      { return true; }

     	void           Shrink();
     	rval_default(XmlNode);
     	rval_default(XmlNode)
     	XmlNode(const XmlNode& n, int);

     #define VALUE_XMLIZE(type) template <> void Xmlize(XmlIO& xml, type& var) { xml.Attr("value", var); }
     VALUE_XMLIZE(int);
     VALUE_XMLIZE(dword);
     VALUE_XMLIZE(double);
     VALUE_XMLIZE(bool);
     VALUE_XMLIZE(int16);
     VALUE_XMLIZE(int64);
     VALUE_XMLIZE(byte);
     VALUE_XMLIZE(Time);
     VALUE_XMLIZE(Date);
     VALUE_XMLIZE(int)
     VALUE_XMLIZE(dword)
     VALUE_XMLIZE(double)
     VALUE_XMLIZE(bool)
     VALUE_XMLIZE(int16)
     VALUE_XMLIZE(int64)
     VALUE_XMLIZE(byte)
     VALUE_XMLIZE(Time)
     VALUE_XMLIZE(Date)
     void XmlizeLangAttr(XmlIO& xml, int& lang, const char *id)
+    {

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

     struct SrcFile {
     	SrcFile();
     	rval_default(SrcFile);
     	rval_default(SrcFile)
     	String      text;
     	Vector<int> linepos;
-...
     inline bool IsCppCode(int i) {
     	return i >= CONSTRUCTOR && i <= INLINEFRIEND;
     };
+    }
     inline bool IsCppData(int i) {
     	return i >= VARIABLE && i <= ENUM;
-...
     		String  Dump() const;
     		Context() {}
     		rval_default(Context);
     		rval_default(Context)
     	};
     	struct Decla {
-...
     	struct Decl : Decla {
     		Array<Decl> param;
     		rval_default(Decl);
     		rval_default(Decl)
     		Decl() {}
     	};

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 __;
-...
     	lock--;
+    }
     CH_INT(GUI_GlobalStyle, GUISTYLE_CLASSIC);
     CH_INT(GUI_DragFullWindow, 1);
     CH_INT(GUI_PopUpEffect, GUIEFFECT_SLIDE);
     CH_INT(GUI_ToolTips, 1);
     CH_INT(GUI_ToolTipDelay, 1000);
     CH_INT(GUI_DropShadows, 1);
     CH_INT(GUI_AltAccessKeys, 1);
     CH_INT(GUI_AKD_Conservative, 0);
     CH_INT(GUI_DragDistance, 4);
     CH_INT(GUI_DblClickTime, 500);
     CH_INT(GUI_WheelScrollLines, 3);
     CH_INT(GUI_GlobalStyle, GUISTYLE_CLASSIC)
     CH_INT(GUI_DragFullWindow, 1)
     CH_INT(GUI_PopUpEffect, GUIEFFECT_SLIDE)
     CH_INT(GUI_ToolTips, 1)
     CH_INT(GUI_ToolTipDelay, 1000)
     CH_INT(GUI_DropShadows, 1)
     CH_INT(GUI_AltAccessKeys, 1)
     CH_INT(GUI_AKD_Conservative, 0)
     CH_INT(GUI_DragDistance, 4)
     CH_INT(GUI_DblClickTime, 500)
     CH_INT(GUI_WheelScrollLines, 3)
     String Ctrl::Name0() const {
     	GuiLock __;

     CtrlFrame& OutsetFrame() { static BorderFrame h(OutsetBorder()); return h; }
     CtrlFrame& ThinOutsetFrame() { static BorderFrame h(ThinOutsetBorder()); return h; }
     CH_COLOR(FieldFrameColor, Blend(SColorHighlight, SColorShadow));
     CH_COLOR(FieldFrameColor, Blend(SColorHighlight, SColorShadow))
     class XPFieldFrameCls : public CtrlFrame {
     	virtual void FrameLayout(Rect& r)                   { r.Deflate(2); }
-...
     CtrlFrame& XPFieldFrame() { return Single<XPFieldFrameCls>(); }
     CtrlFrame& XPEditFieldFrame() { return Single<XPEditFieldFrameCls>(); }
     CH_INT(EditFieldIsThin, 0);
     CH_INT(EditFieldIsThin, 0)
     CtrlFrame& FieldFrame() { return GUI_GlobalStyle() >= GUISTYLE_XP ? XPFieldFrame() : InsetFrame(); }
     CH_VALUE(TopSeparator1, SColorShadow());
     CH_VALUE(TopSeparator2, SColorLight());
     CH_VALUE(TopSeparator1, SColorShadow())
     CH_VALUE(TopSeparator2, SColorLight())
     class TopSeparatorFrameCls : public CtrlFrame {
     	virtual void FrameLayout(Rect& r)                   { r.top += 2; }
-...
     CtrlFrame& RightSeparatorFrame()  { return Single<RightSeparatorFrameCls>(); }
     CtrlFrame& LeftSeparatorFrame()   { return Single<LeftSeparatorFrameCls>(); }
     CH_INT(FrameButtonWidth, DPI(17));
     CH_INT(ScrollBarArrowSize, FrameButtonWidth());
     CH_INT(FrameButtonWidth, DPI(17))
     CH_INT(ScrollBarArrowSize, FrameButtonWidth())
     void LayoutFrameLeft(Rect& r, Ctrl *ctrl, int cx)
+    {

uppsrc/CtrlCore/TopWindow.cpp
526	526	win.Maximize();
527	527	}
528	528
529		CH_INT(SwapOKCancel, 0);
	529	CH_INT(SwapOKCancel, 0)
530	530
531	531	void ArrangeOKCancel(Ctrl& ok, Ctrl& cancel)
532	532	{

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

     namespace Upp {
     INITIALIZE(CtrlLib);
     INITIALIZE(CtrlLib)
     #define IMAGECLASS CtrlImg
     #define IMAGEFILE <CtrlLib/Ctrl.iml>

uppsrc/CtrlLib/CtrlLibInit.cpp
13	13	#else
14	14	CtrlSetDefaultSkin(ChStdSkin, ChStdSkin);
15	15	#endif
16		};
	16	}
17	17
18	18	}

     	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()
+    {

     namespace Upp {
     CH_VALUE(TreeDropEdge, ChBorder(BlackBorder()));
     CH_VALUE(TreeDropEdge, ChBorder(BlackBorder()))
     CtrlFrame& TreeDropFrame()
+    {
-...
     	dropwidth = 0;
+    }
     };
+    }

     namespace Upp {
     CH_VALUE(ViewEdge, CtrlsImg::VE());
     CH_VALUE(ViewEdge, CtrlsImg::VE())
     Value EditFieldEdge()
+    {

     namespace Upp {
     CH_VALUE(DropEdge, ChBorder(BlackBorder()));
     CH_VALUE(DropEdge, ChBorder(BlackBorder()))
     CtrlFrame& DropFrame()
+    {

     	return Prompt(Ctrl::GetAppName(), CtrlImg::error(), qtf, t_("OK"), t_("Cancel"));
+    }
     CH_IMAGE(YesButtonImage, Null);
     CH_IMAGE(NoButtonImage, Null);
     CH_IMAGE(AbortButtonImage, Null);
     CH_IMAGE(RetryButtonImage, Null);
     CH_IMAGE(YesButtonImage, Null)
     CH_IMAGE(NoButtonImage, Null)
     CH_IMAGE(AbortButtonImage, Null)
     CH_IMAGE(RetryButtonImage, Null)
     int PromptYesNo(const char *qtf) {
     	BeepQuestion();

uppsrc/CtrlLib/ScrollBar.cpp
597	597	return Image::Arrow();
598	598	}
599	599
600		CH_IMAGE(SizeGripImg, CtrlsImg::SizeGrip());
	600	CH_IMAGE(SizeGripImg, CtrlsImg::SizeGrip())
601	601
602	602	void SizeGrip::Paint(Draw& w)
603	603	{

     Label::~Label() {}
     CH_COLOR(LabelBoxColor, SColorShadow());
     CH_COLOR(LabelBoxColor, SColorShadow())
     CH_COLOR(LabelBoxTextColor, SColorText());
     CH_COLOR(LabelBoxDisabledTextColor, SColorDisabled());
     CH_COLOR(LabelBoxTextColor, SColorText())
     CH_COLOR(LabelBoxDisabledTextColor, SColorDisabled())
     LabelBox::LabelBox()
+    {
-...
     		ChPaint(w, q - 1, lmargin, 1, sz.cy - (lmargin + rmargin), style->l1);
     		ChPaint(w, q, lmargin, 1, sz.cy - (lmargin + rmargin), style->l2);
+    	}
     };
+    }
     SeparatorCtrl& SeparatorCtrl::Margin(int l, int r)
+    {

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/DrawRasterData.cpp
30	30	INITBLOCK
31	31	{
32	32	DataDrawer::Register<cDrawRasterData>("image_data");
33		};
	33	}
34	34
35	35	void DrawRasterData(Draw& w, int x, int y, int cx, int cy, const String& data)
36	36	{

     namespace Upp {
     CH_COLOR(SBlack, AdjustIfDark(Black()));
     CH_COLOR(SGray, AdjustIfDark(Gray()));
     CH_COLOR(SLtGray, AdjustIfDark(LtGray()));
     CH_COLOR(SWhiteGray, AdjustIfDark(WhiteGray()));
     CH_COLOR(SWhite, AdjustIfDark(White()));
     CH_COLOR(SRed, AdjustIfDark(Red()));
     CH_COLOR(SGreen, AdjustIfDark(Green()));
     CH_COLOR(SBrown, AdjustIfDark(Brown()));
     CH_COLOR(SBlue, AdjustIfDark(Blue()));
     CH_COLOR(SMagenta, AdjustIfDark(Magenta()));
     CH_COLOR(SCyan, AdjustIfDark(Cyan()));
     CH_COLOR(SYellow, AdjustIfDark(Yellow()));
     CH_COLOR(SLtRed, AdjustIfDark(LtRed()));
     CH_COLOR(SLtGreen, AdjustIfDark(LtGreen()));
     CH_COLOR(SLtYellow, AdjustIfDark(LtYellow()));
     CH_COLOR(SLtBlue, AdjustIfDark(LtBlue()));
     CH_COLOR(SLtMagenta, AdjustIfDark(LtMagenta()));
     CH_COLOR(SLtCyan, AdjustIfDark(LtCyan()));
     CH_COLOR(SBlack, AdjustIfDark(Black()))
     CH_COLOR(SGray, AdjustIfDark(Gray()))
     CH_COLOR(SLtGray, AdjustIfDark(LtGray()))
     CH_COLOR(SWhiteGray, AdjustIfDark(WhiteGray()))
     CH_COLOR(SWhite, AdjustIfDark(White()))
     CH_COLOR(SRed, AdjustIfDark(Red()))
     CH_COLOR(SGreen, AdjustIfDark(Green()))
     CH_COLOR(SBrown, AdjustIfDark(Brown()))
     CH_COLOR(SBlue, AdjustIfDark(Blue()))
     CH_COLOR(SMagenta, AdjustIfDark(Magenta()))
     CH_COLOR(SCyan, AdjustIfDark(Cyan()))
     CH_COLOR(SYellow, AdjustIfDark(Yellow()))
     CH_COLOR(SLtRed, AdjustIfDark(LtRed()))
     CH_COLOR(SLtGreen, AdjustIfDark(LtGreen()))
     CH_COLOR(SLtYellow, AdjustIfDark(LtYellow()))
     CH_COLOR(SLtBlue, AdjustIfDark(LtBlue()))
     CH_COLOR(SLtMagenta, AdjustIfDark(LtMagenta()))
     CH_COLOR(SLtCyan, AdjustIfDark(LtCyan()))
     bool dark_theme__;
-...
     	Iml::ResetAll();
     CH_END
     CH_COLOR(SColorFace, LtGray());
     CH_COLOR(SColorText, Black());
     CH_COLOR(SColorHighlight, Blue());
     CH_COLOR(SColorHighlightText, White());
     CH_COLOR(SColorMenu, LtGray());
     CH_COLOR(SColorMenuText, Black());
     CH_COLOR(SColorInfo, LtYellow());
     CH_COLOR(SColorInfoText, Black());
     CH_COLOR(SColorDisabled, Gray());
     CH_COLOR(SColorLight, White());
     CH_COLOR(SColorShadow, Gray());
     CH_COLOR(SColorMark, IsDark(SColorPaper()) ? DarkTheme(LtBlue()) : LtBlue());
     CH_COLOR(SColorMenuMark, IsDark(SColorMenu()) ? DarkTheme(LtBlue()) : LtBlue());
     CH_COLOR(SColorLtFace, Blend(SColorFace, SColorLight));
     CH_COLOR(SColorDkShadow, Blend(SColorShadow, SColorText));
     CH_COLOR(SColorLabel, SColorText());
     CH_COLOR(SColorFace, LtGray())
     CH_COLOR(SColorText, Black())
     CH_COLOR(SColorHighlight, Blue())
     CH_COLOR(SColorHighlightText, White())
     CH_COLOR(SColorMenu, LtGray())
     CH_COLOR(SColorMenuText, Black())
     CH_COLOR(SColorInfo, LtYellow())
     CH_COLOR(SColorInfoText, Black())
     CH_COLOR(SColorDisabled, Gray())
     CH_COLOR(SColorLight, White())
     CH_COLOR(SColorShadow, Gray())
     CH_COLOR(SColorMark, IsDark(SColorPaper()) ? DarkTheme(LtBlue()) : LtBlue())
     CH_COLOR(SColorMenuMark, IsDark(SColorMenu()) ? DarkTheme(LtBlue()) : LtBlue())
     CH_COLOR(SColorLtFace, Blend(SColorFace, SColorLight))
     CH_COLOR(SColorDkShadow, Blend(SColorShadow, SColorText))
     CH_COLOR(SColorLabel, SColorText())
+    }

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	}

     	Point     target2;
     	One<Node> split;
     	rval_default(LinearSegmentTree);
     	rval_default(LinearSegmentTree)
     	LinearSegmentTree() {}
     };
-...
     		Point      trg_topleft, trg_topright, trg_bottomleft, trg_bottomright;
     		One<Split> split;
     		rval_default(Node);
     		rval_default(Node)
     		Node() {}
     	};
-...
     public:
     	Node root;
     	rval_default(PlanarSegmentTree);
     	rval_default(PlanarSegmentTree)
     	PlanarSegmentTree() {}
     };

     		SKIP_CURRENT_ROW = BIT(0),
     		SKIP_HIDDEN = BIT(1)
     	};
     };
+    }
     class GridFind : public EditString
+    {
-...
     class GridClipboard : Moveable<GridClipboard>
+    {
     	public:
     		rval_default(GridClipboard);
     		rval_default(GridClipboard)
     		GridClipboard() {}
     		struct ClipboardData : Moveable<ClipboardData>

     namespace Upp {
     INITIALIZE(PdfDraw);
     INITIALIZE(PdfDraw)
     class TTFReader {
     	struct TTFStream {

     INITBLOCK {
     	RichObject::Register("Drawing", &Single<RichObjectTypeDrawingCls>());
     };
+    }
     struct RichObjectTypePNGCls : public RichObjectType
+    {
-...
     INITBLOCK {
     	RichObject::Register("PING", &Single<RichObjectTypePNGCls>());
     };
+    }
+    }

     		void                 Justify(const Format& format);
     		int                  BodyHeight() const;
     		rval_default(Lines);
     		rval_default(Lines)
     		Lines();
     		~Lines();
-...
     	void        CacheId(int64 id);
     	rval_default(RichPara);
     	rval_default(RichPara)
     	RichPara();
     	~RichPara();

     INITBLOCK {
     	RichObject::Register("image", &Single<RichImage>());
     };
+    }
     RichObject CreateImageObject(const Image& img, int cx, int cy)
+    {
-...
     INITBLOCK {
     	RichObject::Register("PNG", &Single<RichPNG>());
     };
+    }
     struct RichRawImage : public RichObjectType {
     	virtual String GetTypeName(const Value& v) const;
-...
     INITBLOCK {
     	RichObject::Register("rawimage", &Single<RichRawImage>());
     };
+    }
     RichObject CreateRawImageObject(const String& s, int cx, int cy)
+    {
-...
     INITBLOCK {
     	RichObject::Register("iml", &Single<RichImlImage>());
     };
+    }
     #endif

     #define IMAGEFILE <RichText/RichText.iml>
     #include <Draw/iml_header.h>
     INITIALIZE(RichImage);
     INITIALIZE(RichImage)
     class  PasteClip;
     struct RichPara;

     	friend class RichText;
     public:
     	rval_default(RichCell);
     	rval_default(RichCell)
     	RichCell(const RichCell& src, int);
     	RichCell();
-...
     		PaintRow& operator[](int i)                 { return row[i]; }
     		const PaintRow& operator[](int i) const     { return row[i]; }
     		rval_default(Layout); // Old CLANG requires this
     		rval_default(Layout) // Old CLANG requires this
     		Layout() {}
     	};
-...
     		Rect              next_page;
     		Rect              header_page;
     		rval_default(TabLayout); // Old CLANG requires this
     		rval_default(TabLayout) // Old CLANG requires this
     		TabLayout() {}
     	};
-...
     	void          Normalize();
     	rval_default(RichTable);
     	rval_default(RichTable)
     	RichTable(const RichTable& src, int);
     	RichTable();

     	RichTxt(const RichTxt& src, int);
     	RichTxt();
     	rval_default(RichTxt);
     	rval_default(RichTxt)
     #ifdef _DEBUG
     	void                  Dump();

+    }
     namespace Ini {
     	INI_BOOL(skylark_log, false, "Trace of Skylark");
     };
     	INI_BOOL(skylark_log, false, "Trace of Skylark")
+    }
     #ifdef PLATFORM_WIN32
     BOOL WINAPI SkylarkApp::CtrlCHandlerRoutine(DWORD dwCtrlType)
-...
+    }
     namespace Ini {
     INI_INT(port, 8001, "TCP/IP server port to listen on");
     INI_STRING(ip, "0.0.0.0", "IP address to listen on");
     INI_STRING(path, Nvl(GetEnv("UPP_ASSEMBLY__"), GetFileFolder(GetExeFilePath())), "Path to witz templates and static files");
     INI_INT(threads, 3 * CPU_Cores() + 1, "Number of threads in each Skylark subprocess");
     INI_INT(port, 8001, "TCP/IP server port to listen on")
     INI_STRING(ip, "0.0.0.0", "IP address to listen on")
     INI_STRING(path, Nvl(GetEnv("UPP_ASSEMBLY__"), GetFileFolder(GetExeFilePath())), "Path to witz templates and static files")
     INI_INT(threads, 3 * CPU_Cores() + 1, "Number of threads in each Skylark subprocess")
     #ifdef _DEBUG
     INI_INT(prefork, 0, "Number of preforked Skylark subprocesses");
     INI_INT(timeout, 0, "Timeout in seconds for Skylark event handler");
     INI_BOOL(use_caching, false, "Cache compiled witz templates or other data");
     INI_INT(prefork, 0, "Number of preforked Skylark subprocesses")
     INI_INT(timeout, 0, "Timeout in seconds for Skylark event handler")
     INI_BOOL(use_caching, false, "Cache compiled witz templates or other data")
     INI_INT(caching, 1, "Agressivity of caching on static/** "
                         "(0=no caching, 1=use ETag header, 2=use versioned path)");
                         "(0=no caching, 1=use ETag header, 2=use versioned path)")
     #else
     INI_INT(prefork, 1, "Number of preforked Skylark subprocesses");
     INI_INT(timeout, 300, "Timeout in seconds for Skylark event handler");
     INI_BOOL(use_caching, true, "Cache compiled witz templates or other data");
     INI_INT(prefork, 1, "Number of preforked Skylark subprocesses")
     INI_INT(timeout, 300, "Timeout in seconds for Skylark event handler")
     INI_BOOL(use_caching, true, "Cache compiled witz templates or other data")
     INI_INT(caching, 1, "Agressivity of caching on static/** "
                         "(0=no caching, 1=use ETag header, 2=use versioned path)");
                         "(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	}

     	enum { GET, POST };
     	rval_default(DispatchNode);
     	rval_default(DispatchNode)
     	DispatchNode() { argpos = Null; method = GET; post_raw = false; progress = NULL;}
     };
-...
+        }
+    }
     };
+    }

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	}

     INITBLOCK {
     	Compiler::Register("ImlImg", ImlImg);
     };
+    }
     };
+    }

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	}

     namespace Upp {
     namespace Ini {
     INI_STRING(session_cookie, "__skylark_session_cookie__", "Skylark session cookie ID");
     INI_STRING(session_dir, ConfigFile("session"), "Directory that contains Skylark session files");
     INI_STRING(session_format, "BINARY", "Skylark session format ('BINARY', 'JSON', 'XML')");
     INI_STRING(session_table, "", "SQL table used to store Skylark sessions; if empty, sessions are stored in files");
     INI_STRING(session_id_column, "ID", "Primary key of SQL table used to store Skylark sessions");
     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");
     };
     INI_STRING(session_cookie, "__skylark_session_cookie__", "Skylark session cookie ID")
     INI_STRING(session_dir, ConfigFile("session"), "Directory that contains Skylark session files")
     INI_STRING(session_format, "BINARY", "Skylark session format ('BINARY', 'JSON', 'XML')")
     INI_STRING(session_table, "", "SQL table used to store Skylark sessions; if empty, sessions are stored in files")
     INI_STRING(session_id_column, "ID", "Primary key of SQL table used to store Skylark sessions")
     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	}

     INITBLOCK {
     	Compiler::Register("CachedStatic", CachedStatic);
     };
+    }
     SKYLARK(ServeStaticPage, "static/**")
+    {
-...
     	http.Content(type, LoadFile(path));
+    }
     };
+    }

     	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);
+    }
+    }

     	__List##I(E__Cat); \
     	priority = SET; \
+    }
     __Expand(E__SqlSetF);
     __Expand(E__SqlSetF)
     //$+
     FieldOperator::FieldOperator() {}

     	__List##I(E__SCat); \
     	text = ~set; \
+    }
     __Expand(E__QSqlSelectF);
     __Expand(E__QSqlSelectF)
     #define E__QSelectF(I) \
     SqlSelect Select(__List##I(E__SqlVal)) { \
-...
     	__List##I(E__SCat); \
     	return Select(set); \
+    }
     __Expand(E__QSelectF);
     __Expand(E__QSelectF)
     //$+
     // -------------------------------

     //$-SqlSet(const SqlVal& p0, ...)
     #define E__SqlSet(I)   SqlSet(const SqlVal& p0, __List##I(E__SqlVal));
     	__Expand(E__SqlSet);
     	__Expand(E__SqlSet)
     //$+
     	explicit SqlSet(Fields nfields);
-...
     	SqlSelect()                                       { on = valid = false; }
     //$-SqlSelect(SqlVal v, ...);
     #define E__QSelect(I)   SqlSelect(__List##I(E__SqlVal));
     	__Expand(E__QSelect);
     	__Expand(E__QSelect)
     #undef  E__QSelect
     //$+
-...
     //$-SqlSelect Select(SqlVal v, ...);
     #define E__QSelect(I)   SqlSelect Select(__List##I(E__SqlVal));
     __Expand(E__QSelect);
     __Expand(E__QSelect)
     #undef  E__QSelect
     //$-
-...
     #define E__Arg(I)       Arg(p##I)
     #define E__Args(I) \
     	SqlWith& operator()(__List##I(E__SqlId)) { __List##I(E__Arg); return *this; }
     	__Expand(E__Args);
     	__Expand(E__Args)
     #undef E__Args
     #undef E__Arg
     #undef E__SqlId

     		Vector <Value> value;
     		SqlBool        remove;
     		rval_default(Row);
     		rval_default(Row)
     		Row() {}
     	};

     template <> inline unsigned GetHashValue(const SetOpCode& c) { return c; }
     NTL_MOVEABLE(SetOpCode);
     NTL_MOVEABLE(SetOpCode)
     template<class V, class I>
     Index<V> SetGetIndex(I begin, I end)

uppsrc/TSql/util.cpp
586	586	__List##I(E__SCat); \
587	587	return SelectHint(hint, set); \
588	588	}
589		__Expand(E__QSelectF);
	589	__Expand(E__QSelectF)
590	590	*/
591	591	SqlSet DeleteHint(const char *hint, const SqlVal& table)
592	592	{

     #define E__SelectHint(I)\
     SqlSelect             SelectHint(const char *hint, __List##I(E__SqlVal));
     __Expand(E__SelectHint);
     __Expand(E__SelectHint)
     */
     SqlSet                DeleteHint(const char *hint, const SqlVal& table);
     SqlSet                DeleteSchemaHint(const char *hint, const SqlId& table);

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	}

     	TopicInfo() {}
     	rval_default(TopicInfo);
     	rval_default(TopicInfo)
     };
     String          GetTopicPath(const TopicLink& link);

     		File()                            { Init(); }
     		File(const String& s) : String(s) { Init(); }
     		rval_default(File);
     		rval_default(File)
     	};
     	struct Config {
     		String name;

uppsrc/ide/IconDes/IconDes.h
37	37	IdeIconEditPos() { filetime = Null; }
38	38	};
39	39
40		INITIALIZE(IconDes);
	40	INITIALIZE(IconDes)
41	41
42	42	#endif

     	Image                      icon[2];
     	Size                       iconsize[2];
     	rval_default(LayoutType);
     	rval_default(LayoutType)
     	LayoutType()               { iconsize[0] = iconsize[1] = Null; }
     };
-...
     	String   SaveProperties(int y = 0) const;
     	String   Save(int i, int y) const;
     	rval_default(LayoutItem);
     	rval_default(LayoutItem)
     	LayoutItem()                      { csize.cx = -1; hide = false; charset = CHARSET_UNICODE; }
     };
-...
     	bool        IsRedo();
     	void        Redo();
     	rval_default(LayoutData);
     	rval_default(LayoutData)
     	LayoutData() { size = Size(400, 200); charset = CHARSET_UNICODE; }
     };

     INITBLOCK {
     	RegisterGlobalConfig("SlideShow");
     };
+    }
     SlideShow::SlideShow()
+    {

     	Array<TemplateItem> item;
     	Array<FileTemplate> file;
     	rval_default(PackageTemplate);
     	rval_default(PackageTemplate)
     	PackageTemplate() {}
     };
-...
     	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	{

uppsrc/ide/t.cpp
37	37	Sort(ls);
38	38	}
39	39