v2.7.2.1

110_gfml/src_500_build/gplx/gfml/GfmlBldr.java

@@ -0,0 +1,74 @@
+/*
+XOWA: the XOWA Offline Wiki Application
+Copyright (C) 2012 gnosygnu@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package gplx.gfml; import gplx.*;
+import gplx.texts.*; /*CharStream*/ 
+public class GfmlBldr {
+	@gplx.Internal protected GfmlDoc			Doc() {return gdoc;} GfmlDoc gdoc = GfmlDoc.new_();
+	@gplx.Internal protected GfmlFrame			CurFrame() {return curFrame;} GfmlFrame curFrame;
+	@gplx.Internal protected GfmlFrame_nde		CurNdeFrame() {return curNdeFrame;} GfmlFrame_nde curNdeFrame;
+	@gplx.Internal protected GfmlNde			CurNde() {return curNdeFrame.CurNde();}
+	@gplx.Internal protected GfmlTypeMgr		TypeMgr() {return typeMgr;} GfmlTypeMgr typeMgr = GfmlTypeMgr.new_();
+	@gplx.Internal protected Hash_adp				Vars() {return vars;} Hash_adp vars = Hash_adp_.new_();
+	@gplx.Internal protected int				StreamPos()	{return streamPos;} int streamPos;
+	@gplx.Internal protected void				ThrowErrors_set(boolean v) {throwErrors = v;} private boolean throwErrors = true;
+	@gplx.Internal protected int PrvSymType() {return prvSymType;} @gplx.Internal protected void PrvSymType_set(int v) {prvSymType = v;} int prvSymType = GfmlNdeSymType.Null;
+	@gplx.Internal protected int ChainIdNext() {return chainIdNext++;} int chainIdNext = 1;
+	public GfmlDoc XtoGfmlDoc(String raw) {
+		Init(raw);
+		CharStream stream = CharStream.pos0_(raw);
+		while (stream.AtMid()) {
+			streamPos = stream.Pos();	// NOTE: streamPos is defined as just before curTkn
+			GfmlTkn curTkn = curFrame.Lxr().MakeTkn(stream, 0);
+			curTkn.Cmd_of_Tkn().Exec(this, curTkn);
+			if (stopBldr) break;
+		}
+		if (!stopBldr) {
+			curNdeFrame.Build_end(this, GfmlFrame_nde_.OwnerRoot_);
+			if (frameStack.Count() > 0) UsrMsgs_fail(GfmlUsrMsgs.fail_Frame_danglingBgn());
+		}
+		if (throwErrors && gdoc.UsrMsgs().Count() > 0) throw GfmlUsrMsgs.gfmlParseError(this);
+		raw = "";
+		return gdoc;
+	}
+	void Init(String raw) {
+		this.raw = raw; stopBldr = false; gdoc.Clear(); vars.Clear(); frameStack.Clear(); chainIdNext = 1; 
+		curNdeFrame = GfmlFrame_nde_.root_(this, gdoc.RootNde(), gdoc.RootLxr());
+		curNdeFrame.NullArea_set(true);
+		curFrame = curNdeFrame;
+	}
+	@gplx.Internal protected void Frames_push(GfmlFrame newFrame) {
+		frameStack.Push(curFrame);
+		curFrame = newFrame;
+		if (curFrame.FrameType() == GfmlFrame_.Type_nde) curNdeFrame = GfmlFrame_nde_.as_(curFrame);
+	}		
+	@gplx.Internal protected void Frames_end() {
+		if (frameStack.Count() == 0) {
+			UsrMsgs_fail(GfmlUsrMsgs.fail_Frame_danglingBgn());
+			return;
+		}
+		GfmlFrame oldFrame = curFrame;
+		curFrame = frameStack.Pop();
+		oldFrame.Build_end(this, curFrame);
+		if (curFrame.FrameType() == GfmlFrame_.Type_nde) curNdeFrame = GfmlFrame_nde_.as_(curFrame);
+	}
+	@gplx.Internal protected void UsrMsgs_fail(UsrMsg um) {
+		GfmlUsrMsgs.MakeErr(this, um, raw);
+		stopBldr = true;
+	}
+	GfmlFrameStack frameStack = GfmlFrameStack.new_(); boolean stopBldr = false; String raw = "";
+}

110_gfml/src_500_build/gplx/gfml/GfmlBldrCmd.java

