mirror of
https://github.com/gnosygnu/xowa.git
synced 2026-03-02 03:49:30 +00:00
Embeddable: Create core dbs in proper subdirectory
This commit is contained in:
gnosygnu
@@ -1,72 +0,0 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012-2017 gnosygnu@gmail.com
|
||||
|
||||
XOWA is licensed under the terms of the General Public License (GPL) Version 3,
|
||||
or alternatively under the terms of the Apache License Version 2.0.
|
||||
|
||||
You may use XOWA according to either of these licenses as is most appropriate
|
||||
for your project on a case-by-case basis.
|
||||
|
||||
The terms of each license can be found in the source code repository:
|
||||
|
||||
GPLv3 License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-GPLv3.txt
|
||||
Apache License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-APACHE2.txt
|
||||
*/
|
||||
package gplx.gfml; import gplx.*;
|
||||
import gplx.core.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 = "";
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012-2017 gnosygnu@gmail.com
|
||||
|
||||
XOWA is licensed under the terms of the General Public License (GPL) Version 3,
|
||||
or alternatively under the terms of the Apache License Version 2.0.
|
||||
|
||||
You may use XOWA according to either of these licenses as is most appropriate
|
||||
for your project on a case-by-case basis.
|
||||
|
||||
The terms of each license can be found in the source code repository:
|
||||
|
||||
GPLv3 License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-GPLv3.txt
|
||||
Apache License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-APACHE2.txt
|
||||
*/
|
||||
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.Instance);
|
||||
rv.Add(GfmlBldrCmd_dataTkn_set.Instance);
|
||||
return rv;
|
||||
} GfmlBldrCmdRegy() {}
|
||||
}
|
||||
@@ -1,126 +0,0 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012-2017 gnosygnu@gmail.com
|
||||
|
||||
XOWA is licensed under the terms of the General Public License (GPL) Version 3,
|
||||
or alternatively under the terms of the Apache License Version 2.0.
|
||||
|
||||
You may use XOWA according to either of these licenses as is most appropriate
|
||||
for your project on a case-by-case basis.
|
||||
|
||||
The terms of each license can be found in the source code repository:
|
||||
|
||||
GPLv3 License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-GPLv3.txt
|
||||
Apache License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-APACHE2.txt
|
||||
*/
|
||||
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 Instance = 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 Instance = 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 Instance = 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 Instance = 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 Instance = 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 Instance = 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 Instance = 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 Instance = 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 Instance = 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 Instance = 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 Instance = 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 Instance = new GfmlBldrCmd_whitespace(); GfmlBldrCmd_whitespace() {}
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012-2017 gnosygnu@gmail.com
|
||||
|
||||
XOWA is licensed under the terms of the General Public License (GPL) Version 3,
|
||||
or alternatively under the terms of the Apache License Version 2.0.
|
||||
|
||||
You may use XOWA according to either of these licenses as is most appropriate
|
||||
for your project on a case-by-case basis.
|
||||
|
||||
The terms of each license can be found in the source code repository:
|
||||
|
||||
GPLv3 License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-GPLv3.txt
|
||||
Apache License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-APACHE2.txt
|
||||
*/
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012-2017 gnosygnu@gmail.com
|
||||
|
||||
XOWA is licensed under the terms of the General Public License (GPL) Version 3,
|
||||
or alternatively under the terms of the Apache License Version 2.0.
|
||||
|
||||
You may use XOWA according to either of these licenses as is most appropriate
|
||||
for your project on a case-by-case basis.
|
||||
|
||||
The terms of each license can be found in the source code repository:
|
||||
|
||||
GPLv3 License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-GPLv3.txt
|
||||
Apache License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-APACHE2.txt
|
||||
*/
|
||||
package gplx.gfml; import gplx.*;
|
||||
import gplx.core.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() {}
|
||||
}
|
||||
@@ -1,85 +0,0 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012-2017 gnosygnu@gmail.com
|
||||
|
||||
XOWA is licensed under the terms of the General Public License (GPL) Version 3,
|
||||
or alternatively under the terms of the Apache License Version 2.0.
|
||||
|
||||
You may use XOWA according to either of these licenses as is most appropriate
|
||||
for your project on a case-by-case basis.
|
||||
|
||||
The terms of each license can be found in the source code repository:
|
||||
|
||||
GPLv3 License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-GPLv3.txt
|
||||
Apache License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-APACHE2.txt
|
||||
*/
|
||||
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 Err_.new_wo_type("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);
|
||||
}
|
||||
}
|
||||
@@ -1,248 +0,0 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012-2017 gnosygnu@gmail.com
|
||||
|
||||
XOWA is licensed under the terms of the General Public License (GPL) Version 3,
|
||||
or alternatively under the terms of the Apache License Version 2.0.
|
||||
|
||||
You may use XOWA according to either of these licenses as is most appropriate
|
||||
for your project on a case-by-case basis.
|
||||
|
||||
The terms of each license can be found in the source code repository:
|
||||
|
||||
GPLv3 License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-GPLv3.txt
|
||||
Apache License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-APACHE2.txt
|
||||
*/
|
||||
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 // ,
|
||||
;
|
||||
}
|
||||
@@ -1,88 +0,0 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012-2017 gnosygnu@gmail.com
|
||||
|
||||
XOWA is licensed under the terms of the General Public License (GPL) Version 3,
|
||||
or alternatively under the terms of the Apache License Version 2.0.
|
||||
|
||||
You may use XOWA according to either of these licenses as is most appropriate
|
||||
for your project on a case-by-case basis.
|
||||
|
||||
The terms of each license can be found in the source code repository:
|
||||
|
||||
GPLv3 License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-GPLv3.txt
|
||||
Apache License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-APACHE2.txt
|
||||
*/
|
||||
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() {}
|
||||
}
|
||||
@@ -1,101 +0,0 @@
|
||||
/*
|
||||
XOWA: the XOWA Offline Wiki Application
|
||||
Copyright (C) 2012-2017 gnosygnu@gmail.com
|
||||
|
||||
XOWA is licensed under the terms of the General Public License (GPL) Version 3,
|
||||
or alternatively under the terms of the Apache License Version 2.0.
|
||||
|
||||
You may use XOWA according to either of these licenses as is most appropriate
|
||||
for your project on a case-by-case basis.
|
||||
|
||||
The terms of each license can be found in the source code repository:
|
||||
|
||||
GPLv3 License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-GPLv3.txt
|
||||
Apache License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-APACHE2.txt
|
||||
*/
|
||||
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_.Max_value : 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_.To_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_.To_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.To_str());
|
||||
rv.Add(rawBfr.To_str());
|
||||
rv.Add(symBfr.To_str());
|
||||
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);
|
||||
}
|
||||
Reference in New Issue
Block a user