@@ -0,0 +1,40 @@
+/*
+XOWA: the XOWA Offline Wiki Application
+Copyright (C) 2012 gnosygnu@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package gplx.gfml; import gplx.*;
+public interface GfmlBldrCmd {
+	String Key();
+	void Exec(GfmlBldr bldr, GfmlTkn tkn);
+}
+class GfmlBldrCmd_ {
+	public static final GfmlBldrCmd Null = new GfmlBldrCmd_null();
+}
+class GfmlBldrCmd_null implements GfmlBldrCmd {
+	public String Key() {return "gfml.nullCmd";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {}
+}
+class GfmlBldrCmdRegy {
+	public void Add(GfmlBldrCmd cmd) {hash.Add(cmd.Key(), cmd);}
+	public GfmlBldrCmd GetOrFail(String key) {return (GfmlBldrCmd)hash.Get_by_or_fail(key);}
+	Hash_adp hash = Hash_adp_.new_();
+	public static GfmlBldrCmdRegy new_() {
+		GfmlBldrCmdRegy rv = new GfmlBldrCmdRegy();
+		rv.Add(GfmlBldrCmd_elemKey_set._);
+		rv.Add(GfmlBldrCmd_dataTkn_set._);
+		return rv;
+	}	GfmlBldrCmdRegy() {}
+}

110_gfml/src_500_build/gplx/gfml/GfmlBldrCmds.java

@@ -0,0 +1,128 @@
+/*
+XOWA: the XOWA Offline Wiki Application
+Copyright (C) 2012 gnosygnu@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package gplx.gfml; import gplx.*;
+class GfmlBldrCmd_pendingTkns_add implements GfmlBldrCmd {
+	public String Key() {return "gfml.pendingTkns_add";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {bldr.CurFrame().WaitingTkns().Add(tkn);}
+	public static final GfmlBldrCmd_pendingTkns_add _ = new GfmlBldrCmd_pendingTkns_add(); GfmlBldrCmd_pendingTkns_add() {}
+}
+class GfmlBldrCmd_dataTkn_set implements GfmlBldrCmd {
+	public String Key() {return "gfml.elm_data";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {bldr.CurNdeFrame().DatTkn_set(tkn);}
+	public static final GfmlBldrCmd_dataTkn_set _ = new GfmlBldrCmd_dataTkn_set(); GfmlBldrCmd_dataTkn_set() {}
+}
+class GfmlBldrCmd_elemKey_set implements GfmlBldrCmd {
+	public String Key() {return "gfml.elm_key";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {bldr.CurNdeFrame().KeyTkn_set(tkn);}
+	public static final GfmlBldrCmd_elemKey_set _ = new GfmlBldrCmd_elemKey_set(); GfmlBldrCmd_elemKey_set() {}
+}
+class GfmlBldrCmd_ndeName_set implements GfmlBldrCmd {
+	public String Key() {return "gfml.ndeName_set";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {bldr.CurNdeFrame().NdeHeader_set(tkn);}
+	public static final GfmlBldrCmd_ndeName_set _ = new GfmlBldrCmd_ndeName_set(); GfmlBldrCmd_ndeName_set() {}
+}
+class GfmlBldrCmd_ndeBody_bgn implements GfmlBldrCmd {
+	public String Key() {return "gfml.nodeBody_bgn";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {
+		bldr.CurNdeFrame().NdeBody_bgn(tkn);
+		bldr.CurNdeFrame().BgnPos_set(bldr.StreamPos() - String_.Len(tkn.Raw()));// stream has already advanced tkn.len so subtract
+	}
+	public static final GfmlBldrCmd_ndeBody_bgn _ = new GfmlBldrCmd_ndeBody_bgn(); GfmlBldrCmd_ndeBody_bgn() {}
+}
+class GfmlBldrCmd_ndeProp_bgn implements GfmlBldrCmd {
+	public String Key() {return "cmd.gfml.ndeProp_bgn";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {bldr.CurNdeFrame().NdeProp_bgn(tkn);}
+	public static final GfmlBldrCmd_ndeProp_bgn _ = new GfmlBldrCmd_ndeProp_bgn(); GfmlBldrCmd_ndeProp_bgn() {}
+}
+class GfmlBldrCmd_ndeHdr_bgn implements GfmlBldrCmd {
+	public String Key() {return "cmd.gfml.ndeHdr_bgn";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {bldr.CurNdeFrame().NdeParen_bgn(tkn);}
+	public static final GfmlBldrCmd_ndeHdr_bgn _ = new GfmlBldrCmd_ndeHdr_bgn(); GfmlBldrCmd_ndeHdr_bgn() {}
+}
+class GfmlBldrCmd_ndeHdr_end implements GfmlBldrCmd {
+	public String Key() {return "cmd.gfml.ndeHdr_end";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {bldr.CurNdeFrame().NdeParen_end(tkn);}
+	public static final GfmlBldrCmd_ndeHdr_end _ = new GfmlBldrCmd_ndeHdr_end(); GfmlBldrCmd_ndeHdr_end() {}
+}
+class GfmlBldrCmd_ndeInline implements GfmlBldrCmd {
+	public String Key() {return "gfml.nodeInline_exec_end";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {bldr.CurNdeFrame().NdeInline(tkn);}
+	public static final GfmlBldrCmd_ndeInline _ = new GfmlBldrCmd_ndeInline(); GfmlBldrCmd_ndeInline() {}
+}
+class GfmlBldrCmd_ndeDot implements GfmlBldrCmd {
+	public String Key() {return "gfml.ndeDot";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {bldr.CurNdeFrame().NdeDot(tkn);}
+	public static final GfmlBldrCmd_ndeDot _ = new GfmlBldrCmd_ndeDot(); GfmlBldrCmd_ndeDot() {}
+}
+class GfmlBldrCmd_atrSpr implements GfmlBldrCmd {
+	public String Key() {return "gfml.nodeInline_atrSpr";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {bldr.CurNdeFrame().AtrSpr(tkn);}
+        public static final GfmlBldrCmd_atrSpr _ = new GfmlBldrCmd_atrSpr(); GfmlBldrCmd_atrSpr() {}
+}
+class GfmlBldrCmd_frameBgn implements GfmlBldrCmd {
+	public String Key() {return "gfml.frame_bgn";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {
+		GfmlFrame newFrame = frame.MakeNew(lxr.SubLxr());
+		bldr.Frames_push(newFrame);
+		bldr.CurFrame().WaitingTkns().Add(tkn);
+		bldr.CurNdeFrame().BgnPos_set(bldr.StreamPos() - String_.Len(tkn.Raw()));// stream has already advanced tkn.len so subtract
+	}
+	GfmlLxr lxr; GfmlFrame frame;
+	public static GfmlBldrCmd_frameBgn new_(GfmlFrame frame, GfmlLxr lxr) {
+		GfmlBldrCmd_frameBgn rv = new GfmlBldrCmd_frameBgn();
+		rv.frame = frame; rv.lxr = lxr;
+		return rv;
+	}	GfmlBldrCmd_frameBgn() {}
+}
+class GfmlBldrCmd_frameEnd implements GfmlBldrCmd {
+	public String Key() {return "gfml.frame_end";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {
+		if (bldr.CurFrame().FrameType() == GfmlFrame_.Type_nde) {
+			GfmlFrame_nde ndeFrm = (GfmlFrame_nde)bldr.CurFrame();
+			ndeFrm.WaitingTkns_AddSym(tkn, ndeSymType);
+		}
+		else
+			bldr.CurFrame().WaitingTkns().Add(tkn);
+		if (bldr.CurNdeFrame().CurNdeStartType() == GfmlNdeStartType.Prop
+			&& String_.Eq(tkn.Raw(), "}")) return;
+		bldr.Frames_end();
+	}
+	int ndeSymType;
+	public static GfmlBldrCmd_frameEnd data_() {return nde_(GfmlNdeSymType.Null);}
+        public static GfmlBldrCmd_frameEnd nde_(int ndeSymType) {
+		GfmlBldrCmd_frameEnd rv = new GfmlBldrCmd_frameEnd();
+		rv.ndeSymType = ndeSymType;
+		return rv;
+	}	GfmlBldrCmd_frameEnd() {}
+}
+class GfmlBldrCmd_whitespace implements GfmlBldrCmd {
+	public String Key() {return "gfml.whitespace_exec";}
+	public void Exec(GfmlBldr bldr, GfmlTkn tkn) {
+		if (bldr.CurNdeFrame().waitingTkns.Count() > 0) {
+			GfmlObj t = (GfmlObj)bldr.CurNdeFrame().waitingTkns.Get_at(bldr.CurNdeFrame().waitingTkns.Count() - 1);
+			if (t.ObjType() == GfmlObj_.Type_nde)
+				bldr.CurNdeFrame().IdxNdeBgn_set(bldr.CurNdeFrame().WaitingTkns().Count() + 1);
+		}
+		if (bldr.CurFrame().WaitingTkns().Count() == 0) {
+			bldr.CurNde().SubObjs_Add(tkn);		// if curFrame begins with whitespace, add directly to node (whitespace should not belong to atr)
+		}
+		else
+			bldr.CurFrame().WaitingTkns().Add(tkn);
+	}
+	public static final GfmlBldrCmd_whitespace _ = new GfmlBldrCmd_whitespace(); GfmlBldrCmd_whitespace() {}
+}

110_gfml/src_500_build/gplx/gfml/GfmlBldr_.java

@@ -0,0 +1,44 @@
+/*
+XOWA: the XOWA Offline Wiki Application
+Copyright (C) 2012 gnosygnu@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package gplx.gfml; import gplx.*;
+class GfmlBldr_ {
+	@gplx.Internal protected static GfmlBldr new_() {return new GfmlBldr();}
+	@gplx.Internal protected static GfmlBldr default_() {			
+		GfmlBldr rv = new GfmlBldr();
+		GfmlLxr rootLxr = GfmlDocLxrs.Root_lxr();
+		GfmlDocLxrs.Default_lxr(rv.Doc().LxrRegy(), rootLxr);
+		rv.Doc().RootLxr_set(rootLxr);
+		InitDocBldr(rv
+			, GfmlPragmaVar.new_()
+			, GfmlPragmaType.new_()
+			, GfmlPragmaDefault.new_()
+			, GfmlPragmaLxrSym.new_()
+			, GfmlPragmaLxrFrm.new_()
+			);
+		return rv;
+	}
+	static void InitDocBldr(GfmlBldr bldr, GfmlPragma... ary) {
+		GfmlTypeMakr makr = GfmlTypeMakr.new_();
+		GfmlTypRegy regy = bldr.TypeMgr().TypeRegy(); GfmlPragmaMgr cmdMgr = bldr.Doc().PragmaMgr();
+
+		for (GfmlPragma pragma : ary) {
+			regy.Add_ary(pragma.MakePragmaTypes(makr));
+			cmdMgr.Pragmas_add(pragma);
+		}
+	}
+}

110_gfml/src_500_build/gplx/gfml/GfmlFrame.java

@@ -0,0 +1,35 @@
+/*
+XOWA: the XOWA Offline Wiki Application
+Copyright (C) 2012 gnosygnu@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package gplx.gfml; import gplx.*;
+import gplx.lists.*; /*StackAdp*/
+public interface GfmlFrame {
+	GfmlLxr Lxr();							// each frame has only one lxr
+	int FrameType();
+	GfmlObjList WaitingTkns();
+	void Build_end(GfmlBldr bldr, GfmlFrame ownerFrame);
+	GfmlFrame MakeNew(GfmlLxr newLxr);
+}
+class GfmlFrameStack {
+	public int Count() {return stack.Count();}
+	public void Push(GfmlFrame frame) {stack.Push(frame);}
+	public GfmlFrame Pop() {return (GfmlFrame)stack.Pop();}
+	public GfmlFrame Peek() {return (GfmlFrame)stack.Peek();}
+	public void Clear() {stack.Clear();}
+	StackAdp stack = StackAdp_.new_();
+        public static GfmlFrameStack new_() {return new GfmlFrameStack();} GfmlFrameStack() {}
+}

110_gfml/src_500_build/gplx/gfml/GfmlFrame_.java

@@ -0,0 +1,87 @@
+/*
+XOWA: the XOWA Offline Wiki Application
+Copyright (C) 2012 gnosygnu@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package gplx.gfml; import gplx.*;
+class GfmlFrame_ {
+	public static GfmlFrame comment_() {return new GfmlFrame_comment();}
+	public static GfmlFrame quote_() {return new GfmlFrame_quote();}
+	public static GfmlFrame eval_() {return new GfmlFrame_eval();}
+	public static final int
+		  Type_nde		= 1
+		, Type_data		= 2
+		, Type_comment	= 3
+		;
+}
+abstract class GfmlFrame_base implements GfmlFrame {
+	public GfmlLxr Lxr() {return lxr;} GfmlLxr lxr;
+	public abstract int FrameType();
+	public int BgnPos() {return bgnPos;} public void BgnPos_set(int v) {bgnPos = v;} int bgnPos;
+	public GfmlObjList WaitingTkns() {return waitingTkns;} @gplx.Internal protected final GfmlObjList waitingTkns = GfmlObjList.new_();
+	public GfmlFrame MakeNew(GfmlLxr newLxr) {GfmlFrame_base rv = MakeNew_hook(); rv.ctor_(newLxr); return rv;}
+	public abstract void Build_end(GfmlBldr bldr, GfmlFrame ownerFrame);
+	protected abstract GfmlFrame_base MakeNew_hook();
+	protected void ctor_(GfmlLxr lxr) {this.lxr = lxr;}
+}
+class GfmlFrame_comment extends GfmlFrame_base {
+	@Override public int FrameType() {return GfmlFrame_.Type_comment;}
+	@Override public void Build_end(GfmlBldr bldr, GfmlFrame ownerFrame) {
+		GfmlTkn commentTkn = GfmlTkn_.composite_list_("tkn:comment", waitingTkns);
+		ownerFrame.WaitingTkns().Add(commentTkn);						// always add commentTkn to WaitingTkns
+	}
+	@Override protected GfmlFrame_base MakeNew_hook() {return new GfmlFrame_comment();}
+}	
+class GfmlFrame_quote extends GfmlFrame_base {
+	@Override public int FrameType() {return GfmlFrame_.Type_data;}
+	@Override public void Build_end(GfmlBldr bldr, GfmlFrame ownerFrame) {
+		GfmlTkn quoteTkn = GfmlTkn_.composite_list_("tkn:quote", waitingTkns);
+		GfmlFrameUtl.AddFrameTkn(ownerFrame, quoteTkn);
+	}
+	@Override protected GfmlFrame_base MakeNew_hook() {return new GfmlFrame_quote();}
+}
+class GfmlFrame_eval extends GfmlFrame_base {
+	@Override public int FrameType() {return GfmlFrame_.Type_data;}
+	@Override public void Build_end(GfmlBldr bldr, GfmlFrame ownerFrame) {			
+		GfmlTkn evalTkn = MakeEvalTkn(bldr, waitingTkns);
+		GfmlFrameUtl.AddFrameTkn(ownerFrame, evalTkn);
+	}
+	@Override protected GfmlFrame_base MakeNew_hook() {return new GfmlFrame_eval();}
+	static GfmlTkn MakeEvalTkn(GfmlBldr bldr, GfmlObjList waitingTkns) {
+		GfmlTkn composite = GfmlTkn_.composite_list_("tkn:eval_temp", waitingTkns);
+		String[] ary = ExtractContextKey(composite.Val());
+		String varContext = ary[0], varKey = ary[1];
+		GfmlVarCtx evalContext = GfmlVarCtx_.FetchFromCacheOrNew(bldr.Vars(), varContext);
+		return new GfmlVarTkn("tkn:eval", composite.SubTkns(), evalContext, varKey);
+	}
+	static String[] ExtractContextKey(String raw) {
+		String[] ary = String_.Split(raw, ".");
+		if (ary.length == 2) return ary; // NOOP: elems already assigned; context = ary[0]; key = ary[1];
+		if (ary.length > 2) throw Exc_.new_("invalid context key for eval frame; should have 0 or 1 dlms", "key", raw);
+		String[] rv = new String[2];
+		rv[0] = GfmlVarCtx_.DefaultKey;
+		rv[1] = ary[0];
+		return rv;
+	}
+}	
+class GfmlFrameUtl {
+	@gplx.Internal protected static void AddFrameTkn(GfmlFrame ownerFrame, GfmlTkn frameTkn) {
+		GfmlFrame_nde nodeFrame = GfmlFrame_nde_.as_(ownerFrame);
+		if (nodeFrame != null)						// ownerFrame is node: set frameTkn as dataTkn
+			nodeFrame.DatTkn_set(frameTkn);
+		else										// ownerFrame is likely quoteFrame; add to waitingTkns (allows multiple nestings)
+			ownerFrame.WaitingTkns().Add(frameTkn);
+	}
+}

110_gfml/src_500_build/gplx/gfml/GfmlFrame_nde.java

@@ -0,0 +1,250 @@
+/*
+XOWA: the XOWA Offline Wiki Application
+Copyright (C) 2012 gnosygnu@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package gplx.gfml; import gplx.*;
+class GfmlFrame_nde extends GfmlFrame_base {
+	@Override public int		FrameType()			{return GfmlFrame_.Type_nde;}
+	public GfmlNde			CurNde()			{return nde;} GfmlNde nde;
+	public int				CurNdeStartType()	{return ndeStartType;} int ndeStartType;
+	public GfmlDocPos		CurDocPos()			{return docPos;} GfmlDocPos docPos = GfmlDocPos_.Root;
+	public void				NullArea_set(boolean v) {nullArea = v;} private boolean nullArea = false;
+	public void DatTkn_set(GfmlTkn datTkn) {		// < data >
+		if (nullArea) {								// tkn is unnamed atrVal for new nde; EX: < a:; data >
+			nullArea = false;
+			GfmlFrame_nde frame = NewFrame(GfmlNdeStartType.DatTkn);
+			frame.tknMgr.DatTkn_set(datTkn);
+		}
+		else {
+			GfmlTkn itmKeyTkn = tknMgr.KeyTkn_pop();
+			if (itmKeyTkn != GfmlTkn_.Null)			// elemKey is pending: tkn is atrVal; EX: < a=data >
+				tknMgr.ExecMakeAtr(itmKeyTkn, datTkn);
+			else									// tkn is unnamed atrVal; EX: < a datTkn >
+				tknMgr.DatTkn_set(datTkn);
+		}
+	}
+	public void NdeBody_bgn(GfmlTkn symTkn) {		// EX: < { >
+		WaitingTkns_AddSym(symTkn, GfmlNdeSymType.BodyBgn);
+		GfmlFrame_nde frame = this;
+		if (nullArea)								// EX: {{  NOTE: else nde is in header; don't begin nde; EX: a:{
+			frame = NewFrame(GfmlNdeStartType.Brace);
+		tknMgr.ExecXferTkns_ndeBgn(this.CurNde());
+		frame.nullArea = true;
+	}
+	public void NdeInline(GfmlTkn symTkn) {			// ; 
+		WaitingTkns_AddSym(symTkn, GfmlNdeSymType.Inline);
+		if (nullArea)								// empty node; EX: < ;; > NOTE: this will not be called if dataTkn is present, since dataTkn starts node; EX: < a; >
+			NewFrame(GfmlNdeStartType.Inline);
+		bldr.Frames_end();							// NOTE: no need for frame.nullArea = true b/c frame is ended
+	}
+	public void KeyTkn_set(GfmlTkn symTkn) {		// EX: < = >
+		WaitingTkns_AddSym(symTkn, GfmlNdeSymType.Key);
+		tknMgr.KeyTkn_setFromDataTknOrFail();
+	}
+	public void NdeHeader_set(GfmlTkn symTkn) {		// EX: < : >
+		WaitingTkns_AddSym(symTkn, GfmlNdeSymType.Hnd);
+		tknMgr.IdxNdeBgn_setToAtrBgn();
+		tknMgr.HndTkn_setByDatTknOrFail();
+		GfmlTkn hnd = tknMgr.HndTkn_pop();
+		GfmlFrame_nde frame = this;
+		if (bldr.CurNdeFrame().CurNdeStartType() == GfmlNdeStartType.Prop)	// EX: < [a: > - must start new sub node;
+			frame = NewFrame(GfmlNdeStartType.Hnd);
+		frame.CurNde().HndTkn_set(hnd);
+		bldr.TypeMgr().NdeResolve(frame.CurNde(), ownerTypeKey);
+	}
+	public void NdeDot(GfmlTkn symTkn) {			// EX: < . >
+		GfmlFrame_nde frm = this, oldFrm = this;
+		GfmlTkn hndTkn = HndTkn_GetForDotOp(frm);	// get hndTkn; needed for (a) newFrm if prpNde; or (b) curFrm 
+		boolean createPrpNde = dotSymCreatesPrpNde;	// get createPrpNde b/c it will be reused later in this proc
+		if (createPrpNde) {							// inside parens; . will create a prpNde EX: a:(b.c); vs a.b
+			frm = NewFrame(GfmlNdeStartType.Dot);
+			frm.nde.KeyedSubObj_(true);				// NOTE: must set prpNdes to keyed
+			frm.nde.ChainId_(bldr.ChainIdNext());
+		}
+		if (hndTkn != GfmlTkn_.Null) {				// NOTE: need to check for Null to handle ")."; EX: a.b().c(); 2nd . would return Null and overwrite b
+			if (frm.nde.HndTkn() == GfmlTkn_.Null)
+				frm.nde.HndTkn_set(hndTkn);
+			else
+				tknMgr.ExecMakeAtr(GfmlTkn_.Null, hndTkn);
+		}
+		frm.WaitingTkns_AddSym(symTkn, GfmlNdeSymType.Dot);	// REVIEW: may want to dump into differnt nde...
+		frm.tknMgr.ExecXferTkns_ndeBgn(frm.CurNde());
+		oldFrm = frm;								// get oldFrm
+		frm = frm.NewFrame(GfmlNdeStartType.Dot);
+		NdeDot_SetChainId(createPrpNde, oldFrm, frm);
+	}
+	public void NdeParen_bgn(GfmlTkn symTkn) {		// EX: < ( >
+		HndTkn_SetFromDatTkn();
+		WaitingTkns_AddSym(symTkn, GfmlNdeSymType.HdrBgn);	// REVIEW: may want to dump into differnt nde...
+		dotSymCreatesPrpNde = true;
+		frmHasParens = true;
+	}
+	public void NdeParen_end(GfmlTkn symTkn) {		// EX: < ) >
+		tknMgr.ConsumeWaitingDatTkn(bldr.CurNde());
+		WaitingTkns_AddSym(symTkn, GfmlNdeSymType.HdrEnd);
+		dotSymCreatesPrpNde = false;
+		if (!frmHasParens) {
+			bldr.Frames_end();
+			bldr.CurNdeFrame().frmHasParens = false; // does this assume that auto-closing stops at paren node?
+		}
+	}
+	public void AtrSpr(GfmlTkn symTkn) {			// EX: < , > NOTE: proc resembles NdeParen_end
+		tknMgr.ConsumeWaitingDatTkn(bldr.CurNde());
+		WaitingTkns_AddSym(symTkn, GfmlNdeSymType.AtrSpr);
+		if (!frmHasParens) {
+			bldr.Frames_end();
+			GfmlFrame_nde frm = bldr.CurNdeFrame(); // get the current frm after all popped
+			int idx = frm.waitingTkns.Count();		// NOTE: reset idxs b/c endFrame will automatically set to 0, and should be objCount
+			frm.tknMgr.IdxAtrBgn_setHack(idx);
+			frm.tknMgr.IdxNdeBgn_set(idx);
+			frm.nullArea = false;					// NOTE: endFrame automatically sets nullArea to true; set to false
+		}
+	}
+	public void NdeProp_bgn(GfmlTkn symTkn) {		// EX: < [ >
+		int oldNdeBgn = tknMgr.IdxNdeBgn();	// get oldNdeBgn; needed for header atrs; EX: < a:b [d] > ndeBgn = 0 (a pos), but will start keyNde at 5 ([ pos)
+		GfmlTkn keyTkn = tknMgr.KeyTkn_pop(); boolean keyTknExists = keyTkn != GfmlTkn_.Null;
+		int newNdeBgn = keyTknExists ? tknMgr.IdxAtrBgn() : waitingTkns.Count(); // if there is a key, set ndeBgn end atrBgn (EX: a=[); else set end curIdx
+		tknMgr.IdxNdeBgn_set(newNdeBgn);
+		WaitingTkns_AddSym(symTkn, GfmlNdeSymType.PrpBgn);
+		tknMgr.ConsumeWaitingDatTkn(nde);// NEEDED for KeydDefault
+		GfmlFrame_nde frame = NewFrame(GfmlNdeStartType.Prop);
+		tknMgr.IdxNdeBgn_set(oldNdeBgn);	// restore oldNdeBgn
+		if (!keyTknExists) {
+			keyTkn = bldr.TypeMgr().FldPool().Keyed_PopNextAsTkn();
+		}
+		frame.CurNde().KeyTkn_set(keyTkn);
+		bldr.TypeMgr().NdeResolve(frame.CurNde(), ownerTypeKey);
+		frame.nullArea = false;
+	}
+	GfmlFrame_nde NewFrame(int newNdeFrameType) {
+		GfmlDocPos		newPos = docPos.NewDown(subNdeCount++);
+		GfmlNde			newNde = GfmlNde.new_(tknMgr.HndTkn_pop(), GfmlType_.Null, newNdeFrameType == GfmlNdeStartType.Prop).DocPos_(newPos);
+		GfmlFrame_nde	newFrm = GfmlFrame_nde_.node_(bldr, newNde);
+		newFrm.ndeStartType = newNdeFrameType;
+		newFrm.ownerTypeKey = this.CurNde().Type().Key();
+		tknMgr.ExecXferTkns_ndeBgn(newNde);
+		bldr.Frames_push(newFrm);
+		bldr.TypeMgr().NdeBgn(newNde, newFrm.ownerTypeKey);
+		bldr.Doc().PragmaMgr().BgnCmds_exec(newPos, bldr);
+		return newFrm;
+	}
+	@Override public void Build_end(GfmlBldr bldr, GfmlFrame ownerFrame) {
+		GfmlFrame_nde ownerNdeFrame = (GfmlFrame_nde)ownerFrame;
+		tknMgr.ExecXferTkns_ndeAll(nde);
+		bldr.TypeMgr().NdeEnd();
+		bldr.Doc().PragmaMgr().EndCmds_exec(docPos, bldr);
+		bldr.Doc().PragmaMgr().Pragmas_compile(this.CurNde().Hnd(), bldr);
+		if (ownerFrame == null) return; // rootFrame; ignore below
+		ownerNdeFrame.waitingTkns.Add(this.CurNde());
+		int ndeType = this.CurNdeStartType();
+		if (ndeType == GfmlNdeStartType.Dot){ // if i was created by dot, close owner;
+			if (ownerNdeFrame.nde.ChainId() != this.nde.ChainId()) {	// can also be if (nde.ChainHead())
+			}
+			else
+				bldr.Frames_end();	// auto-close dot ndes
+		}
+		else if (ndeType == GfmlNdeStartType.Prop) {}
+		else {
+			ownerNdeFrame.tknMgr.IdxNdeBgn_set(ownerNdeFrame.waitingTkns.Count());
+			ownerNdeFrame.nullArea = true;	// reset
+		}
+	}
+	@Override protected GfmlFrame_base MakeNew_hook() {return new GfmlFrame_nde();}
+	public void IdxNdeBgn_set(int v) {tknMgr.IdxNdeBgn_set(v);}
+	@gplx.Internal protected void WaitingTkns_AddSym(GfmlTkn tkn, int type) {waitingTkns.Add(tkn); bldr.PrvSymType_set(type);}
+	@gplx.Internal protected void HndTkn_SetFromDatTkn() {
+		GfmlTkn hndTkn = tknMgr.DatTkn_pop();
+		if (hndTkn != GfmlTkn_.Null)
+			nde.HndTkn_set(hndTkn);
+	}
+	GfmlTkn HndTkn_GetForDotOp(GfmlFrame_nde frm) {
+		if (bldr.PrvSymType() == GfmlNdeSymType.HdrEnd) return GfmlTkn_.Null; // if prev was ), ignore; EX: a(). does not have hndTkn
+		GfmlTkn hndTkn = frm.tknMgr.DatTkn_pop();
+//			if (hndTkn == GfmlTkn_.Null) bldr.UsrMsgs_fail(GfmlUsrMsgs.fail_DatTkn_notFound());
+		return hndTkn;
+	}
+	void NdeDot_SetChainId(boolean createPrpNde, GfmlFrame_nde oldFrm, GfmlFrame_nde frm) {
+		if (createPrpNde)							// prpNde; make sure new dotNde gets same chainId
+			frm.nde.ChainId_(oldFrm.nde.ChainId());
+		else {										// oldNde is dotNde
+			if (oldFrm.ndeStartType == GfmlNdeStartType.Dot)	// oldNde is dotNde; just take oldNde's chainId; ex: a.b.c
+				frm.nde.ChainId_(oldFrm.nde.ChainId());
+			else {									// oldNde is something else
+				int chainId = bldr.ChainIdNext();
+				oldFrm.nde.ChainId_(chainId);		// NOTE: needed for auto-closing; EX: {a.b;} a is a DatTkn nde, but needs to be closed when b is closed
+				frm.nde.ChainId_(chainId);
+			}
+		}
+	}
+	GfmlBldr bldr; GfmlFrame_ndeTknMgr tknMgr; int subNdeCount = 0; String ownerTypeKey; boolean frmHasParens = false; boolean dotSymCreatesPrpNde = false;
+	public static GfmlFrame_nde new_(GfmlBldr bldr, GfmlNde newNde, GfmlLxr newLxr) {
+		GfmlFrame_nde rv = new GfmlFrame_nde();
+		rv.bldr = bldr;
+		rv.ctor_(newLxr);
+		rv.tknMgr = GfmlFrame_ndeTknMgr.new_(rv, bldr);
+		rv.nde = newNde;
+		rv.docPos = newNde.DocPos();
+		return rv;
+	}
+}
+class GfmlFrame_nde_ {
+	public static GfmlFrame_nde as_(Object obj) {return obj instanceof GfmlFrame_nde ? (GfmlFrame_nde)obj : null;}
+	public static GfmlFrame_nde node_(GfmlBldr bldr, GfmlNde newNde) {return GfmlFrame_nde.new_(bldr, newNde, bldr.CurFrame().Lxr());}
+	@gplx.Internal protected static GfmlFrame_nde root_(GfmlBldr bldr, GfmlNde newNde, GfmlLxr newLxr) {return GfmlFrame_nde.new_(bldr, newNde, newLxr);}
+	@gplx.Internal protected static final GfmlFrame_nde OwnerRoot_ = null;
+	@gplx.Internal protected static void TransferToNde(GfmlObjList waitingTkns, GfmlNde nde, int bgn) {
+		int end = waitingTkns.Count();
+		for (int i = bgn; i < end; i++) {
+			GfmlObj tkn = waitingTkns.Get_at(i);
+			nde.SubObjs_Add(tkn);
+		}
+		if (bgn != end) // ignore if bgn == end
+			waitingTkns.Del_range(bgn, end - 1);
+	}
+	@gplx.Internal protected static void TransferToAtr(GfmlObjList src, GfmlAtr trg, int bgn, int end) {
+		int len = end - bgn;
+		if (len <= 0 || end == -1) return;	// -1 b/c calling proc passes end - 1, and end may be 0
+		for (int i = 0; i < len; i++)
+			trg.SubObjs_Add(src.Get_at(i + bgn));
+		src.Del_range(bgn, end - 1);
+	}		
+}
+class GfmlNdeStartType {
+	public static final int
+			  Hnd			= 1			// a:
+			, Brace			= 2			// {	// has no header (since header would have created node first)
+			, DatTkn		= 3			// c;	// has no hnd
+			, Inline		= 4			// ;	// is empty (since something would have created node first)
+			, Dot			= 5			// a.b;
+			, Prop			= 6			// a=[b c];
+			;
+}
+class GfmlNdeSymType {
+	public static final int
+		  Null		=  0
+		, BodyBgn	=  1 // {
+		, BodyEnd	=  2 // }
+		, Inline	=  3 // ;
+		, Key		=  4 // =
+		, Hnd		=  5 // :
+		, Dot		=  6 // .
+		, HdrBgn	=  7 // (
+		, HdrEnd	=  8 // )
+		, PrpBgn	=  9 // [
+		, PrpEnd	= 10 // ]
+		, AtrSpr	= 11 // ,	
+		;
+}

110_gfml/src_500_build/gplx/gfml/GfmlFrame_ndeTknMgr.java

@@ -0,0 +1,90 @@
+/*
+XOWA: the XOWA Offline Wiki Application
+Copyright (C) 2012 gnosygnu@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package gplx.gfml; import gplx.*;
+class GfmlFrame_ndeTknMgr {		
+	public int IdxAtrBgn() {return idxAtrBgn;} int idxAtrBgn, idxAtrEnd;
+	public int IdxNdeBgn() {return idxNdeBgn;} public void IdxNdeBgn_set(int v) {idxNdeBgn = v;} int idxNdeBgn = 0;
+	void IdxAtr_clear() {idxAtrBgn = 0; idxAtrEnd = -1;}
+	@gplx.Internal protected void IdxAtrBgn_setHack(int v) {idxAtrBgn = v; idxAtrEnd = v + 1;}
+	@gplx.Internal protected void IdxNdeBgn_setToAtrBgn() {
+		if (idxAtrEnd == -1) return;
+		idxNdeBgn = idxAtrBgn;
+		this.IdxAtr_clear();	// newNode starting; old atr range no longer valid
+	}
+	public GfmlTkn HndTkn_pop() {GfmlTkn rv = hndTkn; hndTkn = GfmlTkn_.Null; return rv;} GfmlTkn hndTkn = GfmlTkn_.Null;
+	public void HndTkn_setByDatTkn() {
+		if (datTkn == GfmlTkn_.Null) return;
+		hndTkn = DatTkn_pop();
+	}
+	@gplx.Internal protected void HndTkn_setByDatTknOrFail() {
+		if (datTkn == GfmlTkn_.Null) {bldr.UsrMsgs_fail(GfmlUsrMsgs.fail_DatTkn_notFound()); return;}		// ex: < : >
+		if (hndTkn != GfmlTkn_.Null) {bldr.UsrMsgs_fail(GfmlUsrMsgs.fail_HndTkn_alreadyExists()); return;}	// ex: < a:b: >
+		hndTkn = DatTkn_pop();
+	}		
+	public GfmlTkn KeyTkn_pop() {GfmlTkn rv = keyTkn; keyTkn = GfmlTkn_.Null; return rv;} GfmlTkn keyTkn = GfmlTkn_.Null;
+	public void KeyTkn_setByDatTkn() {
+		if (datTkn == GfmlTkn_.Null) return;
+		keyTkn = DatTkn_pop();
+	}
+	public void KeyTkn_setFromDataTknOrFail() {
+		if (datTkn == GfmlTkn_.Null) {bldr.UsrMsgs_fail(GfmlUsrMsgs.fail_DatTkn_notFound()); return;}		// ex: < = >
+		if (keyTkn != GfmlTkn_.Null) {bldr.UsrMsgs_fail(GfmlUsrMsgs.fail_KeyTkn_alreadyExists()); return;}	// ex: < a=[b=] >
+		keyTkn = DatTkn_pop();
+	}
+	@gplx.Internal protected GfmlTkn DatTkn_pop() {GfmlTkn rv = datTkn; datTkn = GfmlTkn_.Null; return rv;} GfmlTkn datTkn = GfmlTkn_.Null;
+	@gplx.Internal protected void DatTkn_set(GfmlTkn tkn) {
+		this.ConsumeWaitingDatTkn(frame.CurNde());
+		idxAtrBgn = frame.waitingTkns.Count();
+		idxAtrEnd = idxAtrBgn + 1;
+		frame.waitingTkns.Add(tkn);
+		datTkn = tkn;
+	}
+	@gplx.Internal protected void ExecMakeAtr(GfmlTkn itmKeyTkn, GfmlTkn valTkn) {
+		frame.waitingTkns.Add(valTkn);
+		idxAtrEnd = frame.waitingTkns.Count();
+		this.MakeAtr(itmKeyTkn, valTkn);
+	}
+	@gplx.Internal protected void ExecXferTkns_ndeAll(GfmlNde nde) {ExecXferTkns(nde, 0);}
+	@gplx.Internal protected void ExecXferTkns_ndeBgn(GfmlNde nde) {ExecXferTkns(nde, this.IdxNdeBgn());}
+	void ExecXferTkns(GfmlNde nde, int from) {
+		this.ConsumeWaitingDatTkn(nde);
+		GfmlFrame_nde_.TransferToNde(frame.waitingTkns, nde, from);
+	}
+	@gplx.Internal protected void ConsumeWaitingDatTkn(GfmlNde nde) {
+		if (datTkn == GfmlTkn_.Null) return;			// no datTkn; return;
+		if (	bldr.CurNdeFrame().CurNdeStartType() == GfmlNdeStartType.Dot
+			&&	String_.Len_eq_0(nde.Hnd()))		// if cur hnd is empty, use datTkn for hndTkn
+				frame.HndTkn_SetFromDatTkn();
+		else
+			this.MakeAtr(GfmlTkn_.Null, this.DatTkn_pop());
+	}
+	void MakeAtr(GfmlTkn k, GfmlTkn v) {
+		if (k == GfmlTkn_.Null) 
+			k = bldr.TypeMgr().FldPool().Keyed_PopNextAsTkn();
+		GfmlAtr atr = GfmlAtr.string_(k, v);
+		GfmlFrame_nde_.TransferToAtr(frame.waitingTkns, atr, idxAtrBgn, idxAtrEnd);
+		frame.waitingTkns.Add_at(atr, idxAtrBgn);
+		this.IdxAtr_clear();
+	}
+	GfmlFrame_nde frame; GfmlBldr bldr;
+	public static GfmlFrame_ndeTknMgr new_(GfmlFrame_nde frame, GfmlBldr bldr) {
+		GfmlFrame_ndeTknMgr rv = new GfmlFrame_ndeTknMgr();
+		rv.frame = frame; rv.bldr = bldr;
+		return rv;
+	}	GfmlFrame_ndeTknMgr() {}
+}

110_gfml/src_500_build/gplx/gfml/GfmlStringHighlighter.java

@@ -0,0 +1,103 @@
+/*
+XOWA: the XOWA Offline Wiki Application
+Copyright (C) 2012 gnosygnu@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package gplx.gfml; import gplx.*;
+import gplx.core.strings.*;
+class GfmlStringHighlighter {
+	public String Raw() {return raw;} public GfmlStringHighlighter Raw_(String v) {raw = v; return this;} private String raw;
+	public int ExcerptLen() {return excerptLen;} public GfmlStringHighlighter ExcerptLen_(int v) {excerptLen = v; return this;} int excerptLen = 40;
+	public GfmlStringHighlighter Mark_(int pos, char c, String msg) {
+		marks.Add(new GfmlStringHighlighterMarker().Pos_(pos).Sym_(c).Msg_(msg));
+		return this;
+	}
+	int XtoBgnPos(int pos, int prvEndPos) {
+		int rv = pos - excerptLen;
+		if (rv < prvEndPos) rv = prvEndPos;	 // ensure bgnPos is not < prev end pos; ex: marks of 5,12; at 12, bgnPos = 2 which is less than 5; make 5
+		return rv;
+	}
+	public String[] Gen() {
+		String_bldr posBfr = String_bldr_.new_(), rawBfr = String_bldr_.new_(), symBfr = String_bldr_.new_();
+		List_adp symList = List_adp_.new_();
+		int bgnPos = 0, endPos = 0;
+		int rawLen = String_.Len(raw); int rawLenDigits = Int_.DigitCount(rawLen);
+		int rawBfrBgn = -1, marksLastIdx = marks.Idx_last();
+		for (int i = 0; i < marks.Count(); i++) {
+			GfmlStringHighlighterMarker curMark = (GfmlStringHighlighterMarker)marks.Get_at(i);
+			GfmlStringHighlighterMarker nxtMark = i == marksLastIdx ? GfmlStringHighlighterMarker.Null : (GfmlStringHighlighterMarker)marks.Get_at(i + 1);
+			// bgnPos
+			bgnPos = XtoBgnPos(curMark.Pos(), endPos);
+			if (i == 0) rawBfrBgn = bgnPos;
+
+			// endPos
+			int nxtMarkPos = nxtMark == GfmlStringHighlighterMarker.Null ? Int_.MaxValue : nxtMark.Pos();
+			endPos = curMark.Pos() + excerptLen;
+			if (endPos >= nxtMarkPos) endPos = nxtMarkPos;
+			if (endPos > rawLen ) endPos = rawLen + 1;
+
+			// build bfrs
+			for (int j = bgnPos; j < endPos; j++) {
+				char rawChar = j == rawLen ? ' ' : String_.CharAt(raw, j);
+				if		(rawChar == '\t') {posBfr.Add("t"); rawBfr.Add(" ");}
+				else if (rawChar == '\n') {posBfr.Add("n"); rawBfr.Add(" ");}
+				else				{
+					char posChar = j == rawLen ? '>' : ' ';
+					posBfr.Add(posChar);
+					rawBfr.Add(rawChar);
+				}
+				char symChar = j == curMark.Pos() ? curMark.Sym() : ' ';
+				symBfr.Add(symChar);
+			}
+
+			// gap
+			int nxtMarkBgn = XtoBgnPos(nxtMark.Pos(), endPos);
+			int gap = nxtMarkBgn - endPos;
+			if (gap > 0) {
+				int gapDigits = Int_.DigitCount(gap);
+				posBfr.Add_fmt("[{0}]", Int_.Xto_str_pad_bgn_zero(gap, gapDigits));
+				rawBfr.Add_fmt("[{0}]", String_.Repeat(".", gapDigits));
+				symBfr.Add_fmt(" {0} ", String_.Repeat(" ", gapDigits));
+			}
+			if (curMark.Sym() != ' ')
+				symList.Add(String_.Format("[{0}] {1} {2}", Int_.Xto_str_pad_bgn_zero(curMark.Pos(), rawLenDigits), curMark.Sym(), curMark.Msg()));
+		}
+		if (rawBfrBgn == 0) {
+			posBfr.Add_at(0, "<");
+			rawBfr.Add_at(0, " ");
+			symBfr.Add_at(0, " ");
+		}
+		List_adp rv = List_adp_.new_();
+		rv.Add(posBfr.XtoStr());
+		rv.Add(rawBfr.XtoStr());
+		rv.Add(symBfr.XtoStr());
+		if (symList.Count() > 0)
+			rv.Add("");
+		for (int i = 0; i < symList.Count(); i++)
+			rv.Add((String)symList.Get_at(i));
+		return rv.To_str_ary();
+	}
+	List_adp marks = List_adp_.new_();
+        public static GfmlStringHighlighter new_() {
+		GfmlStringHighlighter rv = new GfmlStringHighlighter();
+		return rv;
+	}	GfmlStringHighlighter() {}
+}
+class GfmlStringHighlighterMarker {
+	public int Pos() {return pos;} public GfmlStringHighlighterMarker Pos_(int v) {pos = v; return this;} int pos;
+	public char Sym() {return sym;} public GfmlStringHighlighterMarker Sym_(char v) {sym = v; return this;} char sym;
+	public String Msg() {return msg;} public GfmlStringHighlighterMarker Msg_(String v) {msg = v; return this;} private String msg;
+	public static final GfmlStringHighlighterMarker Null = new GfmlStringHighlighterMarker().Pos_(-1);
+}