From 8649ab7d767302801d8b7db09fb2302a2c23b044 Mon Sep 17 00:00:00 2001 From: Liam Galvin Date: Thu, 9 Aug 2018 14:59:19 +0100 Subject: [PATCH] fix deletion on wrapped line --- Gopkg.lock | 16 +- buffer/buffer.go | 12 +- buffer/buffer_test.go | 27 + fonts/FSEX300.ttf | Bin 0 -> 575668 bytes fonts/envypn-15.ttf | Bin 0 -> 14876 bytes gui/gui.go | 18 +- gui/renderer.go | 4 +- terminal/{escapes.go => output.go} | 0 vendor/github.com/BurntSushi/toml/.gitignore | 5 + vendor/github.com/BurntSushi/toml/.travis.yml | 15 + vendor/github.com/BurntSushi/toml/COMPATIBLE | 3 + vendor/github.com/BurntSushi/toml/COPYING | 14 + vendor/github.com/BurntSushi/toml/Makefile | 19 + vendor/github.com/BurntSushi/toml/README.md | 218 ++ .../toml/cmd/toml-test-decoder/COPYING | 14 + .../toml/cmd/toml-test-encoder/COPYING | 14 + .../BurntSushi/toml/cmd/tomlv/COPYING | 14 + vendor/github.com/BurntSushi/toml/decode.go | 509 ++++ .../github.com/BurntSushi/toml/decode_meta.go | 121 + vendor/github.com/BurntSushi/toml/doc.go | 27 + vendor/github.com/BurntSushi/toml/encode.go | 568 ++++ .../BurntSushi/toml/encoding_types.go | 19 + .../BurntSushi/toml/encoding_types_1.1.go | 18 + vendor/github.com/BurntSushi/toml/lex.go | 953 ++++++ vendor/github.com/BurntSushi/toml/parse.go | 592 ++++ vendor/github.com/BurntSushi/toml/session.vim | 1 + .../github.com/BurntSushi/toml/type_check.go | 91 + .../github.com/BurntSushi/toml/type_fields.go | 242 ++ vendor/github.com/liamg/glfont/font.go | 3 - vendor/gopkg.in/yaml.v2/.travis.yml | 12 - vendor/gopkg.in/yaml.v2/LICENSE | 201 -- vendor/gopkg.in/yaml.v2/LICENSE.libyaml | 31 - vendor/gopkg.in/yaml.v2/NOTICE | 13 - vendor/gopkg.in/yaml.v2/README.md | 133 - vendor/gopkg.in/yaml.v2/apic.go | 739 ----- vendor/gopkg.in/yaml.v2/decode.go | 775 ----- vendor/gopkg.in/yaml.v2/emitterc.go | 1685 ----------- vendor/gopkg.in/yaml.v2/encode.go | 362 --- vendor/gopkg.in/yaml.v2/go.mod | 5 - vendor/gopkg.in/yaml.v2/parserc.go | 1095 ------- vendor/gopkg.in/yaml.v2/readerc.go | 412 --- vendor/gopkg.in/yaml.v2/resolve.go | 258 -- vendor/gopkg.in/yaml.v2/scannerc.go | 2696 ----------------- vendor/gopkg.in/yaml.v2/sorter.go | 113 - vendor/gopkg.in/yaml.v2/writerc.go | 26 - vendor/gopkg.in/yaml.v2/yaml.go | 466 --- vendor/gopkg.in/yaml.v2/yamlh.go | 738 ----- vendor/gopkg.in/yaml.v2/yamlprivateh.go | 173 -- 48 files changed, 3509 insertions(+), 9961 deletions(-) create mode 100644 fonts/FSEX300.ttf create mode 100644 fonts/envypn-15.ttf rename terminal/{escapes.go => output.go} (100%) create mode 100644 vendor/github.com/BurntSushi/toml/.gitignore create mode 100644 vendor/github.com/BurntSushi/toml/.travis.yml create mode 100644 vendor/github.com/BurntSushi/toml/COMPATIBLE create mode 100644 vendor/github.com/BurntSushi/toml/COPYING create mode 100644 vendor/github.com/BurntSushi/toml/Makefile create mode 100644 vendor/github.com/BurntSushi/toml/README.md create mode 100644 vendor/github.com/BurntSushi/toml/cmd/toml-test-decoder/COPYING create mode 100644 vendor/github.com/BurntSushi/toml/cmd/toml-test-encoder/COPYING create mode 100644 vendor/github.com/BurntSushi/toml/cmd/tomlv/COPYING create mode 100644 vendor/github.com/BurntSushi/toml/decode.go create mode 100644 vendor/github.com/BurntSushi/toml/decode_meta.go create mode 100644 vendor/github.com/BurntSushi/toml/doc.go create mode 100644 vendor/github.com/BurntSushi/toml/encode.go create mode 100644 vendor/github.com/BurntSushi/toml/encoding_types.go create mode 100644 vendor/github.com/BurntSushi/toml/encoding_types_1.1.go create mode 100644 vendor/github.com/BurntSushi/toml/lex.go create mode 100644 vendor/github.com/BurntSushi/toml/parse.go create mode 100644 vendor/github.com/BurntSushi/toml/session.vim create mode 100644 vendor/github.com/BurntSushi/toml/type_check.go create mode 100644 vendor/github.com/BurntSushi/toml/type_fields.go delete mode 100644 vendor/gopkg.in/yaml.v2/.travis.yml delete mode 100644 vendor/gopkg.in/yaml.v2/LICENSE delete mode 100644 vendor/gopkg.in/yaml.v2/LICENSE.libyaml delete mode 100644 vendor/gopkg.in/yaml.v2/NOTICE delete mode 100644 vendor/gopkg.in/yaml.v2/README.md delete mode 100644 vendor/gopkg.in/yaml.v2/apic.go delete mode 100644 vendor/gopkg.in/yaml.v2/decode.go delete mode 100644 vendor/gopkg.in/yaml.v2/emitterc.go delete mode 100644 vendor/gopkg.in/yaml.v2/encode.go delete mode 100644 vendor/gopkg.in/yaml.v2/go.mod delete mode 100644 vendor/gopkg.in/yaml.v2/parserc.go delete mode 100644 vendor/gopkg.in/yaml.v2/readerc.go delete mode 100644 vendor/gopkg.in/yaml.v2/resolve.go delete mode 100644 vendor/gopkg.in/yaml.v2/scannerc.go delete mode 100644 vendor/gopkg.in/yaml.v2/sorter.go delete mode 100644 vendor/gopkg.in/yaml.v2/writerc.go delete mode 100644 vendor/gopkg.in/yaml.v2/yaml.go delete mode 100644 vendor/gopkg.in/yaml.v2/yamlh.go delete mode 100644 vendor/gopkg.in/yaml.v2/yamlprivateh.go diff --git a/Gopkg.lock b/Gopkg.lock index 3673433..2e8b7ea 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -1,6 +1,12 @@ # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. +[[projects]] + name = "github.com/BurntSushi/toml" + packages = ["."] + revision = "b26d9c308763d68093482582cea63d69be07a0f0" + version = "v0.3.0" + [[projects]] name = "github.com/davecgh/go-spew" packages = ["spew"] @@ -33,7 +39,7 @@ branch = "master" name = "github.com/liamg/glfont" packages = ["."] - revision = "1409aed3c17da6d28f211c5e5c52e879abb32fbf" + revision = "d24783da55c81fd75c8e7c0897ee3f7d336f8b44" [[projects]] name = "github.com/pmezard/go-difflib" @@ -90,15 +96,9 @@ ] revision = "c73c2afc3b812cdd6385de5a50616511c4a3d458" -[[projects]] - name = "gopkg.in/yaml.v2" - packages = ["."] - revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183" - version = "v2.2.1" - [solve-meta] analyzer-name = "dep" analyzer-version = 1 - inputs-digest = "2ba92df49de7d74abb3a647555d24d1d872cfee4812e7250fa7d49fb23872053" + inputs-digest = "0b3960a1d15048ccc49c41464fdb2346062f791ca53d614d4535d2930d4969f5" solver-name = "gps-cdcl" solver-version = 1 diff --git a/buffer/buffer.go b/buffer/buffer.go index 3a53a3b..1a2d12d 100644 --- a/buffer/buffer.go +++ b/buffer/buffer.go @@ -183,21 +183,28 @@ func (buffer *Buffer) incrementCursorPosition() { } func (buffer *Buffer) Backspace() { + if buffer.cursorX == 0 { line := buffer.getCurrentLine() if line.wrapped { buffer.MovePosition(int16(buffer.Width()-1), -1) + line := buffer.getCurrentLine() if int(buffer.cursorX) < len(line.cells) { + fmt.Printf("Deleting (end) %s\n", string(line.cells[buffer.cursorX].Rune())) line.cells[buffer.cursorX].erase() } } else { //@todo ring bell or whatever + fmt.Println("BELL?") } } else { buffer.MovePosition(-1, 0) line := buffer.getCurrentLine() if int(buffer.cursorX) < len(line.cells) { + fmt.Printf("Deleting %s\n", string(line.cells[buffer.cursorX].Rune())) line.cells[buffer.cursorX].erase() + } else { + fmt.Println("Wat?") } } } @@ -324,11 +331,6 @@ func (buffer *Buffer) EraseLineFromCursor() { defer buffer.emitDisplayChange() line := buffer.getCurrentLine() - if line.wrapped && buffer.cursorX == 0 { - //panic("wtf") - return - } - max := int(buffer.cursorX) if max > len(line.cells) { max = len(line.cells) diff --git a/buffer/buffer_test.go b/buffer/buffer_test.go index fcfa219..06825df 100644 --- a/buffer/buffer_test.go +++ b/buffer/buffer_test.go @@ -403,3 +403,30 @@ func TestEraseDisplayFromCursor(t *testing.T) { assert.Equal(t, "asd", lines[1].String()) assert.Equal(t, "", lines[2].String()) } +func TestBackspace(t *testing.T) { + b := NewBuffer(80, 5, CellAttributes{}) + b.Write([]rune("hello")...) + b.Backspace() + b.Backspace() + b.Write([]rune("l")...) + lines := b.GetVisibleLines() + assert.Equal(t, "hell", lines[0].String()) +} + +func TestBackspaceWithWrap(t *testing.T) { + b := NewBuffer(10, 5, CellAttributes{}) + b.Write([]rune("hellohellohello")...) + b.Backspace() + b.Backspace() + b.Backspace() + b.Backspace() + b.Backspace() + b.Backspace() + b.Backspace() + b.Backspace() + b.Backspace() + b.Backspace() + lines := b.GetVisibleLines() + assert.Equal(t, "hello\x00\x00\x00\x00\x00", lines[0].String()) + assert.Equal(t, "\x00\x00\x00\x00\x00", lines[1].String()) +} diff --git a/fonts/FSEX300.ttf b/fonts/FSEX300.ttf new file mode 100644 index 0000000000000000000000000000000000000000..a4f177c41a894b87a0175d2d68e730aa2f742700 GIT binary patch literal 575668 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 c>67WW~=|^ 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

(uoe0-<-a(fWkoKH%0Xu=5cB^Ty4cPnW)_ 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

*9?or6L$ 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

@Nd6mx40zf{!BdBiz{ASQ+JGHe0LP}r zHgG7@n`p>y*qjrqjA~`gdXCkZq}1IhKI;zOGKa~wiP!_t{CB%#!q-fVFJiR1hVl)u<132!%r}VR$N!H|0Tdw)&y|<&YJu~|ayjk#wi{5NFqU}I(uQ-+pGe63sNBs_t zAQg4Dvpp`i-8{h$nXVY>-kPdO!_?qv{@t1tSF;}Mcxh81E!CzgXR)W-1o~=qgImo5F z2ftQBF=L}bwge(GDh22Q#sT~dfw%0;P=`Ks5!z0rQEag-Myj4|c|p-*4%MCvc5ox1 zrU*2UkWMxUBeOP{1t$&o>%;`d?Ul~>Q|HD)IB5r)jLL%L?-j4|RxKB$`dBv(uqW4w z&5e}=ygP#m^VqQCymR-P6bA=zPgPq*Ee+kla7EWiZe@GI#1U^9Jw|Ge*WN1>1h&-r z8vhW!-*@Ukg63x%+WnMrOdQ%{m(FdOs>ub~$0|3<%d2la~Hrdx)=o+cb?S9szUD~sb z?L~2MwP|290iJL;ny{%Z6N2tCB;HFOW=OB$NS&loP&IJoS&w{1(nE zxqu9*@eh_Tr?|+wYfUXQH1{>GIsJ@HG*5#?=)3JIL0@VN3DS&Mg3vSKB(rPx1;$>( z&@BVMHbBYw%P(ilbb1pDceY?wZ40aNd=5Q+6Iq2E@dg_^Bq%azH-NfF#wM!H^tSr~ zd%t*|=6c3oxM_UP8?(p6Ip2?*w%?XQ<-YjeS>|-Pj?j@m@~*MM`)#avMmF|&v)Vtr z7vDvb+}refY$$3eq!9#7HVENgk(4mXz|^+m9ch5}cxZk$(Xi$gRXlB}fD3FV{)YGY z++|Sw^S!W2#_;Yw)e#gPw#_NvzVto4;Z@rkwzVoNzs0BEWGtxUE~_hwR^Apnu71@~ zs%LtZCj^{)b9hq1?t^D68C=K=6v3VMW=?g|z+_oE2NuVck2ztD`9y|e%gD2I*c3P} zQ~V8UYH3kmxPyes9maMZ^7xxXg)=Uv)}j{2ZobdHocev?)Ho4N!2VhhHvt#u5BZW((YnNe|qV(lRYSi12rFSa%eifgci-FVA<<>nJxj`stU z6lYGPbnqJ9{Cs0e%zqvXut|_dA!v`)RF&UNJNzk`(eoY=?b(=mG#(Z%dp|h#Tue;U zAA&RR$xzw4`}WNGCSzRfj(jGCg*}(l_9|j-cJV}fyh=}Efa1W_5|Tz|cEU3gNmJ_d z>Clz=SdB^d%3A0qEz3C%jRDA~!o=Q@3*2&$9=WK6Y-CaE7(OO8R#mEFRj^cK*f0%H z@*riUu-x(9p8T}=r8U0uoW6B&g6j14QI66<8|*1Dj}{mp;v7*02eOu=mSvixcHY|C z=T~_c`>Od}ldGf`BO_MpX5^qSh%=o9ZxodYHhD1G3EPO83}uf2Q%9ftvOF_VS$G+_ zJ;IH6GA2TjMY}lc$Z)C`XZ(y#rV6RDSALvo(-;?yV1Nx!3rBEfqlmbwA5n9Krd>Ga zC3pmE{EQ7OS_v4m?O@d~p|@L!=?cZ(SJ5~6UVLwKR@2c2yNb@ri0~baqCJCVG_Dey z7=%;;x9WHki@%;83jAYM6$6W_J8@&z14L+7uJwPgtFP9B17NWQZMZF~2frRD!UntG zKjGPIj&D{iX`d}PmYY^txOzusy|uQL8Nn6MYB^%#8&Q{@L-Y=F+yTwVY69@C^Szx^ z=SG(F58MZ4TIPLS1EFJ>LZ-)qaP+kq8?SrsDq8edfY9c?pMj=A)hX(X)JeCs6=Frc z8h^|VjeA8~Lp;(3eNb4D?uOYaI6sszp&t&7D(g!Lu**Q)nX$ zaE(t|3*W8Ram@`ESkRmHE9$nhe18tU^iL2Dm}pJxDHL}GU^$LCt5&F@QZ@59YwoaZ z%R2j6M!+KuG~4a3X!&7sTh`19Pw+8;p93Hj#|szT02}q>+-SG7D|^i|Gu-86aM7YH z7<1=n*oq$t8P9qB8jg%JnHGvws;PV0$C(2?k$BdMcmN;9;6sZT-jv_$%T%k8Z7ru!k|g~USFv3{$mABq-T8Ybc~$Cu_7!%f|(uu7ru#jb>}EtPv2z5 ziB}D_eU`lpd_Sl4-fRYZAmSfICXWZ`S1vSY_K}B!+l^h z72Df%_HgdHbpZGgps6?^JQNP0 zHw#IQG~&&79`caZTxle$=5zAtv9!#3HpuES8v|rIw!=^&g}kO<0By{ zHfaNrTx~;X z|E4ck_A`~N=Ad;Pe9w6om)x{pfCbm-HVDx8h=howB3h?83TFmg!w907~Xw{i;b#dzVTC5hL`>RK=l2 z+m(`)8s#ZWgMP>uNs6fsY0M`Vg-Y++EBEG#nWp|sG0N0U+$^YoX&&tk~ zg{@()||dmssf(Y65*N`4VV zk&IVojALZ+?ks}tdqDB3u4s@{CvRwO3smc!yCM3J|rtIvekVRH5$5)HEhp(*6!n)>8XS4RI6xQzl?RZ zJVFgWMk8qG3HwOiXbOJ+(?@M_XspuA*VJzw?ykza~ zOjLa+t*j{~1&JWa1{q4{P$U^Gr;xy#T5>xR5(jfU!K56i>bv&!*1qIa4x>0#R?-1! ztq$917llPRd;~ZzSmcWOtJ5GBZ^*(-RM<9-* zhQg89^P=i#NlI);+B^@{9mH02Sr9^aYYk=QarAS1)k$&g9^BdE;3~IgOhe+k6IW~9 zvzqHt71pckE%P{S6&=%ySc_Lbd+`ZrOfJvd(idbIZ_@uv)mrIik$FD-S$x0FHG1JU+1I{utiNCTJCnUXth5KjFFnmmzRC5Pr^i0{Cy^%>_BwS5 zK7A}C|9|lx8!{)Wms676~Kl1d$zY2z@|L_0v^y!~??$bYg`t*Z;kQ4vP(?0DF{oUB5UDSs@ zf`(PHX(07Soq!j|EOY3w&sa|WHP3s9F=Ye=qa*;*Zc_sF49<51!SRh)Z|4iN)b^hz zXL6m3Y9F+lQA4D!6qPKpjZUJ){4%TYDDzAg)Mv0|X>&LB86gmLbr!c5$s4l6+pUcz z+qbmK4}L9U3*XKYYJZ!j^8H?(%I6bl|MjbX^XlKe`ggAW{j2}z>OZ~uFR%XVtN;G$ zf4cf#uKu^H|1+K*?+B$hN|VVREjhgOf%uZN@}1in<|r|9+4ty)bC5!KVlJ9VnNloDk5gj9P|w+99e}$IM5=>fRBbYP5x%u%sP%q@oyE zm)!a8YQ$NeTPCC&=@>b~T~Nz7KUKRW{GR~dd!(lN+S)&r7L_#6!4l=rtIb;ACAUaM zJmqJ?uQ3YavT$AFwkxkvyu(!4v9iRrfzCNR;vfP?uP)x6eco~2pj3RSU zz}))eML~NXh4VSp$#;lbSDYH=d@t{dnx*aJ(+Gf^SH8Zy?`P5r6)Vk%&Lp$OPCQ2z z3TxReYj(A5jSXaGHBdLpYGfdUay1sumJ45(ETM2bvxzI@UC#_qawN*TaA8AfG}>y>g%_^?Sew49K<~3SmC|%9je{P*!$f z{Yhctx-9;8wB@@^Y@&htu7kpl`2)PYVR zEdO37Oa+w3zADsJj}?V-zt%&!C==!Jyg%Ki4mPrhX&1%3@3!J?`XeBouiE-^X5S+H zi$ZEV;D}ob)NL7#=UZ^`k-lERANiY+zeo1ce81?BWj%D=wgzXxi2bxB0RmbSq|! zMd54K9G#KZK!Ybaf`j5ha3ssb(U6`9;+KG|wtD>eE&A_l;QN4?00mg~OJrK^$mJcL z-M1QVW^1(KOSd(Z%b07h*_Jw1>?#KZIx+xa5GV!a9T_b`TD?JOR>sr`XlLAJzHH5| z0#aT1^aim%ORMBr(dl>CD z`YYN^i0)vgK=OnjAk95_Jbwf&ab2k2uD69vjP)8=akwqlmK}c@|9t6v_g;CCn+?{1 zE8qahH@0T2fkPE>nC)$1%#0N-Itry!oHPh!t<3x+>(NNLPqjwj2mZ4>^bstwVt!Du zz!+EU)+fQfbUW+ zS_p#_bYk56yq+;;F6~{U!jF{|d~UKMXnDF39($g4?=5km=3^-Hndh+5(QI{6YmS_m)gMI``^YWnA=!trVYXtzovO1!#4w<;=LSz*TQ`AJ(j#Gb1shv6f%i zgLvrOHno6DBIIY1qN?^edDi&#XNd;|H}Nad0-pLAuTb}qbmlE>5G55di7sIuc;z2& zI?kGbM#-h(0;<(M=S70)#Y9;Alz(XRzV^T*!yZ^$Y`p{vTH^&ftWdOrQs3%%^5TjA z`0iuyMn}S4;TEq8nbio$IdQ4mftiDH9gYPtg7lN`x?0s}0)OMTOgS=ETUJ#R1r-ys zPTEj$`~=T6H%LDYUlClr8jU(rw!#L?2(#`>(W(kCum!p024nwAG!%+j_hmGMvS=pZ z(Cd}!#FMf2vxqDVwe71SGU^y8=AX4q+%qnHYa63!|CN{Gu|BT@Pd=q=kAT>F04l+= zFbK}VrPFV*aF4b7y%>++ycBVFe2-(>aE+X9HvS&Lv~%a49J<8Xk+Xc-Y><~ykRn(fPKH|OmOunWAh-76k)U+w49^mp&JxmZ=L zY1h^pPaBUA?VNf7LIK z@g-b=6V$RZVhciknJkxh%VwXU#;>=$0LcUIRFTnKH=EQ`EB7PMAK_Z#+2I~ft_rOi z#rOi$o<*|Gx?AHo5f;c?NxHD$!!dJ2cjx@=(81V5LdRo%)F17GgFDcYlr~ zZ@0c@EXk8ILj4(RZJfuIZvbQ83n-*e&(738uc0w_DqMo3J@0af4v&!aodt3co6G~M z>G@B-VD6Fj5r75qvPFs` z8hju0l8iV+hV3FZQ(E=1 zIk4sC39kqFQQ<(g$27?(6+WugdH40(aOI`kF16tsvg~wb;zW(g6|7Hxtv37;j%vft zF%bU-zP4!nd+x1`tlFlH7Li&c$Qni`z73W{Y~FfZq>RgmCw|X6>QBa6sJ6WLW_+?E zln$vU`8jb3bW?U{%IiaI^nnbDRUT|SSu+srvLfH?)%WeaxC%zGZoND2BJBR-0j)lU zR~Ks9h;FQ!rsYE$-)XA6XtnU4k)HD&_7KIa%ckZlXepn#N55a0N9YlHgRdozNNX(T zg$cZ_iR>n?z-Mzl_l%AHHR8r5=TrDSNLy>#bR(|8`<$bTcLxP^b~Z5AJG4|cYd;pM z>M|pYvbS&SGoFkB$wfp6qNsa}*#nH5O@m$VkNu%q|GRPwq9N5Cu7RWa({3j61Jpmc z*#SyaQ7-jvrg-UvrMtDYQMWxd@HO%#Jr5uc@+H7(mB(C3&5SMHP~&s{$JpX#^~zzZ zI!I(9p1t_K);XC~57}~_$ieGIe8|l^aD&ga8kAYJBes(l+((nxuo` zZ}92!8K({J9(dPgL)e&xd}`CX{J7C7ZtehHkH;1I5H(o)6Swv-F+&R z6K`$rYR+Q%K61q0iWJz9`vsf@5SVE5&PPHA7jK){Y&(0PuX{Q@&q zhm(2(#maDGTXaZB&ew0VyL~ldzFCUD66hl4wk-$P;#peCtQv)2!J9wHp z@}>VSqrSRAGc%tC5*nboM^HKKGf6Rk%@BaTX{!xmGZS!Vk2}UY%;Qq9+C((SHDYwvxoUitQt- zzzR*}t6xJ>q52UiMJSI*$Sz6u7mT%K({&G1aI1-t(FrN}+OtIE^@Nu*c4>I^An`Ph z?9FDjNC(g8Fd^*`lJ*OB0o2&Yb84t?E zp0MWvw-fzi55sSG49bmH33{BzmAS2-@@8*a%EB7rVBu44)2X`p+J{W6dyE^o5Q|(5#&gbyWMD-J8}5}w z<6Ol$n#96?w8?tL;&AHc8Moqn(l2ojO=p~M5-l>qzHcJ}9lQuhDyL4_%onO}^*fzC zYLdyhPP13vw|C8#KkdlBgM7ZChb1}Elyr8r>pJ>$a*ZeCGBw|9pMSCV?@3w;cWB&w zSJ_CDpU1fvjX~tKyUobBK`dD+%9v%|XN_U%SBoToE7tHXc3%}q#MaG^@Y6N6@K&pZ zL;*KFL6x6rM4PSu#l%L`i;a2cVwr%*;s(ii42=<;nDQ@iFvu1Kx(x6y2-J$>df@anVWpE<|4j# z6!<}9UM__k6M?USHT~R2D&PS8jrv(MH<7928`mqM5!W!=iY#?79Ke|3dkNl3k1018Y(Wb?z7 zCHa?!pqn526y)@G)1GQxs5SeOQ4cvpCP?QH*-Abww@9v~2M1O54E>19$hy}CD$Mq8 ze3&A%=Jz?NZ=JOn+!IR=THi5+s?e7x0K9EBR-tIjNgEnXei&TxnK@V&xZAAkJ@~NN z%NSMH&RXOA|L3bX7IyXS>UXaGW=ZD)%@eoKR_mrBX1*<&L}vE?MpNfnYT@yL;bD#0 zw6{^$euTXxroDx}8V`LGuYR>qzH7EAw$iGXKHL^bS20YA_H9!#9KjO*W?y^o^`P&fvyf&)uD${wiV7d5u~9>KWv}lQ9b30G1JJF z_B1ia))Gj}^E31~k-k^+(l;|So4cx}k9X5?lUy{F?2=N)iEDj!s@W6NGKV+5uNU@K zv}X=dA4yNEa^AI;nYgb-pP(7&JA4CXh5f0>t+2PMW_mrTA#`lsbEo1U)^VVGAk*M5 ziD;iR9QdOE^Oqcu@S3}5-P!m*bIX#${!A?ZEM0B~)I~}p>FQi)3%vJ8BdfJ=9NU-` z9LmNPJt?$N&Nd^gJbh71E$`L&aE$?XHC2w(hOdFMRYha-FStorWrrR;vgTVBMPu`^ znU$7 zd{|T+KlF1@0TT~P5sjtpPtmqu=)hM$M_P@7~A>q1e6`*5m9C}tZjGGbdvUFJCB6}1LeW}YTS07V%w{t!5(5S4c%Z(wdguJK+& z{CTc88Rs4GF}Z&BA}hEaJv|85G7ALImj-wB8hAw5L3aQVXl8iiio;IEyt19UDVRKZdTN>UX(IIrp3gE!YaZ|(JeJ&7;UYgl^1ON07S zBB?;wRF=q~4#HkM`%yiNrbNsAmtR6(*sI0CjmX}U!SAN``AXLrUbF60MHQBoojd#VT`gBw2)z#!#BFEd*yiH{zwPU?brDgnKkl^+ z@FvtTOpArPT%n&GUd5~Y*{k3IGsp$a%oz8(j6sJdAWjZKCpJJUyViy^*4 z-I(08m-BpiISVi1&~~(U9gQcLdlNWZ*sr?1y?GmZt?Sjrc5jTD5C$y~OyKHSbpypB zWZWRKM*6q6HWha__km*^G)JiCE|h%bv}Bnw4N=-|P06ityTZGzHx_J-{DN|@Gb>18 zM%|!y{Suyl%7~6zmmXNcB6bE%e@fIp~{KKFK=a7^9xvF!V8|30$e z6IYxl@`dWdI!w}48r0SQqErPq(Ikz{Ti#Q8C5inl=0{_yY63noAwh^J4xt~;%ciV>xE@O^yY1=O-P>3)@dXW+4Sx!6j!Iig zioQxZk8@-DWaPpvB5^1gCHin%8Hf^Xg@;4}Wu^lszqq>k18};MP$YIPEijK%r6)Q& zy-cS~1!2Cbi~Gv}S?Nc_z$!`v7h}zf+u`kV@XU$~f%;Xv6)k#j@o08$Xg*g*=Z_pn<``@R#&exJps=Jat^$nh|;+Zr{s zVMP2=Iv;7=vZ4V71UCfDFOyupw|(Q`4`|I5>(~rZ<`d*m<`dtABkOBFgb%5m*J)9x zl*8Lp%flDvc~pA6NcQD~3X9Ym=gNK*I0X;CeDUn*7tuYcx3M(_CuXS@3@-Tw0pQt@lps&^0ku_?{JS$@gy59a zpmLk5FC(|#*v87JPF7VY=r_SdXc7s5XL3?tP}-T;WMiMxxa?9x{is)Z6`{>LMDsH} zH&d1vvy$TOzm^qlN^o)g8-r%a%v^Tn+nfsu+NOPc^A-izMCy$OP^aT50-DKgCo2Yj zh9CZ8v?OzXwOTlrI^4x1S^%XHH51X~J-X>D70?sq8#dqwza+J@I#q%vfuI3RYpa53%#?6FsM2oI^OyY;Ltbh!f#C5*3 z{gMrw*=*`!?-+fn@yf>1;)y`SDL#ec{&T)*6%2voj=Pjk(m0BajS12+Y6^gFkBssfGXvx-hAd-ks7t^gv1NCIlN zf4CT(Tc4l#un$^Aq7_J$x45Sj)Pn+eT0g95&!LgDK9!1+wi4piUI|yBMuRk8Y-!qX zYv|nDw7Wx_J$ZAt?h#7~?Oa)Y2cz_=GfM>RE~PTWVPHiJcg8RbCF+d9yt$beRkj|7wb)N_9l)L&Vm1N=<1?@;J@SF4Xv~c~s>UkK|HP5P1~mB^~9nNdm>N zh*$NdXe8P+Bqgq~B;q1RUW-JgXTMmCOO+c}>fUN|OIHQIsH0Qt5{QU1&S)guq2Jxf zXXUcWwr0C}P5+%q7_MxWLin&jeu#h4b5pl1NZKaoE4V)b?sti^k5Sm6=H!Z!i0tF* z)V7OS&5~9Wd<)H(4)E>XZ8CTl+8@CX{QwyH7Rj$5O?U1hPi(C0{?S%6iY-bbB$Zz; zMCQ|i$IO&Qbpj1HIN2f}b?nBZmLysut1sYVt8J+}{UV?5KTz zr{jWXcFkx-Vvp#0-^l0;qQ-uq4c{bEu?az>4YMVGar+uNDsQu&`n`Q*S@8S?6=spW zeA~6cQM3|rat7zW;+W~83>5stm5t&8R4#_tk%djs}f>a*MxgBlCT7K)p z)5|sAF3xSMVEd4GM{ws^cjRejm6qd>epl2i9m>NG(o?(~Gh#|eO26ARJ4aiy%2Cah z$1(rDg$Y^gsUrSDwrk6=i&JhIjn}c(A%P&LMY+tc(etYPwKnuOyE1fHloA&LL(nOt zN^VF#nxA5SXn|jBG%K|)=mlz4t1()y9cw)JDd)3Q^cu@F_^r0dvlg;eqI~?2zR5pv z^-o>>GgtrI)!*J?iF_%On2WcQO1y9to|Zu z#Vo_VkLdZ#_xi1bRJ~kvfDuRR3fP7_u6y3kjkK_txU&LMM{2B^j3_6T(?85wQr33V z(L_%xJCG4u2#KS$*3L%ik^H^_HlD~zuBU3n&Zn^;2eG84rnX8OU&0kTh#elaCZ!(- zzz2>sPcOAaFc?g3;+%<^VX#RyvJEjO-l@4l0cZ--YZjCx0%xsGX#pqguZe4onHk@v z4YB$SAF3*{h_a6Re%pVGWd~`9aj&l@4ou}+a(*0*#AnpSl4_@49a514{|My|l*=UC z>ijsiArEe>WlIL0rR}!yBHP62Ekz@(Q+O&0)zhO|M0l@Seu)8VA8Ay##sNrk>+z%^ zYl#KenK^N-Q~nq|Cn-9YpF+FWiuU29$PMZ7so4y2E5U<$nd@VJX~se?YW1Qfi;i83 zoMet9H9r~^F3Q`461~y(?t0T~qtMu#V)D*N)m1Ul^*q{+5xXjh5DGO%P@GtuZ^8!8 zz;ofzJ613*-ie33_L-s37+CkNz%3U8K$*5=3oMd;-rT(P5pO~U8ZB$~A>NU%5$4mI z&9)l8PuS^|8UUTY0xT->sn`}{VKU=bByU)B!V=Wu-YMRMmy90pQw@-D=q3@pWTVZL zYy$By`$z?aOTz-689F=K0`RawW3_&<^c~^_5Z@kKl!qm0ua``zgEbZ(`cnK**@#S@ zccv0-E6=m;YzvNSf3%2zX$dj}AF+@9 z(UJ08HY~7oy3;lHrH`cLT?ss-Y*jdC3`L*Gy9DtOlK6~9iX4@4%rBc3T7``kbfo>x zTKVBRoEKHf0qmh{+aGyFnyhG1ai20Z(UL$KmT@@QZW{;j!|JGHyV261vC5(BYgXUN zd9q3*QW=a=c1cHTOy07N@w=5rhePfQCrHU zq%>5vT);04p98nLR+}{|p}mTq##%YV?K4M%ag0x>-u__8n-g2Wuwxdlf7hd<`4;?V z*?#g2u2}k5Cj|sr2hO#O$e?A!ev3$*qP(nU%;#jpee$TVyQCTBFxZ+kOn>*E1bn2FLkln4>q5yn)#nX=kIJ| z@k2{dHZ72FqJ(ck)V4RWSvY>#)iu+td}bsT-qto~V^ znD8&?O|g@fbjh3dXrn9#@=Ef2mh5*6D{k$p(BHC$t|3i#OU4XJKaMp$ob?mR<9lED zFd%r3eK|nNKgPA&)p<|Llilp+*y*CZbXnEdR&wdP$-16LV-Glj>l`bqgRkKgdiguS zk(n12`^tw?EvFV9yuKxzvD3L0r@@IE?wmKu=9H+Z#Wp>z%mhRc@=C}Om3xe2*y8ut z1DWwY^6-wC5EW-WCC~148xU;ZY($3{>-tJ_wQ8RwS<;uG@jL7N1}OCdN?BcO1S>H z(yCUCgM1Fn-y!1m%q7>b*ht*fD2Xr;%j79Rp5nc_)B`yDIiWXdLP+BJ#KBr4UOFWr zSAe8RNn|stPd@CURQ~b_bLU@WRJ+V2;!uzIi|`_(2+Ct%ErO(k*If;;cepHUW&McB z`;qetEwbVOvt2gagH_9*A@!51KSd6X2c4GoAS-&ns&v3>)D<}>iy@(9B9$c;$1vT` zSf-!EsOc;HDWYOR9-BA2Bdn*-{^(QnX6uCvd*x<+fZ~#Ai!T?wsjfivmuLXEd4oA% z?AQ(*^;vV#YIUqL23p9lVDvnWXuUhClG&HrXqFV1>uQ3ik}um(R`<_7YoBs0Q0kS} zEjd10T~(9h7bFzlLJ>8~j>k)2F3h)7J8a(1D-u`UfA*qlqWaf&$c$iB?8Mt7!Zb{ z?AO#j&+>pnH=B>$6dK!=T6-&I;wbYB&q~lGJWLKY>>Ju)jL(a0o5ZHez2PH~oC( zo-NaYr@{&W7GG`L*|=Y_^`CjP8S@yJ1+@hOlP!i-G+KiU6<3UxwxhuA+h;zGrkn&$ zz{-GA!YoJM^tcnajbY#FQJ#ai5hoNVTzX>Q*_0Cfuk&Nl7#bxb?%+_{x>V`B;&tUA zKL+2-vIfCu+t08Vw0<*UiFfbmke?&E)EpeBtsx}L9_|?7=($?9Yp>F()hstMlgCDq zHdM{0n%lX&(6nk@l^waFh+-Ab0$+P2uDb ziQa#C&R3J>FLXCh#x=_e)X$CGd&FzF6lFK7IOQ=+4k~WjNa$ zLS@^1na$?pp!zO<1Nx71IDelfYgP3KGQtZ)#n|Ob0_#1W#bNy(vhy29k9`)C3r)xn z`K33!lx^T0a+099-LJ6qR}9wcoX$3q7>;k}<3m_K%1J=4X9E8Lyv-sf& z_4`(l`w~3dzehmF9Q@Y?@Nf2T@+A9ENbVSl^E1a^^EeBATrIkhz*T*&@_;|05AwJ0 zg1^mk4}X@vThY3yG8~1c;p%7X(`E7m)XElAe$D5 zkz#Yo;Sw#jt!#-t)gfH-3-jBVGu~7{TS-^Wq<_AzJaNpt))(VG>QC#cPh_k>wKAn` z7lhU=9*@B z+Sh-cSfcGzP4Hj5@`;uIno&h6a+x&6BNzd*9_M-n0nIX$r;F|!cCci){t#)kSkaE8_43jNW-}LFD0@T@7EiL z@FF)QgXWZ9^L?by=P0cUGAN+{!aptcQVxaFe34S{g9!UYLPc!g$CvV{uv(VTQsan5 zw~byTIgFiu@b|;-+-bJ!I^072@UioC3eo#_&hWg8d^Traw8(Wh4HwrlqbjFdS`LB> ztUa37dLge(e?1+s?_ZUV-=>Z^bBWR_BKw`EmFCt~czK-ugPtDiPiV3GP{{*3O&%G( z2{=hb2#iFb%}}@Cc*b5Ui}Z#jiO>|EuGsYF@Vd+@ICy5+WohYA&K~y7K5f~e9?87a zPixU{^0&{n*OC9>>G?cIsEAs(zu+>M%NWdAuhbS*Um#UV1gOZILMbcDRr5$3cxLsn zw}_68Y9*N7OWeZhJoAgCEkPD-xkXmVDa15MMYNW|(ax`FcI}6oC(|e+oMe?OsgwuY zf;R}4o_W%Y>U~wt@F&nvqb|wPiUtHE70}dz3T+30K}Au#odtbGn^LlqB5|K$7sYmL zOy8>X_w!OC?}#phLjPk06LTXiEbZUqm*y7Jn+*{mR^1xX!pL>LK|Iui;Fn}x{x$7V zDYaids5ap;_7O{bR-Bk$E*#wk5#Nr(5RQ0o zd*PA4xf{H-7Y;>I=!72}(QqFdua(EO&MPka0J-Myx#@qW2R6bMpXIzR~Hg4;F zrw@MmKVIFjO2<7Ga^*ctw{PCK`sf^gOLd9k$d5ICp7ImiT>9+0Q4{|+;R8Yfo#DaSwj>3_rVpKv^MQvr!+e1f~PxjjpTq)uMv{#nlDsl!Gj z#W$Y%@ih{Qchu|!T_V?s`)zO_nW9fEaF1I+_Yx@5_`gRkKG(SU=l(x$0h;$+dLCtTdyR71Fp-fyyEi- zujgQ3bns*!+EKVCyuLr59J9Jc8sUhw%_1DwHqN_*q;=x6W+$^_0k|T&0fL$f?>F#z zP8XGE5QX=OG}0t(()pbapodTEeMX)jC1!~`^<>bw>l-q*-FI!I(ZjFI_y-{Q8_2sh z&@an)nO|`6gKLpMl;O2j_N1n-RSh)T3MJRl4q*X4Q)FM0kBc=Vd6O5gf9FF)%u$Rk zmmx%W;k~vJYv%oa$a>83;c7@-fuOh!lvHdh15=`|C8gcviNCf)0bMn~Ka0G-u}M55 zo@!giP}82DN-88Mz~t(A>preFt$of~FPt96;&rmAu4k3I07<%PJop2MK3hyG z)yKw#LXm3*WbR37vW61pXdCkC)9z=k4zPDykZNsH%GCzhW(2m0FKdnT3eB+)pw>9S zx!u($PQzBJfysA$z}dWk8Bf)?;EzE||JkX$WA|O@ts3%4YSp+=+-m?6Sn8S%)*I;2 zPL6)icmx2zz7Dj4^GSze(jCnTo=#IdK!moXN}FecJmVi(EDv6C%Z=gDQe&* zP-Dgr$AV24`H~ztf}#SamOe%|oGz%6X!8{hR5s-cw|Fv9T3HGr9>HL=tn*9x)ot5a z&I+>4yM#vc%0ufH``P_SxfgXOW4ksJ>L8HoN@ih_TCNo`3eUDO=-y3#8XK?J2dv_; zCH8|4x#^V)fW;W!P3FnCL=?*&MHfP$-@&_fz51py+7%FMPMWRIpzGG;;qn-ew2?jgJLp)RK^q}&e9XFOc znEjLpJZ&x|2PZvz^QP{Ts+dx|#{;;+tFLd~;5J}$5*S48=NWtWUCvn1k18i##R{05 zbI~7j-pTiAhpOr=Bi1r92wQPr$6=2^_@}~y$8q|b*Y~gamln;h+NGj7@I#F!mTXqJ zd;`tKI*kX?QV{QBR0q0e%~j4*bK2t2E-mFPq96p^+lsQ;Y)R2hKRFdL0z!K6_uRX^ z>qr~xU&}W1Es+45E${Sig!%eD^G43EZK-(mN6D@jd(5@Iu~-8gAbL8pzL~nMJRw-6 zYL6y{VcQw)$+v}0TMw@YA3l{R(flr{Z+0Z9a^B2$x9p& zc?nX=T7pPjDIy9LkZ`)_bs`~znXy3q9lG7)NBM90E(mP{j5}hvV*}joBc9v*LT8^X zm8vvXg%T<@&h^T6;P)(6%$4IcJV~oAV!jR=5@TE2@Urx|Gw77-ua%g_2<1keAxje- z6N4&Mp`j*=R8DL<0WVvIoyW;fH_Ou!0+dhX61Cc(`-OLCUUmA-E$RWMkM9OtuI%}FC)Z$S*RhPS=wXKXY{#A4-Mg9B@9F-?A3aC){ zvf$DVT7!|Iag;M|SOAf?m6x}RyrZL6QY8Z_R32*4#G>g9eY48DI`@zkjg`}@#k;-N z?LIL)AMEmxIIj$BBcQJW0d&4#iKBe8k0P8s&R1L5)-+V!KCQJnI8&Lm^+e7<&Kevr z@*1b45%$>~15f$-{KN{mSvg9x^ps7OxABN$pO_0KGf_$!RSX2U%*z`ZgbQ~eLD*$a znBWU%b6^*JZrS@uO0^6>Tf0Dhi!rtBDbjiFhxfoL~}0_}t}VZWT*#~cceo+Mu~oh^{V8=iPnhf0%PW=t)C`RtMm)13KjkAXq#Nma30);O zMVD}#bD)!Kq;)Hwl`rcr-}?Y)rRDeyaG|oG;m@q!W~oATmfcUDs$8cY(whIuxLoab zKn0j%+-q&2R>f*+vw{?y)C)P;<-r59wH=9*PIkhIi33X)fiXBOfhDIB zc~%+I-lm;b<|TnM{ecB}uZm;eV^&kWD9ZCKk2F&gh@td1@}HKmX}Bdg#I`swYkbXl zlf#P-Qnh7~F@RtzPcFhOo0bPA@7Kn@#W;=;B{JcHvJ+{pzn8{efbo;rPe_K@w068T zxf*Z=MYmY2>}=OIcyi5ka_WQ7l=Z}6>G);nn6t~&Be%NVYoW*M#SIkAreto&v_wh& z6_}gd2=hBaEIuNLQs2U9L4yZ31q3iaIdu(tyeM1bpiJ!}KoGUK*#E=+k^EQgzDb~X z_&!&Gjbsf`pbfRn-(5N@K6~~jjIMoUU&)C!*ubT}(lLH4+&0OhTgHK+&-Q;**~&DK z9Q^;6=(APL9Ny)={wlk!7MlJ5$8};idrQgo{DLq+q+7Cg(2s33(m^1KG8*1Jm>kZ|CYqL17)6V5YV^o+LSLTc*oOa*K>#P5#O_U5|hQEPhdaDew=`Sg5bX3h6 zx1Fa5Yue+17D&$lS45R{G&KEBaAf6XJxEFI+c~ZFU3fmHWV=(aqRlR6O{m&=dKb-g zMorlF``+G*M`V$OP7+T+8Bqe?OGtVVV$x@$lU>I3yp(Pe#p|CaiTsUOImr^6Z`n~? znhoISeq^|qwiXWcgVI~CYIzMnVv{g==?%6ewgwfaXpiF9Pw$D!Hi~*=HlPii^Za1x z41Hsfno}SX$fVc4L0_*}pi&xP{McH03gFR4(d^oz(=+Y5ul7wW%$Pz0)(Mje0I(_+ ziEEj~K7CZzY+v~gwYwIz-Jx@_;UaRiWM{@#{_@9>scrJq?UiGcq$EdQ9?>pzX@D(n2K9MOdj)m+shzBT1!n>0Jc{UcKQ0I!2U|nf|#KJ`{%v# zo!H}^YgFH5$r+%5tE~y7_RA-hCr%RvS=uAB-U-gp{T#c6u2!_@aEB zTixhGNrhyPHXxGo_0#|qyJgB6doxm zAc42rU&ptCsQ8rzuc*P8Ao$2aK!8x4n1JAj$N&^#=~MbDlV9m$9=tF(TdHuP@P*l# z8$rwTfvih-b+-i)LOd$IcsGi7m4REjrHGe#k8sR-DkrP)7p?ykW`M%QkJl%p`RCI6 zkVuendxIZdb&8q6D&Q^4%PZMr$&Yt!;b+fxOuF2p-l5m=g?YAadqAr~I=Xu>Pnj%D za=CZTBLvqyrlxsEKF=g6Z8{34&N|FfY5dD|=UhKj}-6aooahYa~ES@DEN)4P;WMKZaMb~9D*PN6 zrINEry<6lr`P5#!NPKG3=xC~Zl;30(w)8d+%A@|h@iO~}#k(tjKJ?BwP+5AbSs9F` zg=$nsq&f=#I}qq^Arn|qTe0qp_k#t;a)h^7av(0|yu&n(>kr>Ro=e{I5!Xu`ESD)R zEpy3^6fKsRMjaCMY(j%`C7xyOj=4hLw=0w|E5pty*tU3uZ^ne-@0+b#BQ-SSJ+w%X z@rlbj-;S}|-raC#9A$IZnjGPdd-!IA<$6L>c{tw$gwV)kMZkVpF%}r(SNs<;**$l8 z2Zhgb546@7+SGxsieD#JisQRhqe5dVnuTiRJp}`~0F^B{gjYM|bLncXQ)(-cSCILH z?D|gqkmH9MjVKO<8i)6`IQxz$>r9JOzRvQTozTg65C#-2c~4WQY|B@C=38a6J9&0r zLf2MD2~BAGmI=W7wLWXaF}zds}1D3AJHa`k|V$C1XFN9s48lsf@a3 zUG$Bwm#oGwwS}@VKj@qAy=v3!Y~CL2LD}Z+&`B>RzA^32w(k0MJW@DXS3b2dZJA@$ z@2>H}@eS$C_BPGBA}|bAP*71%w!YrPQ(J;pNVq&CT?2W$$^d9k`0_N)9$h|<`BB!h6dE;29IH1pO4kS#vVUzv5HzNqNT1}A{jpe zR4&BUFog?}ZPUeF|))3^J{$gS^H6%_8eA^YeZ}cpyVibl}mE`H!sv6kxzkLL`IQemW5C2IAr< zC!&SI=W~V4m$$i^6~~1wf3$mm7ZKGhaPD76o>~U883VX0B7A{{F*AZ2zo)(Bpq~=v z6}6sj&C_(v%A#YQ4EejULQxkj@VJp;zw1CtiDNQsX&Mhc(v}Xh#7QGkDSwXOHad4I zV;xfb*4gC9tbF|)eVFfZ_r{J5-S^NpM-LL>ue-HVIScp@9bI9083>iF$H6T zmDk#0`g|)ZX_6({#>o}bhNidZ@t2@#p5YZ*f-=-;z4_LbyL^LIt=4K(VG(fUkSZza z;vF$yS`sGBZf1VGXH6;SsGLB1s{2yDUp}Ku@`_}_x3ocr`@DGfyQz>gNMLZr?}Ns- ztOYMuOL$O(ygLl1g+&JNt6Gx@%H+r21MFTA(ilNZ&yKq{4gdYz!xlqU+ zYvi@0{D_o7MJJRFl8sfjKASG|TV`e>XY)Qizty6tx-&Vt4n8OkS0D+w4OXf3S5l9_#j6He|22o}r*IQd`A7!$W zk?i1ynrfZEBz|6cb1N*q3Se9Ocx5er;sJkhL!YeK3ZI`N+nz2+r((WlHv&WTse}oED14*LEK5Zc34GXQ=R=XDHe16(61z1PJtM=N~HR>0sX|A+0u5WJ#g&z)xM5Kk*K{P zC@jud27L@F<|q_Jq`vz?8rnBv0R(CvLoac``?^>J?pO>4#mLaL)g@o=x|exD39#9<3MqRKaak zMm$@Np$u%>{;BF!o1`Agy1X{xsrdupzs%mz^NlR?biA%&b9v|?`-<2$TdUk_@*dWk zX?ZA_{1Fk^$yewmjzq5cNiGttv@rLlxkfOex3{B^iWK!JncYa{Tz;wcYSswc^3=D) z1|_FXo#7P%K%wv?gBO{!J4NOhWkxV5()TNT*H9nLgi*kaQF{!2H#eKle2XV2Xy?(4 zPdXO!EhwriRhmjFTRbnDmN0wakQKtl(vu%T4+n{+%7On3!tqE!zeNn0T9HzuE307c zd-T-MJjcxWY2v;8j-hFf6+eWs(OA>=e#%Cl6D_3hNmJUHkX0H`uaw3&IjBOjpC%Wg zGqoW{$~hu!Iw(fv8B?-N+gQty(P7I?Coyc zqP|billpKYQ(N0reLHijwK9)z>Te=k(Ihd@70)TZVmcUN^jMbSRCN3UUB`(tG|F-$ z4yyH}BYDfbomwl{{^c)2g)Kt$U(y$j(7+gyAZL+QACfkD?7WXGcd6;eshqtHOJIqZnf4Otfx6t~lM>-*(WHX{0q2+szWE7bk3Au*|IC&XJ zi!j2R(yDjVTY6Q`Cgw)R{MHiY8=FtuHFIU$i5mB7DqXp|<+RaOr}cZC_miB*oGqfF z3h#*Bp*J*uDd#d*;5B-3e%Hlwi$uhivRm9_jd9)nLo! zz}iCcyS1opzk(uf`WW=TeqGNK7&tYbH}$QM$fY$Z===t$LhATWT`Hi`CGR)zZgpHu zwkZ9S&%D@=xpGao%Y1?oVA}Yd7suhOCpVPQH*^%ZYiSU-au{k-jpS&_g#2xhNdPq| z%0+j5!pHbm<d+i6`h!kwd1zGwD&QG6okxct!_r^p^XsV#-z*Fn9O-!m( zap{tGecD?1ViVW7J9R9|^V1l%T={sHaprH6*OX1}bZj+C)Tigck$b60%2YXGr*?=} zBrr+MHl4g>?Ah_+_d>7imFt_(12kzJdChqGX5)LNEIDQH1On*bpHHr>wo$)xEPflS z8yngoAZyL@WAmViGzBr5gf{+H;E*ZKq7PqkeDhaIpQFJcbR?(@y{fkg&T%Q*4Zar5 zyHCxSOj|`!SWqkD)|<-GHhY82@+0SaWFcQ=IP=LJZ>V}tiC`eN1#72n1ubpuIMvJ* z(HG}FKpE0tq2d@XI$AgY8LcK(6b;U`cTVg^JXa(Or#{N*}JarRO%`J0IbZ8odj*Ykwf6S_=dVu+FD*@9Fu{1B|G}Btnf6oFF-_w zgol`r@GbXMC$nXeHmv5PB!&fEla6f+&7hcBD2tT=H_jp=Q6wWP${mUlMa#X~pL&XP zF_8Bt0F*!QehP8H46#2tQ9`vjfQGoKa8y+&+{{mWTEl>k%HOTt(F;$1r*K46de?|* zWXGY%a%xe2wdLs;t@E#&-GxxBXKjM5u=M%AJeYrdy%XzN;=N)Zw9 z#Tn81HdR;SC+FPX8+U3f-?=H)U&DkdeZk$;Trswn-)pSdIR~x;a97uRmh(}P1GlXJ zpIFSs$h}&d7~y%2+lK-znLEK)D~kdWw*xG=>fQ#Rs4HJ&;xcqYx=`?Tx^ixx3H?NH zy1AY%YVM+1;W|ICgCXYyCaWvnF@vhwFzIvrzWe~ZW0m1p5^nCCV}h+f@1xgT2gmUm z?8}K-JKd3j8Y}Lcx3b)~=>1MjD-926Qgn5YbqqQ-M(mJhn*({-aZI++QXJ`^ml6-v z*2BF#8|Mw1>)@iGbLSlJU(jgp@LQAGd8A(VWADGW9(QO^DsIvcQ6KC=TaI0*Z{?x| zd6On;%+%QhZ}qp@T9u!wMAru7mA)OKFoo!u7{=Lok<(6PS)5OhkyJ_o=Qd~ixWvYj zTF~;8Rc&?{eR5qtBV+TCMI&AjObUem_=<~8bMhIlfxlUm7+n3}H8!!@U~yaat^7C* z`Egz(y~1q0l|8_w9=QI#%eTER1X@Xwx?R7UKLrv?AAqaYqS(*bb25ON82l$ z6-3ol$AJW&&<%_Y-CsG{t#cT^=u~ehZpoF?3-^qkI$gp5C3YB za==j*QEdgXjP*pGyxCM>Lk84E7OV7k`tP}6)iZZ_4CGKVc4KJaMKCgEaen0!6E6=k zM6;+>&7uu!b{EgpgY1jtT-E|*q7swY4m>UrC$h6vBx2FxneCqEitIGEo`qR&2U~qx%F>=b-;Rh6pL#Akk7R#vaX% zZGM(9q*o;|e5e1oYX7TVUH!85N(d~URxU?RbJ?tA}(ZGjOCm%`| zP5Ahv*W`X-@Op);h(EFtZR)f2o{7}YZi$7Z%UvGO>J{Q`2tuQ}RI&)|uUT~^M5{Qq zo#yJ{1^WtzeX7_9FJ*PELMt=73K?msQ4OH2wEXf`Noz{bU)ZPD z&XI~grc7K1%g8-9n(`zREQvNlidI^*yVBrd3rH_Fz0{f=Z%S_GdW){W&ebCgfGY%4 zADMHV>k}XJhQ<>?%3h0qFca2sK6PdXQbV70Ke&2qeY5XX@o5#uO90{;?{tM$JJmPw=N?$4A=GB5l_$hC#P20H@Pl@lI*<9$f75`&nZV zjl_dk)OS7%T{4F*VgWo=UL}|HBbn#|p|U~7LPyOSM+aOfkKxkx3!meGDzPCUVMu&2 z7LM=Vbyd0CE?O-4K!>$0vV-`Zk&Xnw*cI$^{q0;Y-NOTWp@A+qDaS;sD^%h@jT5_8Pl9V140DDqOqEKO;QVj@6}J*x2itlnFjw%d2P~U8YGmhm|^1 z!5DIsYSxrSbR~+0wKmNGw)2FYR^6bfk-d*^_cmZ_0v0(~A8RqlL2<%f(a{pMtB)bV zjIa5a+w*c{m2KyGLLq6)$~Tspkky79XojtG1GBivmu<%2`DOBgMqlb1N69b6b<@ zAy2I6D`J}KHA}xn**v{xW${}wYo)r%vifmy6OKxbMhp~Svw`oqP7|B4VwYoRTBMNc z(X{%8=~Vu7`xRG>L2h{9yY)sZW#nv(ks<4B(O)lR5Sf=abw`#kwQwPX_LCaj+MT)( zOE98WgQrZbc$~LCTa60{frO;cm8-cxLG-{n+HYAe-JCzGXw%tq)vXU$Fa4hCrT6N% zA~*IRgpAZ0BWlXE=l$nd^W1y$bNxL}QdPfP|CZ}NwJMf*uw|2xNey+ufU~aLkRx#J z>3z6vJ5>hSSnd8L(2zC*=gLT2b&fER$VQcC!VZMJxGl;Crt7iSJwJh|nb|dj$2GRy z(*_>$Gc88^ep>HSvIyJCj4dv9bFdfta5)#RQBqv#f~OW1Xlc#TpOMQ}j&)D{weCSm z&rmFKOWWZ(6q?pNm!@L4v{n131jSOm!d_hocyy{2J7qN+yP#KQgVSd~^q2_L)n6zM zywEJ=&owlWFfxCl$EtF+-UmSQy~bX%&l^ICCD+=ryAPEWtD}M*sa#8a>^ku%y+NGT z+E0NNVDIj3Y`+3CXTl^~sWSyQ*!k;#<`bb~YD+v1=m3%J4W-0i)d z32v=}Ir51(E`QdsVq~*b@ug6DjWh){tH1)CpdfK|kG^uLI(2Mlk13S^8%=oXB1IoX z2|t6Ubs267(@00jth)Tye42spb1?G+%JN*HHvGj7g2VOb#fRseGCL|@o8ZFa7ZWPc@zTZEaaW-% zvhlvLKm(Uj73*N`W)U=@=sRk|8T*-| z46q>ejaT}zU?>&!4h2g*bkFhoPQ&Q9q*+{uC^C(wTRUseYB_z+e3yg&kGc1c>vg^# z{~y<{P6*+3oDf22WIA*vG(w|UXp;#c(=6mHgpdi1SjZM)&Dz#zghs59Erbw4CX>lz z%YANa5%5`bE{-zb1RCQAS=z?{gkMWo0Mu(0b8%OsPS=FXzqQ)xJ zT-cPEU(7LwX|_`u?M5Hb+tI0~!1_5U@6l6Xtc&Q5jwN)CTBm7rXQ9VX{1&^pd`KR3 zO1_N!vVB&d2~W32%pP-c$dM?qnY<+GnZ8C1?kEq>zoT_a=7seTz2PYXwGD>U7vj{YT;x}U>${4X=xAUo#udT#vMsHurjc24%U zk@WlY_BRypE1}V9GrFQ}PtxxvnB7gZP0{C&hUY(MxBi&B!cC)SV{2=ZSuPsphjhM(y8@cUekqjnwm>~NizyD=6BRT#vM6LzVE|sLQHma z99#7oBh5uqXb&}ARu3Q8AsZd4Np-{|Lxh<%hN?EVN{3-;bCDnQM#c1i!|a79;F-12 zIMrP1`H<-=tBf#5gNW&)ToAMVeqip^uyfk+acu3WO=}mwjSt3GYnH#dnKLe^8|Fn$ z?KVPfo9%e$G-_6b&Z{E*hicu^&?dNK6r1_BNR{1)YApIved)xa*)YBs51AUq0XiAc z>l9mfNTWWOXGQ2fFa8aDlY8Ti)nJ^!5z=U^Yfzc3pV(x^+ z0gjM3{O6(ex(zWh^acHmR0c5HjCdkL_e~baiUwk~REb>bGt_iAlUt_eXkX2MJ?7Fe zr`reWz%z_bDk*IdcUsS3#;G8 zcaDfO3e?&|6}^nD%FIC>nNx2O=WLIc?R$2ltKHCtP=)c$_^xgsNYXUzcB37|qB_jI zYX}?XBPC(h?7hLNhL;&k=00-s}>u#4q%-h;=djssjHzJ-l|+Sw#^nbazML-X-<@w?qMBL(Re2a zKj@}2^ez0LIk3ldw!cR+$zds!R(Gq~7^=#gU+R9x-j8bT(=_*zX*6iDvFW}?d%5vjx0&YPiPk|AF}NBC z`LXw0M>EP~!eqn@6+ItfYpn`6MaDX_7o23HQ~x6!jS;=a*=#vN#Lg*oyj8B6l1`>^HKcv2!MF>PytA_=O(Y>Ktxnvt&FS%rx)a2-e4 zdhCufsw-@oQpJ;$T8X&&~#zF0S!%Nj52R(w-0~i9s`pvyMGJY&A6)W>NwJf^oT(CB*h*H`CR?A}$=ti8#+NBeY6CAl9E75Y?pvRrncnGMyC z+OO0fQPdNkGG{B{UnG-VmeZ^64TZNpG+}rdXWn)*ZtKG1L^_QdkIa}<~6)#P`p9NlKBGSy;rC1OmBjL^qOkG`80kK&CKMnNZZ+BqNnKBhif zM~^y}^hcXH^o1ig9<~0+ZPW!!%i*Z{sgBzHshxXHidMY}TSPzEXd^Xr#<&J6uRg68 zon0?&$%H@AHY8FL4>0m2%GqlAqRwQRYZfZMD)Pnj##JV6az-X~jm_T*-t~|PWgO7z z0cjYd2Fm7|a`pgWp*gBaYNw;QPNc^p;d8rI8pR2t_KHZdB|Rcgx6P!CS}+Nw1P}DM zMc2jqz-mU9{g#rsdr$KTNm0>qpNWO*(B{#-#_yz1?3OnyjV$T+F!i;Xe~H{N^ZDPh zr#(;m&GImdpUEI`MjdkPNo3?$+e>q}y~x_LxTeLVOeWc~=}k(e4$wr5iG1$NIKcPM z%jjpUt&!Daljif%#G1`Q_+1Vi%l6p?Uk$&@p`FkCi_Gi5(|?*y;}kV$YO|#Ke$BLg z^VNP6+?Z! zjZkBJ-@jY5moxp+_Rn}YCWtk3>A_;;SK@>2Q_Q~U!03r9D>NN=_JzqZ>($$+y_mGn zeBgBGxxQ0^(a3*mUn}v73eA|-{iFW!xIKOf=ls@;OTU>;lPu@!2T^+LJVT_)*f;xH zdwdff2ZZ~orMX7cGEndJX^f%MW~Xh`MLMmYI#TWTgLGap{`86eAyevlm@RGj&&!s{ zOO&VReQCZlVfL6Qk*{dqVon(}Nu-H?QH0uyld{H!*6v;stzf%u{8%hHhSIYV+p|75 zd!NZ5tw8eDl0?P;-#s^dEio?5lXdL5v2lCNMkfsI#wLAqNIO8xlX-V`6T?#j{4Yb4 zB$|!9I=1$KYP=@rOvKpZHO+7MUDeMUt)WAvADJJk4bL5;CNpVZA$q6rqGQ3`%stC& zb=RWXgll?C{P;Ja-Hv19Z9=a(f>o>N*J}u?xy}&(-m2*lByUx;eL%nV4U;x=w5k4a z9U{?g#$oeE`@X#vq}$Uk)T#Pxf6yaXtJ8Leq&{H|LQNmmGirTiTzoH{=xfQIs#YCo zYkF&2F>=(thc~*|>l(Um)#ukF_2D)3Mk7UYU6zyyZt93!MzPh6<7Px!-%US`z7MZw z8}!q#2h&?wqHCzf%RqAyp0u0WOSGMgTAdWrPs}p#(qlV)MziK*6P*!2Y^^$zy-v~_ z`K%`mRxc+vk;~y+km`;yV*0}>(=SvbxzXWehnopOzj|U0%Zz*a$2KY+t6Gy5-t>H2 zU;2Gsd(C-GT{aA3$!w&pKAq^Y6N0*I5@F^XRG0d>&C-@zyN_(WRZaXAcH*`9r~P47 zs523J^ofYcMf~r7&qZW%NlxO0_Cr!`R~N$;u(w*#NoGJ4mb=7nPxUfMQ#*N+~T{|}=f@iC)aEqlPJv@ zrv~hMdFeB|qGy_YX3VYGN^7=Hp)FxhHrHt53f8|WvWQ+^7dcLpo$ZS7sdk~`DP^;U@ zt+*bo^N#lZVViTKS=-#CLT~oB$=CO2Y#+#Rp}7`f#7t2nCD-uFs`X)=Kb|IfB8UPJCVILw>I!?t%T(}p^) z6=v0JGvYRB9kpUSSRQpoj$Om?L_*O>wi2=0d9-L$+226HnBHQg^XAr`9v_E2eXaJ4 zRXXEm?U=49^X?ttt?WbgGYDc}q zRpTo*xY=BHvF3#()o=MuV&<(?Y5g$?KKnVpHRx7UlJ zkz?#dv(=g!`p7zFyH(A8V-?SmJU|YTZ^&VCxEv|R=!mnvs?R2pFd7qA7@LhV{A(f$ zrRWX%OAc;2Gcvk(QG<^smS;B zk+p3}L@pZu(&u z74hj_X6Zh{j@eLq`h!O%uUHR1n~dvNi?35pt$A~Mgc^tkZOe~lz+lfDLaye^G`fUcdmSlpKZ@E@ zYpU7UrNvm%>fy98Lm<%)&6hpwoJivS(0DIko)B4WAM@XSP0Va&8H;LN@1xNf4%>Mm zqd1_ZfpUE}`PFS9i6ktI%oLe77R}hzr{*5W+?2To(ukTExC2FBdc&BGUA4Ov^>Xxx zT}K_?MAJSIJ;z9&V-?<)Ws+cgA|T_BrX*}uW8Y>r@z?mFt*QAmdNiFHU7|yUNe!Rs zX5&a`u%FPN?Gi)FZulA90cgGDHe=I^O)MPe>-AQh(FsjhQ(-Di3UN9#YFd#$YBhee zXOc;FOlr-&DE3@N+a`-UsMs><7_~ZR4x1KZZ55?@$Ew*#>0mZ}+uWOnI_4$L}HSs_xAD~A2Wt<(r(MFUOjR!&(|VjdVClCc9QK; zxEzgEJ(|+di!b~}62aq!_Tunv3ynQ77peDbm~RZ4eyLha^pU)NYfw8OvYc_zd7}NK z9+QMu4M~Q2AJ39z&uSrK#uL3TfD^it*G-!}mC%MUjf9VSkEHP_oDU3-eM6-vjGjfN zewkj$Z7kL^Jy_H{;~Q;h&P5L7n9y89)%~9Opt&_lkT!lM+BhC9DiSTH3Q?<}NBdPR z($wi5#`sDzFsAjIxy_%o5=O3mM)xwP7IwN;(DpZbecav&7WOjyOO~})#TmyY{i;Fd z2-LEU1wGu-^H$xrYj_B2Yil#HM(?9Z+?!(e?lu!9+GSWuTq8GOg*VX{S-pm2j~m#! zL`M$lT|6F6=gjep+OYSVSQ}wqR{im#2+bKUb3PoMgX*)2qZx4OYKxe^Is&-bV*89{ zFzF1`j0Du6iof(5{h9(=qjSN+FS?h5-k6A(MA^2CZV50sO>76&xSvD)Q2C_$9_)Pp ziE~BW4u|(g5=WQ?8pX;jy}yB6FuD`tIB`G6XWB`vYA)4-HQFmF07j41N8^S4agF{@ErZ)oWSsI^@L)lG#7)wF*2i8l&0a-AFfCUt&jdkaYb{H;HkTW@5qW(0iXU zBs2MZGTy4Y^AuW}Ob%tD%bhrca|vC>rRaQL^YFiA!CZn{TLwNSeBB=C%U;J^Yvf5$ zC)|wWY`klgGtn-MG$C(xpJrR5?R~VFjr<=Y)n4_#x3_uzYBaYN-CG>r2PN7{wI@Zs z*7hcE+E>50y^Wh+)ZR>l*<&huy)Y@4jJ@dJk}G2-jiy1_U`N;4>~+DpcRtf5-34GT*8+?u07W zh%VY=EYqAN91Qnb)&Nnj5psC%l%3bAW<14bP?mTcMZvq;QC2{5Cd~0sA_~({I5yC2 zRAM`?zpr2;vi&X6o1AI%YP&}^*2q-cjEyKtS!hVNrJA=w>}}hhXUAXttj4aW+Jf4j;btf{CtQ|8} zzdiTX{e+%3MBBJ9H)xIPt>%lKHWy)v^}+Yr0c?J4o9Xz_^Qh10iCSKtj6ptaBSjjt zeWEu1Kll;qhyshWMD48FqImRr{gPZIM`Sa#MpT-lL}1Bn5XH8ZEZOL+z9kVRX$$jh z`^o>{-x|>-X-sNEyMNL1tMKjzjdK-kXGgPc;#so)*x>KTIMlDM^WSu3{m8HmXJBb& zv(eLSmpQSq+w3y7*-1|WGWzs<4I5O~30M2&9NaRmXkVe@SnuUlS4_9nJ&k_0F0M8= zgq!hYI=|WGtAgb7&gj=(Q4orKL1fwvYmE-2#9VCbQBj?v5cXn3v?zh1@si)ji~93{at3XP+`M@{^!*S(^N5vBT0 zw9IN4_52AlV4KYD*7bZ(Ux{3>#aR1&!l>s-Tl}s_sN2i|nWKnAO6auF^{=FBL)s5M zFDt55*MBxMnis{kp2>|pPSBYI-G1mddh}Q!+|!^b?5)v!lj_!EozGk~G?|HCE7V~g zjn(KLCpwh*r`hEns`;mx*8JPOpHZTdJZ68Zxm9O*k97TieUFpv6FMHu9RZqC{u$TQ zS#^+Wkfz!B6Anymbe=02`DDKrVvk!1hckX2y&4{)Yd_GuGP@G#TSXo7HKW~l4x0&$ z{gl0ywwswL!4s1bYv1^wGFoP`gp6((%^@Y9HA5!b(f&@isb;oGE!tR2n$e+sTAM~g zGS45=j~4Yb+SY`AB*~Kp<3q9zvw4ndF>2y|*f}YCKjjzPYq8}13Jrz9MV^UGrwBuT zbk14lY2x!!#1zfYnAw@Q-*#>$Y45zotPJY)$Tie$`@DV^UXLwIgf>PSx9)$J%t_Ju zqzd=U#@+67k2c3<_SbNtjzgzGnQ5@ySLqzDoc5Xon{?nC^fxH!__#F zkE7`arZ2$-kg@7n)W%uB*$=IK4wq<+gy|aQ!YL|D zr#HvC?61vyYoQ+D|M$68f+J)!=u6-9k*y|DTejr*S#@sDwbK8C-W8-)x5#K*Q@^pZ zrWG}>`xNGjbX=@4-=|wLZTV=X4BzNc>R~7o&3PsrqnO4Gy@=0_nV__98GH7(J@vQj zqhFP$f0?!nw=Jd}wTsy0_?Z_&Dta;0jXHhTPrUe=sC}NCCePZ?YXkbLDkgj3QK{)0 zj1lwCyvMKYY34Lue$zW{i3hkOOeGn!U)R(Ea-rQw@AZhzL)ID%+C%+o#G#!sDF}OU z0gcf;(ibl|5BaQao9(sw9!}gZ@jFSs_IsVTUt#W2VgCHH%4vr1w@>tFGRbpVLU;6W z$IUe$?Zb@I=-!7d_3X)v)6Xi#Umc_LF+TBIk4YKVO#uHBEvq{MUgRWthK}B+_Bp*K zp~-wjH|iUatnP0T=M!t`4NF^pi5I#JQZICyyPob9O`pxl_i)>$&sovqbiJ=F)I-GB*SL9Dg+^+; zXCh3$_^mP8XS3+BJ^pK3YhCkKQxw|dCmn3N>n$(pbCh3u?@5w1W6wzHGtAXv(y7}_ zwW}LDeX(6$5_jmY=1McnKi;*Ys!R@N1LjawlVz`+97vS94~WmESPAu9qgBg#r<=8I zTrf$~hD9UZ=)Y9B(;Ld;{};CIk4RZpUpNh z`8P|#V-mZ~jbg=`y31n|lb&~N$CBN*Y5M}#=Jlr=j7Lj+(PwMfI@*qU^30PQc#zi` z{zhXe?yc6wMdL2{HHqTvZ;5Vu1Z6U8;?t~<4xTq>`&2Y$qa!VJs;~M3mD(54sSoK$ z17`sg(9EeV~gw z6Fwr*JE`%WbSZYrDKW6Ol)Lq zM_eUm7||B7*;Z=|4f_mCjZphrbd@^FOI+3tBGc@4R3VVmrb*ica*<>k!`fb^hcSLN zQoCK#L4_~;N!DZT>{xE(^*$Ajufk_gg#LYQ-=Si%o-or!lWAf4x!Tg$jaidu+b6>| zwSCgs*7h`QYP?hdBSyA3>Pfak+}cNxLSmKi+sJB*Y22Z;C2uUK#wGdtB7f~Pj}ErP z7_wtSZCblJ;_N@O=OfX20a5jW6(&c7WG%(uj8&H4cGj&ZDqCS z@1W>d{~N~%_Bp-!OP4$H`_bksNRJQEq2CqM!4#^~lYZ+WhE~{5CQ-5Ho-^MdqZ{h4 zgff7yGaGpQ$w^-Pf|5pH4_WjcbJKZr4Ib!mx$bxMyIbKt34@pTFO9wa^aZFekDh_BTX!L&`QB7D@M^2#`%5fGLrU z@N*;VZA95dBO)880&*K8w{a8T*Tz~-Oq*mwIkW=tY%(trqb!C$v1aIpX_4iWEiZw3 zK=1NVSQObb7b>6)hJd;&Vo(b0Fh(<{19dX$U;q|GHlu7aeA=uCShpGLHfw<{pw4Dv zFe9?LKnCOi_BXGB255sGz>m%6M7BtUEGU37sDUQvfIb+3DOeE6OoyBh;>_%Z8Idgu zp&5Ea^aA8o=-R3mW<|C}=hn5r`mI^c@`3ePlx20n1T2bdL)kVpfbDJ2v(1Rewy8k9 zZD&Nb!`^oDBH7f-MpyQj$o6^A3X>u`;KL5c?m+pDX;1>>aYvSOSk5ViHW(H8QU=t) zfXGe)70?F@B0HA>^>(ISF7|WFf#uwBkzH8cr3hMKLgdSN&;qR6mCw8Kc~{EwvY`&p zu`&bDu@ae;WBf!TI(Dmq9++o)jlSJGU``~z0IH!IrkHC(b`^22YKIw-uVg|k^a1tv zAf`Q7w+D3#a-bfDMfS{sMi>&=%ZDl$6xkd3z008srZ}}phcajbmcJT<3SjxGEboKP zeVSlGWZ!&f20j;|r>F{gVP0gvLSWr~BO?0?lma^T$Cv$Ce?S4$1N9G>6)DbwVrT$l zz7~T@=wr9<1M3c?{(;m#a8l$T)*n;?&Cmn*P?82^&y zN9GLboq_LXp!-bnb7l?ni_{ZWeHHYGoaI9$42hhb4b(Xsy=O0qoP(}&`a~Mg(?EH{ zgvhxifZVy*IuHNOYXsstA3f(6L8nM#Dxk9wyBB0a9gKn;^2g$|e&xhxOR ze_0RAinOrY(g-6Wm!|=BFK>lOktXkBXoPhD2Ji*IEYDYaJK4G81Y5dskBT zs%&8Ss(z8Hse3hbug1pJtZ&0c8|&IS0oiMEp$@uWQsl=mCjtoG)qaDz9Ll&U>h8~y@xiKB^ z_r^x(hB=X+7639o?FH&|ra~dq0D3yn^RqN4hGrNOxe2>BHsZU5cxUweqI4> zFb<0%UHIFD{w{pzLjNz&|BDi6fdQBi`DHd#0dl{b6!{hQf5rM=v924P-RSIQUH6E{ zuT!A}S^?jFJuh-I%Qv?GG2J{Ra!U@>0s4DlPz(JczY(a0UO?{FeCPo5+={Qav3wi8 z-qsGoFelQR31xu(UdnnGL~cj_?G4ZgLoh9JM;ai12e$6$hDnh-V^9qBK;1i$zf;TS zMf$R#9H`&d4E-=I^4kn3fGWV|Z+l<_@a3*_VBKB#a~Cpqb;G#G-KkIvjetLQqo+R; z(BIz*=;%jB|BT2z)V(JgiU1q;v;ns7LI1s3fbM%+06q84i~NqdzpIB~kpUlapcs%H zz}`Ry48XX^@5#aM3xV?Aw?i*z`K-u&>44mQ4bTtMuqbjrHt#QoW}yE4V=yl=m;vY- ztOWE8cETV`z=FsF$URU5`0)V#KF|XrFeCB@fo!M%WdG0&!!QYpB7e*UZ2pmTe`MVs zM}hL87_e@L91OJqI){ct9>kXiDSNO1I$#j6^H2^@{!l%%LqE)mJWTzEOP~f?fVdtW zgIST`JfLiNQsj{s6oypu-U{e`WKrbNY$yfnJ&F&Hr9wGS=P`VKjCvzJAU}faNHb7A zG6L9nJRPw0cm*^;4-CVc$P<}R36ww41?YMLnJ0b7hX!Z^>^@2T(QK%OPM8*X3cXL& zLN8$NsYQ{esq-{-o^FLvAP>)=>lw|d@3ZMZ7b(#V4p$58P zQsnQ*{JjiXVHoB`W~ej6@=QO>iM*Ks70?dU`A0U?0XF}^`nPfcU*E#lx3KdTI%YGW z9$21b`Rx)w{_P=H6nO_7@1XM?e0!${rbONqD1;W66q)k@-E-y81pP28^3P1Dgf5`o zdoe)QdmTWX_o(wP^#7|B#zp4SpbC0nLganwzh4N%@O~Q%!Gg#K8Bh-B{a{Aq!*nPB zWIsgLht&I!dJ8#F13fS$^6y+|fB~2l`47wgsfKnKg+-B%u=f#lKI#)$#Qq}d7YAWl z$S2dKePN$%HzX5y!28ZkQCu%Z6GQ6vt14CUF9$ zPl8r)QZj(LDFfmxqu#PMaZ-x`+0+Sf)=7s3=z=kr6K7q@*5mp6>vh1QIB8YD`m`x= z)*^oLLHUjI?vjE@H`vF}WRYIRQ8zZxE88m?|Pl~fi zDii_!Y%(TJEC=df0H(xQ&idsAfSu(%FeA>U#Ik8S48y!QE3mzy9Eg1dWh-XI$%p|y zWDJV4SsoDAW<%m^o)75W0=-)xvjs9+AhX51IGH(61=P(Pfdz54EQU6i7H2DDw`vCb z+&Tv6-?~qnEFY+s)d;NHCKJ%RZ5mK#+fi}0yJBb8GC=RH$n8p5UJQ`UYXdPhXn{VU?w)yoAA2?cb@!xfFYN4vFMG8@KP-x~ zcMg;S_4XbC{3$GiS{Q;kahPv#zFGuz&<^7;FU~%>K)rps#M##emiH|KbnQC;#8QN8 zQ9e{b6W~kHC}4X({Mip%`{Db39WVql;_ROa=-MBd{ac_PC_jMu2b2S42lT*{IK}Be zOw3U@#l0{N=>8h=%vCsF>w+ZQ$e1{XqW@6p9oh~P;v9yK!%CqQ&{>uV z$d=UrddvD?Qk-w1CN@7vSj9Et3ajX=E${HdsdUU81fflhIbjsgB2!}~G3S5jVy-pX-tj-~9_ zdKePtIAo7Q_PBm=j;H*1J|Eu=Q{q&mLpcyr)u=cpu>OQ<7!l_?`1u{)Ps|7GR->o7 z8L0Q&EWo$#PK$F=DGZ78J^cM%E1K7zYhhBHQ?PT&tT?9o2Z`b{H1t67*hD1IS-8B~CLrXl8wLBT%OqJM)rsJ z`ojvqhaZlKbE!Z+VEb8_Z6Z8T0n4@qmNAKme z&;^uT;RAkLfvqcAU;vQ+Q5Mtye*I`foYoi=LIZTbs5nWa}{z|QN|pG zb5#>y`>F|Xn9Fdk#`e`Efc>k{%bbSOhW$3`wza|ljKPdJ*Q7xa42kn&iCU_zWbsCQ=`G{KxWeUx$T z?);W_&exs0@bfNY?!x}v#el7TA1Yv2oO?0={r6D+Ue@2+35(+Vt`n8ifc?G+# zp!bz#7!l_$=}-)v;=GFAucGHw{X8$u6#A$5JT)oKYq`)0v*P@f`hRVNQE^`PAs_0X z1JL<8veTJR3GFa0&Kog6-y5AUDbC;W0eyc%-{1NC_gd(M8F6N^0DUuk!19|p!1^}_ z#Q6vI{!s$mFfYzqh0p>+;>;4;EV^c^0bR4$c{>xz0ex@dALpUY+jHW)gU)x*^G-9M z_njGW-o@^_)P0w-cSm7S9L__XIrPnS0{Z@$0cFqy6XLv=4lKXN`uEWLuOeXGyg&sE ziSvFQw8FGFA7GR7Oy>i9{}8zk@pB;^8em+Ue-{HX|H+0Xm=))vQmBV+7=s0I77L&T z+JO3t==(SiDEk;+J|><|(D4aAe9{hsfUZw7pbU`vbVywBAs?!t6UM}K(xC#{U{YK+ z2Bpvf!{U0#cxAwPZ%SOh0Ga@O0kQ$I0d<2xm=iZ88)~2%X2o5W166>%WfS72W&-O| z2gK!k)Lo|%x?oz|b#tK(M#WtZJ?l|#y?$U_8ggl6fbFyqao0};d|AI0#>L$LT^pcl z1MF@vDei{U-w@w6Y=bFr({lhn(g(%e2-%HFpc7`q-I#S7*8sLQUKDo|lXaQ%;%-?4O@NK9Vo(izupsW%<FiE(_v* zxfnWNQrum002{mZi<^f`9x{2IFeC2DY^Z@gz{YN6&<+#g?oQp^S>C-BM#RmJK{@om zthlRKzbYTlx2gq(U`E`pWIzctz^J%;qyzQ#s0HlqF)nU_4|z}teXtF!@B?g7|4AP;JwPuyabi_u>^BktFz|21?Rm@Dom)l0KKK-;vSL-tUIIyi04p&B4`J4 zbXWn@0J4W+vn(61TZVkuAfTg+@^4nbn7H4<*0&0w5zu!y%ZDR>cqjD3q`2k8UXIOj zbZ{Q%9)ZpykUxU;M=Xl_?L4RhmcLE?BU7Om$X7)!)WVdwMH%@TOTF*rK^b%dwol3e;y$Sh zu>HMksDUAIYf_;IYM}?l#620kCzn7S^ue^ar(^;4Pici=SP=KrJfP00*gbVo+**?R*V0q#h?(XpaYOSjdHGIyQ}M=U)=AfK{=p{b5ZyELog?99d+s`uWJK*IK2!y z0b6HKeg>bwjO&GOkzFe2_b$emLI#N8lJ z1o+s1&U14BxpT+FJ&(`l;lp`DfbH`Op$Yn7M%>0sz_-R$7!mh^R49QKVEG3zs0Qj^ zh@A_|p$F#0ZNg>~^_sBLv>@(9IZy%EyNLQ1O^JJP4A6gZ7m$Zbh~X0ST|!Kku-uGH zGcwJcFe>g3)1UxaVMN?ZbD>?_%dmY}Eewj=LY+}2E}f?;v5Ooc|65cjGIVExtEfb7+sKzW-FMS$(LZkQ7H8hpN{2D)HY z+#lyd1N4jglQgJ?Uci_365wb|9~Q*DiRGKnchiixKd*pcal7)M zL)>4aLLgtA1sL5Qx4Sm zO&Zj|xVX1s=hjYO{cY5}ZB*Re5}@pM^xw|s+uHyew=ar&Mi)u?p;1Kz=XJW7eEV4irb$H%`hwOJ*Chq?!9SH0o_3T-=#tsbikCj1Lz#6hhcGl z&*$Ga0rl?7g*xbm1#$03-~HIRe^lJTOrYK%F+NZXoq(Tzs0PaZSOAm_`GAfgbUzq_ zM!@DnCD1GG!{~Xq8K%V@E`~vIAIXOO6)&Bh(wgpOHy% zAJ2wbVBHhQJ%QX4$UTAFlgK@Z+>@*ujX^c^z^u4W;m1?mFfZ=Y#n1_SekLF4VMN@q z3_$l7^3U@5S#&+i=jT$P2B`CVCQ$x7<>NkJV|+;57qI<8BMgiCC;a*odj2#j?u(Sa zi2fJH#GS|m$|tD*QVh`Z(zv*PCWn9S6ZhpDXcu=;`bDPU(h74TzvOx!mpdxQ0V!-v21i2L^} z=oEK``ZJB38swgGkL zY5;rxEP(-W-^+mxasNe~fAxqvkKXw%ao^|teU?ASfM#(&OobM47tp)VD(=52|2Osi zP3-?EfnMPAM-|X7?jrgY>tR6LkMZkc>U>Q7kB4DS+)rXq2-Nvx22IPI@{Som3R6h&1N`2gACTE#QM?Vapc3$9L*&xap#Z3xPFXtf zr%#Eu5xO?Y17hC@-5ZmOjaj$xym*^Xz6ts_X#jL@LQFC2#>xTN<>*`90$qU2@;UJ~ z&4wBARtS^;vMYMT%gBIw7=s1zHp>C@Y}N!LK-uPnFeKg<=}-p9ZqWyG;$>z5zGSul zK4uc*mIY7+)Z4NXhGAB`t&rae`K{`p8z#luIt{45H9l;)=*=1z zZ<|bLf>H6dO@&H8&vty?t`Vq{T?l;69uaSQ^lV=PJ>u<91g$VH-i{T}1=Hf?}Q>gVS|EsTn{3b|GN;&CqKeFfP)1X#BR_4b$*uOJVQE0_~+ zPyF0-M7+IxpzdB{;&IO9?VSxpPzM9BAYNfHv;uX$8UxmSwF9uZ4>J3d1IznNi?=Vj z_U#gnb1kokdPNiB?N{XFzg&QC`{)7@@0L%x^I>PpE=L+zSRKua5!}iCziumKD;0Bp*#=J zQ9dHx5iwx>5!Hb0BL)Eb-%f>msDvT$j?4kpA2}ypMFk9s$2pdF6!wqm74K*tssQ<8 zuzw8tj_CpXuS9=kIW$7Qc*kZz2{glmc*kWxF|@#_c*kS&cx)X%CSDb~s>+}f=EOSz zxf9TRLK9GS0`^XrghlbblLc5nU&ah*wSUv?Er_73XY6mQcSBsrm)}4kQr_};-tEsbk zQoQfy19rY&51lX!l-K!?1qDzJbgV7XyTymM25 z<#WlwxyYP{pXW6Kde3Lw`Bi`~=P!uYNWDhnE)b}I5%GS|Dc*(k;x!eEcTomRh<7n{ zF2QDVHcX56!*1~|MdxLC;_2k)ga#0MdGzl*0vzt zHACY4xI?_3)QH!P{I%4(7Q5F`c72t29h7yAF;2&n&?255&q7=;<}ZuKDx3IV@vMdz(;&$G^cQRg=F+*Sg$&y1G^ltVqVLqCkeym+_AARo%19@?QF#$jH(J7Q1(_;?4t-_Z#}fbBc6eP=F|1MBYW zhEYJSFB6KP4mtptK4SW9I-u{jRnP*xFb2rnl>vpoy1Sa82gYGRyt~nNH!0msPz2P!ryWKB8~38;-ZG%>z101kKmpW17vRf47SzFvc)w4D z94LVrXn`IWff@1c!~T8LzYo9f!-xBjyN^2eq3b^M--o{YsCU0W2IN5rR6zr@K@SYU z1k8!|K!JFFq|OjN4s}95jKVZ5iuWLT9;D8Li1#Qq zA0rQsq3^LCz}92v8mWXy@g7Il8({C*Y-j-FpG${2;Pdm?f4&m>#T!qBCh=Y<27LHa zDYS^kIg$4wdS1kr3G_^0>m};GMBSI>#QXEOcrRzdn0S+u;=RKAUs(Q2HH?V&ssOrP z?GkUQL%i3Je{Dv*zm~%QOpEtA^POaeJ=;r33Zh0h|86dv{>vvcXf5#$dfidxOSf5i0&48^hr9l<60rkH$EB;RSwo@IjywimEJEsC= zJELP~mUD9ed%3-^ApS1J&n!VFbMPF?^+1R?K&=gUIvsxE3nLYfWMNuE4yJ* z{N1vk9NJ(;{N3{aKX=EEd}Q-$pdChFQT$ao&;oj~B6K2HUBOj`P`kW{DoG17N zF=znv72x-t$nRMPy@1SK*xw78z3^|ZN%8ll{@xXUjlHMDFH8k&6n4Wn%!~ikG$@7| z=ofzpO{BNV<+t@i0J4a%tA_E$M`bSa!DApaF4_)FPlLqKIW%Z8_;tG z>(0RD8R$JT1B#&;I-wuN#jh7&T|M>d8(>QOvtm#J)qrnjO^AQC54lhd*gmHYSl57$ z4MVUf{<+jYcUJuK$^c)^PXqitza9p~Z$xin0pM37eqE3W)V-h)x?ouRA7J+f$Q0Jm)@h?sXWG}9QW}x21$X=2PlwX4FOWI)s z7R7JQgJJQ1$oe04h<_B~mkk2?Te1Q9%YA4C>Rl0o5>RvG_ z{*RFTQ3J5PH51C95qf~KE0Mpl0?>8kocLF<{;ED07yoK};he+2x*4#0^`iJ~g-{L1 zUxVy5=)Z>bKc?PK(9vEg{sdKebJmvy~k;@@5d$lcE8JMw_fcZ`dFX9;wR-$z*=G91tQzs-RTm=yo6GC<#5 z{V*;5-5EgH-JO6h{h3e-jW7h%xraLU6hi~_z?As+#-I==yO*+i$HeD2-Tz%aw8FUf z1FRot2YmQ_0n`CH?@NUupx%8W;&a^X-;e(L`(aM}!73OQ|A81(K(F|J;PW4-{|D;- z(Fe-^I3WHIdWX>YU=~yY_8!EShtT;D>mI`9L&!fgDgMLAJ&aEeqyOPHK-Vz!hI60{ z8lVS|e}wW!il7NPVF(t*f0Vk9RzWjh|Iu0TAIpSNz`w@^VL|+nY-j{x8W|V=acn=H z3)p!aosahcvQMDz3G6w}O|MZyn z&*TGo#;`Sp?Xh9;pG|{im>2)K8kiLSdE}o*emoagejx`s#s5<(bO3c<3&<}Z_ixtyyAqmV1m?v5PZ6}il=vUz z0XjdL5q~iiilGtEvp6aK#{!gnjISSK>*HDRKf#wzN&%gp48o%LpXLH}KJ9^N2_z4y zpc_UdaC|6(M(6?RxVgZx+Xa&nco|RvlzG(g<|Od5p$0l&M1nw|5E@_rW+g~rIi(JI zC0NG#W%+=PW$0KoB|$2_q*g&2j7hLgCQyGJbgnZg!MZH3TMEt42a6J{mj~5Ao%O~g zNQ*%^u$+dD_3>-{O6Y=l2{s^>4H^KO8%#^EVLssZhMmB2I{MO^VO)ZZ3ZPqpjeV#F z^lg#@$i`yO0+SLfFNS^zHqC%W30CmFq8=6`$Ut`na+_rW>oz0K%?qI&7A4q%c(xdp zAQQhbDa)LcU`y<7*$ML!Y{h!cL4vIX8i4g#*vn%5HmN|_Ht5`zvTX+>*e(XF%T9+n zKz4f{s({Zspl63l=$2qd>h4IL9Tz0XVSNsIzElmo?^FT2?_35m668`ZcUpp73ZX}W zFK0j#P_`>|ckP!TuK;=hzgMO~Hc)?MIn+Wk;M+>-t{eqqS1wAhTMTlc7%HJ2TA>>T zVH{>9*xiRr$cIv>hDKkldg<`0LdT51i z7=&?{mEbErWI{faLNzo(JM_XZOv1bbd!#`&6hb-FLNjziKa9dOEJ{!igIp+vN~nic z=!QWUhgk{s^dS@Sp%kj25!#^_hG7!sCDqpvCx>H+yGYY^ z1XuEY<&Xqd6+o{9SEoa(1Z@I!Fe$+`+0X#gyJlX3AD04pevJN~Aor7Yn3kZO&+Scs zZ`b1IwH1KR*JS{8u3M1cddjXxXGa-y0)E|40Qi2xxCA%mLN)YA@Y5L7z?cM`SfYWd!5!$lgLQYN zLM2Q}(1*W$0}}i;9h!jpcNGAi??T7j=)1dLf_{NE3GRtOy9D=U06Kq{4P6p&Eg%>e zmf-hgFfGA-)e_u~Z}(H@e(VfpLXiZ2AeKK&NH8=g!Gn}NSP!g!C>Qwr(1-*N!1^6BzPhhYJhc5vhGRB zM^m8yT3||or}+F7pPw3+faCe#=_VkKXDELLy&TgAWBJe}!L!IdTLX&{a6BJ8H!Q*P z*-#6}jF$ts8efp$1wM0JANt`{kPkvbFAFe<@I`1w)?%u4WQ?7y4_ zwSb+;66lfO70O=W^DB)oD#2fn{mY;PuVz34^a47kkeiy6;5F>OHYUMevjLgcQ=t;j zHJt;U61;)z8}%?Q!QTpDP=dc>?5*!vinkE#0!>zTI?K1I)`jW8`KQX?r&0nA8>TPG=ACe%ubp97te5~M+cq@+;J zad%3}prmljowAJg)G`>Bly$11S5nsX0e$QCOUinAz`C?j7?+gwDPN!W4LT%c!$L_( zr*8VJq-=!Fjiw}J<8n#aBnG3B62n#uf0j4GyrgW}4%3pdq8R!lB}1S|QZ~zgZb{i3 zTbm=d1#x7eH?vn#wyc+wt*T&7Qnt>A7D>s%Zq|^bY=fR{(}1#Vv9nz(pf@`ks$oo0 zwx{m)Ba*TMdUjxW$5I%Sl$=bMkd!agNy<)nlCm>;cE-P4e9G;V6z0fNzMKOClCo=w zq~uXQuUk@9rb8{XNy={2+Z~(v<&v_h2*xDkD>X1HDSJ@2pb+{cWzSqd_g*o;FOIQN z_HKe+7=|fWl$64(|3}(efJc$M?cS}`?lRcouq?2UneGWLfdqGV2oN9;5+u00yX)fa z?(XjH?#?c|!0uO&=fAt}d(Qiv>s)8K?o@Smb=}o9J@tE@*-07;UwdKPrZDciFg{lJ z0Tw=11dpXi6Re?FORz2ws3?zxJ&M-A!u=J+V=apNDn?+X!-~dgfYlRgCKeuF@vK-o z2o#0ODBNEZ-XDd>TLO=%1RiIJc32y*@Z6O2u|{GYAW$@eRR(Jy)(ryT@5Z2*Xsl$c zJp?KxV^zVz?Ms~?P-#52(h*oSuqI+*&(aSFR0g*zgZGueK4n&5;eBOOVd1{Z;&aO$ zAyB#8SQW6kV&Q8l_lZE|8(`tFmVZK^3fQ{>_NsvUt#AMfAFqhdsn{HAEEXP5#Sa9k zR2ZuX7Vfvw8Z7KpS;s1lm4LMZ>jr_UFj&!81F>EZsH%_E7wZCns^!4KUe)kes^NaC z6Ii(4>iBr|Z`)r8R3kqY-mb9(3-^aVOGh=EV{IW&E!=l4yj?393vbuP=hv=-H5BUz zf$G>;xNRNmTempYM63@4s)y_KaJ?ShkKK+RKOHNnDuakw6rfc35Zi9juIyA}hn&JYO4uBavMw z9=DIbL7>*n3Dic%T0o$L+*tT}+TwO?pAaaqFM*QMVT~nFI|geY)(Zl)pGlw&5m>lw zM?8j(xGj!5QKyVpTL{#-3>NOY%Txm4SQB-{=X7gFpzgS@?gy~&c8^q8(O7tnddgTe zu&__hD+KC=`{~sR>j;5*+gNq5uxD?4ULSm{PhYGP1nSFUC1C9!P(K|D_t6jc*AE}- zkNfXG66*|s2IR&XiuHg%1Iu8oAkd(~Sa?i>@cuzdu#RB8A<$s#H@G-f0@he8Jl?^d z2s8xuH^j$kfQ9=Vf<1@aAka`A3-2F__YWP2wE^n|frjC64l9F|j5QGpw;y(gK*MqS z;SpH4{cya0IQGTyEE<8^kEnpv6>9+&-aq0CfkygRxb4WkSa|+z608RV8jt%P-wF%&JN^cNCg5wF zfX6TaAD@8RPsHsfCSa|=!rPOu*Q8{uJy;(IG`S2GK0bL4))fLxv9W4k&BQu_^@TuF zvtl*C8jFS7OvBsLs$jLk!uzHz!TPozx1F9F3m=<45^Dz*_M8!ch5MiJgg`iMMlHqw3xt(#=^%JpCHf@JccFs_>z%WTd-abXestsnv8|}UyA!*mJX{c7Cw$+ao@{@UgW=2(%9Oi@y(q)~z7WdfX3=+tGS_Z2cVqZNT*nYY4Ovk89&p0&T*_H(}4s zG8R6zc>#g8V6QF7SSJXy6?<;Q?YHSzTL`q>#=^(8W1k(kj~)2j9ajjnGXiTQ))NBl z^09^zXg40m?sixY2($;6dp;0oFK)jNd+i%bp#Av#{dKUmV0|LcfoQCmSZ4@yP{&HZ zI)L?pK!deHgbtg3mpI_Z`Lk9c_+<+aAN-$7*2pB+&5&1UgX|3-@=j z4Aw}jJp?+1`#zN)s|wastUClc&0yj7r*R)=aDQiTA7^m;GfxO~HV4*3tP=#n-@!rW zBCry$@V;|L2y{Lj7WO}n`#OJtKo_!N;q4162y_wGFSf$kK%h$*vGABL%_Pue8w=Mj zFTle7SFp#GCRlj;$_D~n^|5+ly&%xF3Rw7joCBci_?+vw-y67o1AE*!Kp>n4pqmx2 zCSpAy&@FuKt)W=Bej9t<#{J$tL7+Q$?04`r-q}K+y95^Q3xDR1?%7z$Sh&soR9FdE zE3m$8e<09l#EIhUsc>4uD_a*MSP57g zupSWT9X{_}b1dxl9=CsAgCGcpqzDq11pXQL{_|U%A~?L2vY#gM5b2@L;Jx^_)4w$# zSi&TlK^@_zCv<{3Pw2#Os0+A09qJN(YSJ>O%ea0V>L%{<1wj)eBj7!GNE+%Cp^`zU z(?kQZ7}OcuW(L$*A}e_m>WIimzJxkYWTXO67jQiv)Fq+>RU7Iuu1_l!-!-mz$8H@n z#&m5Km(VdjsY6CDPeiaNW|dnW_V8m-ijxZhz@w4hi`)jB8dNzbR5wVzt{;x zEZ!ge{bxMhmq^sY^@Q)WWPDa4t`)@R{onQe?Tirii6HX*U!GYD`*ncvCjM)@5&u6u z{;$_rmiYFs>3_MdjQ^V}`}cMK?~b=3lJUQGcn0#~e_g)+%R{vIZ!;bDzsz$UJnuhhD=MQBYz;%lNrd2WG4J>!k;bRPYpPN$4{RU@e^WX{4^95KeI*0 zPgODTlO}AuI=J{g{X>e*Xl$K{O8PT5w(drL|yy@j`~Ccq9M_UXpH~=WGtDP%tB@* zvys`!AITi#Ph?Iq7nz&C&OeUnUBm*79b0fg~-BW5wa**j4Vz@ zktK)~#C&2PF^JfSpM&v)7)*>NMi8^`9~WLgmc;AeHDUlUfp|x}Cq|Lc#86^Caf^6M z%*HF>N8$tVD>08)NgO2(6RYq|*Nhm8--O5UjeLYSMw}*25GRRK#8Z6RoF~o@XNlGL zjrWEahySSQ1>z#UL7o#YiD5)*d{ec-w@dAh`B@`qBqf(=!aL`SHw0lhAc&vCd-gz$#TS3;!mR- zg{(?eBde1&$eLs=vNlyr)0hGZk+6Y)FQm~2AEl1<5GWOFi(Y(cgpTaoc( zYqAZQK(-|l$t2=3*^X>ab|5>F$z&(8GueggN_Hc=lRe0uWG}KeagVr9_96R{{mB00 z0CFHXh#X7~A%~K~$l>G&awIv5SVOEON0Vd7vE(>%JUM}!NKPUrlT(P##24ZL@sONK zP9vw2Gsv0bEOIva3pt0JOU@(blMBd&-d6m3IUMFvmH_2P%ZSoFzm%K;bCm)ax$w%a4 z@(KBrd`3PeUyv`!SLAE*4f&RQN4_UNkRQok$=}FNW{EH$elAsxVcADoPcj zic?Wk392L&O~p{9sM1s!sw`EGDo<6QDpHlG%2XAqDpifDPSv1lQnjesR2`}=RgbDq zHJ}<&ji|;{6DpQ!N;RXJQ*l%aswLHmilDisJYZUYCg4qT1YLT7E?>8rPMNNIkkdXNv)z* zQ){TT)H-TCwSn45ZK5_)Td1wnHflSygW5^$qIOezsJ+xaYCm;=I!GO&4pT>{qtr3# zICX+LNu8ojQ)j5N)H&)rb%DA_U7{{iSE#GhHR?KbgStuGqHa@nsJqlX>OS>=dPqH@ z9#c=Kr_?j*IrV~iNxh<8Q*WrZ)H~`u^?~|G{Yw2tTp{jKpQzudKd8^t7wRkZC-oN& zhe(>DX_}!~8qpkaowz~VB<>JbiQ6C3!RnDMrWsgq;t?e(K+c{bZ+`*IuD(fj-Z2di1uio4%3lz zJ~}^LfG$WEq6^bS=%REnx;Pz0m!M11(R2)5iY`r;q07?c=<;+0x*}bPu1r^U0gdCS8lJP1m98()H;2bOX8}-H2{XH=$$crgSs9IUPs0pj*>cm(wfgmGmllHNA#jORuBX(;MiG^d@>Uy@lRNZ=<)kJBgUlk_S2G<}9XOU$6p(dX$4^hNp-eVM*OU!||n*XbMd zP5Ksno4!NerSH-A=?C;f`Vsw@enLN`pV80h7xYW|75$oiL%*fp(eLRG^hf$v`ZxL$ z{X6{!{h9tkf2IGV|6&M+WGIGa7=~pK!!bM~Fd`!{GNUjmqcJ*TFeYO$HsdfZ6JSy? zshKoPS|%Oy1CyS~z+_}HF`1bxOjafv{=)c=_)FnGF*%uBOm609CJ&RBiC}_Ei18So z2{VyQJ|;g?fGNlnVhS@wn4(NErZ^LYzo=Z2iDqJ$QcP*43{#dV$CPI(Fcq0fOl77D zQCN%VoATx*=%nV_M z;;(QHXGSn1@mDcNGh>*s_-mEpnF-89W)d@*nZitErZLl*8O%&(7Bidqg_*<5W#%#S znFY*3W)ZWPS;8!3mNCnj70gOz6|nc2G3%KP%tmGtvzgh#Y-P4F+nF8APG%SW z8sHvgFS8GSt?vMHkU7L0W{%*m*&Sn!Gbfmn%qiwH{vzC2<{WdLxxidxE-{yxE6i2q z8grew!Q5nSF}ImJ%w6UlbDw#@JY*g*kC`XTQ|1}-oOyx2684ID&AegWGVhr8%m?Np z{$kf}%qRR6u0NR1%opY>^C$BcORywMu{6uDEQ?r<DV9G^lSz;Bb$lM%w}P;vf0?|?2l{?_9r$cn~TlO{>$71tlFi5FXA7_e*+Oh#wg_94EyfmSqu3H`Nj92|VN0>4*)nWdwj5iYt-w}f zE3uW?Dr{A@8e5&M!PaDJv9;McY+beUW6b^<$*oy1ONr?6AmY3y`%20N3T#m;7bVdt=O z*?H`Ib^*JPUBoVCm#|COW$bcx1-p`6#ja-8uxr_M?0R+syOG_*Zf3WzTiI>wc6JB5 zlikJcX7{jr*?sJO_5gd3J;WYnkFZDCW9)JE1bdP_#hzx*uxHtG?0NPAdy&1wUS_Yb zSJ`Xqb@m2(lfA{>X78|f*?a7L_5u5leZ)RypRiBaXY6zK1^beH#lB|Wuy5IS?0fbD z`;q;X{f+&^{?7iverCV0U)ev|zYu{)L?Ie6h(!o-h(`hvk%VNVAQfpyM+P#Hg>2*? z7X?r%lp3W$X;C`#14@rFpo}OJ%8at0tSB4Gj($Wr&`&5Q%7t>HpHUu^7e$~T3Ly{q zD2yUeK9nC7Km}1DR2UUOMNu(S97UlLs3eL;F{l(Ojmn_1s2nPfDxiv}5~_@aN)CcuN{ZM~201ZTg&|owK4MoGya5MsqM5EAX zGzN`D2%fp(%@XgAt}_M&}gKRSR8qC@B~I)aX( zW9T?Kfli`R=rlTm&Z2YZJi34`qD$y9x`M8vYv?+K6-#2qDSa4 zdV-#!XXrV4fnK6l=rwwS-lBKtJ^Fw?qF>Q(=o9)K{eeECFX$`!6aB>z9LZ4}%`qIy zA&%pCPT)jN;$%+YR8He`&frYW;%v_0TrR++;!<;IxU^h4?guVCmx0U3W#Te(S-7lR zHZD8&BbS5wiOb35;&O98b9uPDTm%>7LY&9>T$qdG@^SgO0$f3^5LcKh!WHF;amBeP zt^`+-i{@guQe0`S3|E#b$Cc+Qa22^qTxG5bSCy;ARp)AOHMv?`ZLSVim#fFs=NfPg zxkg-Lt_c^*HRYOd&AB+P1=o^m#l>^2xi(w^*Op7g95P zag(_z+*EEFH=Uco&E#frv$jj5tGPAY zT5cV;p4-4}pQZX36q+rjPRc5%D8J=|VyAGe=7z#Zfcafi7h+)?frcbq%H zo#ak&r@1rSS?(Nnp1Z(ZSnfWYy zRz4e_o&S-~!T-eP4&G_bg9N&U($+zO;`PO_JK7nt`C-O;rJH9>Nf$zvC^PTw4d>6he z-;M9i_uzZ-z4+dIAHFZ&kMGY9;0N-9_`&=TekebTAI^{9NAjci(fk;GEI*DP&rjed z@{{<<{1kpFKaHQx&){eBv-sKkFZ>*SEkbui#hmtN7LY z8h$Omj$hAj;5YJ{_|5zlek;F?-_Gygck;XV-TWSYFTao9&mZ6q@`w1t{1N^re~drQ zpWsjOr})$S8U8GPjz7;|;4ku*_{;ni{wjZszs}#_Z}PYJ+x#8=E`N`|&p+TF@{jn( z{1g5u|BQdmzu;f;ulU#e8~!c-j(^X8;6L)e^1tz)_}}?I_|N1Ww=uK@bH=kOf6h1x?TeLofwPumwkOg@BMsNG+rh(hBK>AB6Nm1|g%6Nysc@ z5wZ%|gzUnPLJr|4A*YZ_$SwRVVRVSq4D7$gi9h6qE2VZv}>gfLPVC5#rv2xEnD!gyhV zFj1H!OctgHQ-x{5bYX@tQp7Jd=t2y=yb!hB(YuuxbeEEbjsONC{^a$$wAQdlLd z7S;%Bg>}MuVS}(y*d%Ngwg_8=ZNhe8hp%Ar;ev2cxFlQ_t_W9!Yr=KmhHz83CEOP72zP~h!hPX^@KAUp zJQkh^Plac~bK!;XQg|i27TySNg?GYx;e+r|_*M8#_$2%;{2_c6z6f81KZU zq(w$#MI>?}FADh4u97H=il~a3sEdYZiWYt_tRuQ&Kujg37So7n#dP8i_(`xC#EfDl zF|(LO%qnIRvx`6CN4)+d<`i>@xy7HwJYrrkLJZ=^DSM(XhQ&xRpO{}PAQlu0iG{@? zVo|Y}SX_(}ONb@KXfXyqb-T1!Ml36q6U&Pg#EN1iv9ef2tSVL$tBW05;&btZ_)>f&z82qzZ^d`wd+~$#QT$c>P5dPOF8(2Y7QcvJ#XrTr zBtjx3N}?r3VkIPT5-$moC`pnmDUvE_k}esNDOr*&Ig%>{q*PLBDUFm?N+1QdAlvj$7f>KEGBwq?kky1V>zf?dfC>4?l zOGTujQZcEx6eX3AN=ngEj8sZ0EtQeVO68>TQU$4^R7t8VRgtPn)uifD4XLJ7OR6o^ zk?KnIr20|=siD+JYAiL8Vx^{1GpV^0C$*4TO0A@LskPKbN|4%0iBgi(PHHc8kUC1q zQYWdi)J5tlb(6YFJ*1veFR8cGN9rr}lln^oq=C{PX|Oaz8Y&HwhD#%)kv@}K< zD~*%JOB1At(j;lJG)0;!O_QceGo+c)ENQm%i!?`?E6tPUOADlh(jsZGv_x7eEt8fL z>xlKz3TdUZir7SKCJsoei4DX?;-IvK=uhk;hDd9rb<%obxwL^eByE&7Nt>lD(pG7k zv|ZYPA27CC+9~alc1wGtz0y8uzjQ!4NbHafNr$B)(oyM{bX+>Vr=>H}S?Qc~ zUb-M%lrBk^r7O}^>6&z1x*^?^Zb`SLJJMb0o^)S&AU%{GNspx`(o^Y~^jvx&y_8-_ zucbHATj`zjUiu(?Bz}{Am41^xNxw^fNS~!I(pTwE=`Wd(Ntu#qnUPr;$(+o~f-K6C zEX#_l%9^aphHT1~Y|D=9$^ki*oLWvJrL*-%eaCwA0QXVCbmdD6r<#F|*B<$3aaVye7AUPw$MUdxM!g~WJyvAl#>OpKA25)+9@@-lh3 zyh2_nuaZ~GYvi@^I(fakLEb2Dk~hm+F|#a0}}RRT&XCAE@9Nvot&eo)dY z8I+7lCMC0yMaimUQ?e^RDmj#&l$=T~CAadkl1Is_L?}TeqQblQe25rN+>0jXeCA|rIc36C}ov$N_nM%QcmrY zR_Z8qm3m5jrGe5=X{0n(nkcbKQ>B^GT!~X!C@qy%O1#oqX`>`4ZIwhNNol9FS2`#i zm1L!p(pl-EbXB@3-IX3nPoy2?Wsovh8KMkThAG395z0tqlrmZw zql{I?DdUw1%0y+7GFh3TOjV{S)0G*@Ol6ibTlqzqqs&$2Df5*D%0gw4vRGN7ELD~% z%as+%N@bO@T3Ms4Rn{r%l?}>9Ws|a5*`jP!wkg|{9m-B+m$F;gqwH1oDf^WJ%0cCj za#%T{9951f$CVSxN#&GsS~;VfRn95rl?%#6<&tt)xuRTEt|`}*8_G@PmU3IUquf>Q zDfg8J%0uOm@>qGIJXM}4&y^R-OXZdFT6v?qRo*G@l@H2C)2-0IJ29yPBTp$65E>Z!gORwLDXYJRnV zT2L*d7FLU>Mb%#6nC25LjKk=j^oqQE)n00EwU63Y?Wguv2dD$pLF!<2h&ogqrVdv}s3X-; z>S%S0I#wO0j#nqB6V*xTWOa%i&Q}+x3)MyHVs(kS zR9&VnS68Sj)m7?hb&a}KU8k;BH>excP3mTKi@H_arfyevs5{kN>TY$9x>wz&?pF_} z2h~IBVfBc5R6V91S5K%X)l=$e^^AH}J*S>mFQ^yQOX_9yih5POre0TXs5jMH>TUIo zdRM)t-d7)}57kHNWA%ypRDGsCS6`?v)mQ3k^^N*geW$)xKd2woU)A5#PwMaLAL?iI zi~3dlQ~gULG*Y89T4OX;LmH>?nxKiAq{*71shXzgnxUDRrP-RJxmrL=rKQ%=Xlb={ z+7DWKErXU(%cN!2vS?YgY+82hM=gi;la^D#6n9dTV{OzFI%6zcxS{s14EvYeTf5+AwXnHbNVz zjnYPIW3;i_IBmQ(L7S*e(k5$Dw5i%OZMrr?o2kvxW^2D_bF{hIJZ-+VKwGFS(iUq= zw58fIZMn8WTdA$mR%>gtwc0vuy|zKysBO|VYg@Ff+BR*wwnN*g?b3E@d$hgUK5f5t zKs%@%(hh4!w4>TF?YMSAJE@)0PHShhv)VcBymmpms9n-7Yge?Z+BNOEc0;?V-O_Gr zceK0OJ?*~sKzpb?(jIG1w5QrL?YZ_sd#SzBUTbf(x7s`Hz4k%-sQs$_rhU?W*Z$Bx zYhSdl+Mn8AI-!#~rPDg2vpUi_o!13j)FoZk6ir zr_+DX)9V@ZjCv+Lvz|rIs%O))>p$u_^q=&cdM-V;{TW7y@Fm*ucTMjtLRnrYI=3O zhF(*zrPtQ$=ymmadVRft-cWC(H`bfzv3gUznciHF(_82*^;UYk-db;?C+KbUL_JAw zr?=NT=pFTBy_4Qq@1l3ryXoEa9(qr`m)=|NL!8t5>izWo`T%{PK1d&|57CF}!}Q_$ z2z{hJN*}F{(Z}lJ^zr%xeWE@|pR7;Or|Q%6>G}+Pranubt^cCW(dX*(^!fS%eWAWc zU#u_Dm+H&(<@ySJrM^mEt*_D7>g)9N`UZWYzDeJ#Z_&5v+w|@F4t=M-OW&>U(f8{6 z^!@q){h)qGKdc|okLt(tgV+H`UU->eo4QqU(v7X*YxZ94gIEm zOTVq((eLW_^!xe){h|Iyf2=>zpX$%_=lTo%rT$8Pt-sOV>hJXT`Um}^{;U3*{z?B` z|3m+*f6>3{f9ii3gh3jVf&Y4{!5YZm4Bik7(U1(;Pz=@34Bapc)36NNa17T77^#fZ zMj9ink%BEtfre^AQn{j3fv!&U}j5k}GZOjC- zt(j;hneEK>W(TvQnQV44JDXk1u4Xs0yV=9+Y4$REn|;i_W<~bH2I2 zTxc#b7n@7WrRFkoxw*nzX|6I?n`_Lq<~nn|xxw6MZZbEUTg#!73YvwpDBTN$j3RwgU6mBq?xWwWwdKUz7gpRAl#E-Sb7vz5onYeiT=D`a_= zZ-uQ$E1#9$Dqt0~3R#7%B34nWm{r`0vPxJbt!OL8DrJ?n%2;Ksa#ne(f>qI~WL37R zSXHfRR&}d}Rnw|v)wb$bb**|#+G=AZ zSZ%FDE6HkSwYNH09j#=mlhxVkVs*8;S>3H3R!^&!)!XW0^|kt0{jCAkKx>dS*cxID zwT4;4tr6BpYm_zG8e@&M##!U73D!hwk~P_yVokNCS<|f<)=X=bHQV~dnq$qi=2`Qt z1=d1qk+s-bVlB0nS<9^z)=F!Ywc1)^t+m!!>#YseMr)I`+1g@lwYFK?tsT}*YnQd# z+GFjt_F4O_1J*(7kagHPVjZ=PS;wst)=BG>b=o>(owd$c=dBCYMeCAv*}7s~wXRv$ ztsB-&>y~xfx?|n7?pgP(2i8ODk@eVmVm-B?pRiBbr|i@A8T+h#&OUEnurJz|?928Q`>K7- zzHZ;JZ`!x)+x8v%u6@tGZ$Gdf+K=qV_7nT5{mg!Dzp!80uk6?M8~d&O&VFxyus_Xw@{g*>Hq(eEh!#J#i9M0h#!4VzFksZZR9nH}l!!aGpu^q>8 zoq&_dN$sR@(mLs!ADr|~1}CGF$;s?wak4tuob1kzP7dcMC#RFk$?g2?81c+KF*WIi;O4PFbg%Q{JiIRCFpi zm7OY1Ri~O$-KpW!bZR-ZojOikr=C;aY2Y+;8aa)fCQhu=)M@54cjBBDPD`hi6YsQk z+BgYLTPM*;a@slVoeoY%C)w%bbauKpU7c=Dcc+Kb)9K~(cKSGdoqkS#XMi)%8RQIh zhB!l=Va{-8gfr3^<&1X5IAfi0&Uj~nGtrskOm?O?Q=MtfbZ3S$)0ySWc7Ac@ICGtO z&U|Nqv(Q=OEOwSSOPyuTa%Y9J(plxKcGfs+opsK7XM?lR+2m|?wm4gzZO(RQhqKe! z{D9CnU4N1bENap#0{(mCavcFs6wopa84=Yn(5x#V1St~ghn zYtD7&hI7-o<=l4eICq_U&VA>B^U!(ZJa(QqPn~DZbLWNg(s|{)cHTH|op;WA=Y#Xn z`PKQ&`Q-fW{Na3dzBpf$>&a`fdZaq1(u9>^5;@-KK6cx49eVws2dzt=xFG zwcEx`aND|xZj#&1ZSQt)JG#kkC%3cP#qH{LbGy4e+@5YPx3}BJ?d$e)`?~|&f$ku8 zusg&Z>JD><6MKlg?g)3JJIWpHj&aAj~3+ly4&3C z?hbdSyUX3}?s50J``rER0r#ML$UW>HagVyk+~e*E_oREuJ?)-x&${Q_^X>)rqI=1` z>|SxNy4T$6?hW^*d&|A;-f{1`_uTvL1NWi($bIZSai6-++~@8K_oe&FeeJ$+-@5PI z_wEPxqx-A-oBPTA-TlM;?0#{-x_`QV1&9C{paOJ&39tba-~xO=2#5hGAP1Cy8qflI zzzCQDD_{qlfEx$|QUy{6(ge~5(gl79qz_~WWDH~qWDaBrWDR5sWDoop$PxG{kTZ}g zkUQ{mAWtA~AR-V9gaTf`4}=4efqa4dfdYYofkJ`8fg*vTfntH;fv7-OKASO^M zP&!a1P&QC5P(Dy0P%%&`P&rT~P&H63P(4s1P%}^~P&-g3P&ZI7P(RQh&@j*_&^XW} z5F2P3XclN5hzqm`v<$Qg#0Odj+5{2;Z3Bscq(Hksd#+Prd<6av${>^>C_N~BD8o=j zLYWWB{7@EvG78EPP?m%;8p;?bOQn=S@DGB25d4GS9|Zp(_y@s12>wCv4}yOX{Da^h z1pgrT2f;rG{`sKH597!WO~tww;1pRNL5Q9g-5c*pw1QHSG}BIS$2sFSw|rmPv_mZMfK!QYzUjzC*K4 zZCfP7b(Na^Qx{7%PfCt$)(rnTkl5_+DvE9vi@Qe6Q;KNp6Pt{;z7<>y_{M>6Op0&Z z_d<;MyAv_)?l=Bl)&ad>ZQ{=>dZJjlQ zlJI>*$0W9-;}TnPmEk2#f{Cb{@{%TfFOh3#P`mmpA#_ z%Ud($I7F+Gv%r}eJ|LW9pV#PvYo#DRBHbFnv_oe-r{P)UC=3|lxqJo zLaEEY>UIBB@Agj})l0e7?%xZs-rx6-*!}M+n~;>)vSZ5a2+La#mbV}*Z$Vhzg0Q>= zVR;L}@)m^UEeOk75SF(fEN?+r-h!~a1z~v$!txe`!V%UTeYwID2OL0Hy;u&f1PSql~@#a3>W)B%4{_S?^tIfzPGQiD+`OKLDG zWl0T2r7WqzsFWo&7?rZ52BT7z)L>M~k{XOkSyF>hDNAZFDrHFxMx`vN!KfIv=6BCd z|9F;2S0yE|B~Qe68uYoe@XC<2LEXAj|Tr}@Q()n zXz-5)|7h@!2LEXAj|Tr}@Q()nXz-5)|7h@!0sk2Aj{*M}@Q(rim@q1x@~&_By-2xJ zV!%BH++)B!2Ha!7JqFxkz&!@sOM!bSa4!Y!rNF%uxR-*fF9la$3a-8s_?IdmMtxgJ zQr_hFcWj}`Ma6vI#l^;bFQv*I6Jk5IN~tIPQ~!Q7_&08$Oc_lmB4sq8h?LQUB2q>Z zibxqvC?aJvp@@{xgd$Q#6N*TgjZj3&Y=k0GW+N1lG8>_Yl-USHq|8PrB4sv05aNX( z#0x=)7lIHk1R-7sLc9=!c%fiEx%$7BXSw6QHd3w#g1ry~dm#w+LJ;hQAlM5*uonu! zOoU)2LNF5{n28X~Lyeye6{`tT^ANc13|9s$|5B&3ie?IWf2mblMACjC9L;)d)0zwc4gdhqCK@<>zC?Et; zKnS9M5JUkXhyp?o1%x092tgDOf+!#aQ9uZyfDl9hA&3G(kmQ6Q8VEr&5Q1nR1kpeU zqJa=Z10je8LJ$pvAQ}ikG!TMlAOz7sr~u4=6wH4V%s)f~A&3Y<5D|nRA_zf55Q2yx z1Q9_9B7zV^1R;nBLJ$#zAR-7w!Td*oe+lr1s2~JUK?tIP5JUwbhzddw6@(xv2tia3 zf~X(_Q9%fzf)GRnA&3e>5EX-xL;)d)0zwc4gdhqCK@<>zC?Et;KnS9M5JUkXhyp@D^$<`!1XK?J)k8q_ z5Kuh?R1d|#`zHq8KQZwB0j`ID>mlHJ2)G^su7`l@A>eulxE=zohk)xL;CcwS9s;h1 zfa@XPdI-240#Z2kiEM z-5#*p19p26`IS~lNo``ACUuVc*I6mP9uV9Ef_p%44+!o7!95_j2L$(k;2sd%1A==% za1RLX!G|;+d`RQLhcq5=+XHTUz-?E$wv;I;?c_JG@7C?w-7r)gY5QkQ=&3gGPl zygh)o2k`a)-X6f)19*D?Zx7(@0ld9X%H(?hZx7(@0lYncw+Ha{0Nx(J+XHxe0B;ZA z?E$CiJczXbE58&+qygh)o2k`a) z-X6f)19*D?Zx7(@0lYncw+Ha{0Nx(J+XHxe0B;YV?E$nsfV2mY_5jizK-vRHdjM$< zAngI9J%F?akoEx59zfayNP7Tj4T&TVhl~yH>H^t3qsIQgU2ETzsq?)2?GY&c46z=3|oKcv<|J*!Nv><+kzP zK4eSTsQItPV&%4REmIm9@woYa@nXMwF(u-XW7*QN_|vMCH2_l+{Fr+95RLuV8m(}R z`DVzLk8Rg37Jn+#wrTTNs$wUqQYWfTJpOFv`v|Bi@pQFTNo@7_mThC{8nK-?7!7{t zX*^vLt4hcC6q~35^0)r}Ga?Nd{%2c^{d*$hxPM&{j|Y-6J>Rb9d(G~Ya{NE1e&5M{ zKc8ueo3kyyT^!pyE+ILVgT9#V_yGOwVDk4%`_>uT=KG~3e804mL6#^D$E1-@5(Ju(ba+Od0x2dDYa4?fTRbI^Z=3`K+*$9dH_ieAn5@lJ%FSKkn{kO9zfCq zNO}NC4|DLptk6q|BQS>8uawtPe=^0f{~!(FY{@ zkk0y$&iatf`T#>8VCVx3eSo14F!TY2KETii82SK1A7JPM41Iv14>0rrhCaa12N?PQ zLmy!10}OqDp${bxKJd{8KKj5%ANc44AAR7X4}A22k3R6x2R{11M<4j; z10Q|hqYr%afsa1$(FZ>Iki`0s#QKoL`jEu>z)v6e=|d9hLlWyl66-?}>jPhXNMe0R zVtq(reMn+`NMe0RVtq(reMn+`NMe0RVtq(reMn+`NM3zNUVTVjeMnw?NM3zNUVTVj zeMnw?NM3zNUVTVjeMnw?NM3zNUVTVjeMnw?NM3zNUVTVjeMnw?NM3zNUVTVjeMnw? zNM3zNUVTVjeMnw?NM3zNUVTVjeMnw?NM3zNUVTVjeMnw?NM3zNUVTVjeMnw?NM3zN zUVTVjeMnw?NM3zNUVTVjeMnw?NM3zNUVTVjeMnw?NM3zNUVTVjeMnw?NM3zNUVTVj zeMnw?NM3zNUVZpT+lP;|eMn|~NM?OVW_?IzeMn|~NM?OVW_?IveMn+`NMe0pxerOK z4@s;KNvsb^tPec*f#*K(+y|cfz;hpX?gP(#;JFVx_krg=@Z1NU`@nM_cNbcpU~_hk@5&;B^>y9R^;9f!AT+br?7m22O>6Q(@p#7&sLMPKAL} zVc=94I28s?g@IFH;8Ykm6$Va)fm31NR2VoF22O>6Q(@p#7&sLMPKAL}Vc=94I28s? zg@IFH;8Ykm6$Va)fm31NR2VoF22O>6Q(@p#7&sLMPKAL>Vc=32xD*C1g@H?9;8Ga4 z6b2rJfk$EBQ5bj>1|EfhM`7Sm71|EfhM`7Sm71|Efh zM`8F-H4Hoo1CPS6-h^Sj3B!65hV>>4>rEKen=q_5VOVd%u-=4Wy$Qp56NdFB4C_r8 z)|)V_H(^+B!m!?iVZ8~%dJ~5ACJgIM7}lFGtT$m;Z^E$Ngkil2!+H~jbtDYyNVrr; zh;0!ck6$Msb7Vv`?D+|`Yh);r%qw@23WlT(j-8d1W1zrX%Zk! z0;EZRGzpL<0n#KungmFR04Wh5B?6>GfRqT35&=>oKuQEii2x}PASD90Jb=rCN@b?C zYt44AbvM&`nz7b>K{G9E#;VO&jhN|m;NAf44dC7Y?hWAHAZ)ayOL8!80P_YgZ!l9}m^XlV1DH2}c>|a? zfO&(Np$iiSFmZrU8DLZf7?lA=Wq?r`U{nSel>tU&fKeG>R0bH80Y+tjQ5j%V1{jqA zMrD9e8DLZf7?lA=Wq?r`U{nSel>tU&fKeG>R0bH80Y+tjQ5j%V1{jqAMrD9e8DLZf z7?lA=Wq?r`U{nSel>tU&fKeG>R0bH80Y+tjQ5j%V1{jqAMrD9e8DLZf7?lA=Wq?r` zU{nSel>tU&fKeG>R0bH80Y+tjQ5j%V1{jqAMrD9e8DLZf7?lA=WxxtafUpk`_5s2^ zK-dQe`v74dAVdR%Xn-*mV2lMAV*$okfO93lxe{QU1sG=m&XoY?O27(4zzRgb3PivP zL^7<2PjdhK%2k@f$LJL&k5&_zfAqA>%h> z{DzF*kntNbenZA@$oLHzzair{Wc-GV-;nVeVyuK1D5@M``7%L&hN{F!%VyuK1D4ZjIH?XN)#0Q% z98-s5>TpaQPN~BwbvUICr_|wyIvi1l6Y6k49S*27((8=$IwQKyh^{lD>x|qwBe%}T ztuu1#NcuXGzK*1?BkAi%`Z|)nj-;<6>FY@HI+DB&C)DADI-F2v#Mc?|bw+%hkzQw{ z*BR+`MtYr*U1y}$898-EP8~D1j+tA>%&jw`>Wrv5BdX4bsxzYMjHo&zs?Lb2GotE@ zs5&F6&WNfrqUwyOIwPvih>DqJ$4s+hrr9ym?3ihG%rrY@njJIEj+ti1OtWLA*)h}X zm}z#*G&^RR9pe^{af`>e#bey!F>dh~w|I7LS=A#7q!kCI~STgqR6J%mg83f)F!7h?yY7Ob}uw2r(0cmF%yKC2|~;SA!dRQGeL-%AjC`%V%!Na6NQ+GLd--VW}*-?QHYr+#7q=o zCJHeVg_wy#%tRr^oe<+rh;b*xxD#UB2{G=37db| z_d<+&AvX6yX|>f)p5ig|w$x2Ew$bSq7!mChrtd zUen~ll-D%5Fy%E(E=+k%lM7Q`)8xXG*EG2>rPqn>-e# z{$^R1*o~{u@?kfwu;s&UTw%+H-MGS5KX%~?Tm9IDD{S>+7p}0?k6pMWcHt@{Uz5+m z3tRolCZC0^er1!-!d5@_-U?g)viDZl`j@@8rLxIqh1S1ilh4A|zh#rp z!q&fKlh4A`-{i9}^*8w}O#Mwh3sZlS&!w`-XNATN(LQM!uDiZ)N0L8M#(Ad0i@-yjDnkOL!qm^~d12~jcD*q5LtmEBmu2)Ndt>!J8}&n9vNu-g-X( zFZz~U2({D8hJqc6+o%QE`1 zjJ{+qtbRv-p)c7BTVgM)LdFaFlD)7>XFQ@W%jiq?!sB$=+9`^L+FqdtH@o zSRU!34KX#)ZyU~wqZ`FO)pKNaxCSUX;+gp`RzUW7`wBdKFYb~*@RU!GJH`&&zbn-=SvaMC=)Z6AY!p28z zUoEkHRUzXAJ<0Y}rPGh-Nw%*lo%*0B*}kfD>VuwS`>N8Z4|=j2J=u+(>_$(ry|u*l zR)yq`p6o_XcB3cR{;K=vNAx5sCnZ)+6k5Bnaw2SUkChW)%ZHT{VQaU*{8z%(ZmgUL zTRmAh5w`Kd%1Mcp6NSbvtegm2JF{{kZ2iW{iLl85R!)Siomn{%wtBL1QeuTfA^D&e zSs_t6^+YeSLZWo?K`*jGqIBwsUSx$t=_U_YArZFzWQC-}3W-A6nRz5DBub~A%p+ML zQ9A96-eiSD>C_Xw$qI?mX=mntnZZNNIFt2W4FEp?h8qBL3*b5Ewd+Pbd9}V++3R}N4%m;dfSOau~m}u#F4+ z&cfFI_??AK4&!$gHu;3#S=j22-&xq|kKeh3-&vu_C;ZOBCLi!S3!5Io?<{P5f!|r! z`X9fuu=PKFXJPAq{LUr(&I+yn@jDAsf7&0vv(m|*_Q&t6bm~w0<9Aj%`Qz8X@2qs{ zk6#17a|yq*Lh{G2f!|r_^A(;CH&F~sXulbercuC z{@88!rIk+qtkrPKfBmlme}$VL3pCH&F~sXuZNzqHb+KXMVjw9=_R za&g8l9U~WGmAOxfo;b#mL1NxfmlCW8`9tT#S*6F?<&z7h~jN zj9(*3SPR7W|7&#f^7m2a=V(h&bdoPB+WB5D9-ixvKV*Da8evvp#+RooN z+NYy|c35z}JAR;ThYRMPKl2vN{2enfH}8tE17lmqEXCM?F?L{#9T?*$iLnD?{3J1U zU~KD~rP$Ut6*B(to5a|GF@BR6J21v?5@QF(_)TK$z!<+tj2#%`7m2a|V(h<|b%YrE zFUJ0hSx1Pm|6=UFn0160`!B}+i&;mAvHxQHA~E(~jDI9%9U;d4i?RP={3J2tfd6)oM0U#Xy*j$ zC_y_XSVsxgP=Yp2u!a(}ae_8Zu!a(}ae_8Zu!a(}ae_8Zu!a(}ae_8Z@S-GW;{6IK-x+fP?Y@S-HFDkOMO5>^!wv}c0$ zOwgVQ+A~3WCTPzD?U|rG6SQZ7_Ds;83EDG3dnRbl1nrriJrlHNg7!?%o(bABL3<`> z&xBQngjI)xRfmLChXn1Kpj{KRYl3!7(5?yEH9@;3Xx9YonxI`1v}=NPP0+3h+BHGD zCTQ0L?V6xn6SQlBc1_T(30gHlt0rjG1g)B&RTH#of>uq?stH;(L8~Tc)da1Ypj8vJ zYJyfx(54C6G(nptXww93nxIV+v}uAiP0*$Z+B89%CTP6SQZ7_Ds;83EDG3 zdnRbl1g)8%H50UEg4RsXnh9DnL2D*x%>=EPpfwY;W`fpC(3%NaGeK)6Xw3wznV>Zj zv}VGpM8c{>f}Tv!j|uuQK|dxl`jOR$gw=?I)rf@Eh{RSSw21G#F$$g4snE?j6}nl6 zLO1JC=w`hN-K;~QoAoGkvrdI>)}heNdK9`@uR=HLQ|M+r3f-(zp_}z+^8opmN(%-C zH%^T9Z_xQ)sY#$qWLXLhnb^9ae^ke2>GHavL$*!mc!KmW&(X2|4cyD)%H4}}tf$V@ z&?%DrefrU&@g2h%Xm^{E)J}y`+m^wt=^>M2I#gsU&ob4ftK@I0O_(a1Y7?%{@4s}t zUfNfg?761QbcITqGSf~7Drw40m_{~bCQMGY6d+7arqqOKTvKYoG_EN%VH($_l)|)z zDLL)HpmR;h3DdczvJfVJQx?MHZ^}ZL{7qR1lYg}OkoChl&SHzk$avrAW!7s^ zdCt(_Xdi&Ch=R6}{xRJ}GC7)f)}EDU&ITPyIVYYN9p(=Dzy!1IpbtziYj+EMV1ikg zJ}|*7OvWalwd=*&s04$SV9*i_T7p5fPt4_Cf&C`P$qZRxo>yut9MNea>qiGi#s_umZpy;iyhCV}*Jcl}RaT4W zUt;uJdNcVQej%+8t(pYLkyOo0h$F&PM-;i3%+maTkSyMN4LV>Q_7;1}(v$ zB^a~>gO*^>5)4{`K}%+B>VQAW4WpJ|)DnzZf>BE_Y6(UynKh^b0ci)b28F4OS%bnn z->gAl>SNZRun7V!s#tx^8dN%+Xx5-GooLpewm#7hW(^7(!d$w3v41S>4!PAxtTdryMP&bZbMlTL@bl zvfVvm4gzhBdowj#ciqIhI12*ydQmG%;M+4OenNPnm;u6k5}B zz>PLO+HmFo8)55m4zLk6cH!U}ZH(l8v=XdO$%@! zh&EVSy*Lm=*y_cBAi|U%bBF^$${Yxy(Ab{?L4+xn&7FlQ7b2GfL6lCp=uZv=Q9Ah} zmN-B|8$Y?<=A6RR!{(gAHoiDOL)gX_2WV)+DD8;2;s6b$Q(nXs2WTkW1~~_42$MhJ ziUTy1PI(bm9H60e^0&EXnS(SG(q1~?)*rSzFnBE{>ZQfw5TEQ@_lw29AnH#KGD@f3aEkKtmuye&+uEG?d z?21rpJpjJ0AUrDw&x-k6^+QU4bz3RB5(JqCPyz&J1tYg&PFL-8wt>Y-AHuE#Ve0`* zO*!gAH`vJHs1IREU|v^YR|1`2GSf&H!kqP?8*FHC)<>DMJ`~ahh$znbP&&PUh~lgd zr85vPggNU&={B@E>qD3pV8*JmKGcgkkxTz6B2jCRiW@pgQRi4nx9f-Wo|zQA5MY-y zsx0Ed^f{7jmLip85uF@N#I<3=)6X|)ID=a0^U+|>c2%?f-B)nQFV%xUD9z* zL}tpP1GY$+d9tfk`g66jT~e2GPi6#T#dAPNnFB(~91xqFx@8-7E-@95kOn=MRdniX_Z1szpEM^%^>RM1fs zbX0|DK?NOE!S<+NdsMJJD*CL+a4 zT9j_~4M(&HlRIjFBU;KF(W20VFh{fqQ+u=kN3iv%2ylo5-AUVkK3v3D)L|}jGJxvi4B;dfy)R?N04KQ!n-1V47hw}K0XiVS zYZ;&e0(3xt*D}Cs8Q`@H@LF;bOqr8l6w>^*G$%~;ZG)gN&2JlFgiQwpwh=~{!Dky` zgw^>Y5--;IxN3r+JZJsT#5xjt{7wCRqvLZo4ED*1xPeqM#!C|fwe~F&W6TQs7iHoz zo?@LN!%ry#4jWF9DF--gI88>FA%H_Aq|PCA3aL{_ox)1o<_c;*<8*;Crwb^YNw+TL zbOEJXlXAL%u+=QYVhn8+L+RF~oI0Rai%ec{s(>)hw^a+_p84sF(m6;LxEZC3E=m(y z&@~As4Cpu3eVi~LY~2^yN`|mCUC2sCXzx{|3f?`ZitMT)yQ;{pDzdAJ?5ZNWs>rS? zva5>hsv^6p$gV1~tBUNZV#-#LT~%aP71>oqc2$vGRb*Ec*;Pe$Rgqm)WLFj0RYi7H zkzG|}R~6Y+MRrv&W2>04RisxHGq#HKs^S8uBE70uu~np36)U!i^r|Ags?7eYNUy5x z9MJ1yCcUaiuPR1t6(hEa^s1u3sz|RY(yNN^wuDn8t*?Htgj9<2YX zh^{IoY%jjnUKqF+Uu!SE)?R$Az4%&t@wN8iYwd-Ld-1jQ;%n{2*V+r~_F|>=!n(a! zWxcR!FTT}Ytg>FLvR-_vy;xGN<7M^< z3mY%9PgvM^nSH{-#$W6c7B>E3pRlmCFZ+arZHmA?VZA0s{)}(-2`k;S6Z?dPO+Bzr zSlHA9`-Fu}matD)*hC}ygoSND!vB7w3FdiF>#|GoEf!C*j*Qddhs=<`1fjVt4rD~u~ z8>}rfP^S&1R1MT=19jR!oi-VQUte7rA~_=*ELWHy#zb z@u1L+M|pYO^L6^@Oz6g?u=~A2#}^9SxKQZ$LZKU%3LRf4bmLN?;|qmuTq<;Yq0p5> zp(}?%R}O`)9CFr>zZvGj(Z#x)-$=~$8F!`I_7bbtx`@-aJdOr$HE+{OuYeuN;{Hs@KR|D};_@l!uVLPTadrWX<_m=IjYw%xNdS(c;-6g zGdZes+Q;OmFzsVdi`6eQn+pVfxyA*jyoO zeXGN3TsyP5Lg`ixHdhE+Ipk`$`^=Wot3Tv#a|L1Yhv(UZp>%795_)C=UV8yxR1Ia?)(Oh z9F#Jkh5M}wxo1GRjmA_JlEYD=nxMcV;(z;z1-JqUMx$=he6(pY4EdHSf zrw`8`=^xiUZ~oApl_Jnzj5O{{jJv*f;Z2-tZ%da zFAFsn-2%s<&3p z=Zs7YsTl@`CoUZu?4Q52e`1|JVcfrU?nX7s_)!0xzIE&R=55w)oOLR*ze6v{lpHND z&?0@mwcgzA!o@glV?zJfyutPT>qqq~y|+T$U17 zrj(TDL@BPPq&Fpvl*A&g2RO?`N3@yz&{-~XUX_|YnDOYr*~tvkBT(OyT_JKAt`gQKyd{f;J% z4mkQkM>jfps-v46eUYPsj-KY|C62z>(anyY?&y%CXE?gW(K8+0>gZXH4m*0bqa%*K z#L;bzp5y4Kqc3%I%+Z%QI_~JXj!rmwo}=3xJ>StCj$YvCrH)?c=w*&x;gq{xnQ2Pfe!@O#|{pL8Y4pKF6rg``RpCV!hP2$R3f7KAN-O&?wRbNY%7Jv7bB zrXgX|ylfg0HqK?!kg#cfHVp}z=4aE8uvwFA8WJ{ZQk#bSjaup%aJg%aLWmu-x@>ma z>Wtk_Nwfo-YeCDVTkY&W(yJ|7aCMC|XaA9hwG8uV%|Wm`SI3#>C9QbL&7bVI*e9#8 zPga+@XZJQL`cv53m_Mey*juGgHqGx(xgd?rl^RLI1>-yVhqm{p(L?$sHVh80?;F#$ z+VTEFwo5xU(VWJ4jY>+o=d2$dxl9{!xA!aS&0A9wW9yi{J+^V{;DEkYw;<&rTdJC) z9o_?ex?^m3LHfD6?SrPhhbG4Q{1MUhZO#N3bzscV9abOPSgcpJnIqW7VqxY8wv$E} zTitfj2s1~poiuv&*ZPl72npLL;uAu`Hj4O!kg(;)CxnD8KRzKOZ29pCAz{mpPY4Oy zDB=@BItr8gZADg?{B5U|F!@toJ|U!Z<05tr2^$x&b4b|63Ok2{jf>bRq*t76ys}eB z*tnKY2MHV3^64O9@?+k>r-PJEeVI4#=^&-gT5f|gvsCbVd`j6^0Up`!sKV0w}r{ib~*`@pY3oGrk=LLNtk}M z4Vl8!(>7%4RdM>&b~p*sujb1VreDpMCCs=oUzRZA%6wVE@nHMDV! z`DhJoTw^|3LmStakJiw}HRhu=v~i93Xbo*#LmSu7#x=BY4Q*UQ8`sdrHMDUJZCpbe z*U-i_v~dk>Ttgez(8e{iaSd%;LmSu7#x=BY4Q*UQ8`sdrHMDUJZCpbe*U-i_v~dk> zTtgez(8dvZFv2evp^YP3)6lEyHr^v!(-5}t9^sdZ(8iIiY3RC*_lS9Tgf@xwq_}8@;3*)^0&1X9q~Z^wuUK8{^)kHcH-)ZU z6}o;`=U7_Q9g>Kv_bbPPSjXQ;o?-janr_k}eLO1Rdx^_+2$*hq4 zP45Ylzv(?;@;ALFO#Y_#gvsCZo-p~F-V-K&(|f|?Z+b7`lYk1Tzv(?;>Th~anEIRE z6Q=&A_k^jx={;fUZ+cId`kUUU4Kl`qQEq^{K zC~Wz&?ONFK=aYgu{DAyT?+KH?={;fcH@zoJ{-*bY$=~#zF!`I_6DEJtd&1;zdN1A8 zo6g4+TK}`b={%{3au-5L$)Zk}%SGdZd2w3qGmP`0e>m!St^%?GW}_8G4%Ye_i9*rjzw-`ogx9sgCru=@?Yj)0xVT=i6LUnCF|$Nh+pu6wZtd#-!;&wI6+9x={C#zv(2k z7kvOeo5Zd1N)JzQaPy-{)6+Vq<+ZCy`n zoc1=?>eX(UwlF=XG|FQ0H(~m=*ZIVRn?5ncn`@#fBYkdmn(7QTyHVFEyV-5(7s_dN zfUYwpD|IVpz3CHE9cJ2#-->kpu1xe%bAN--3v+M1xLe80jBfuce`d^4o3EX$@P3wT`qPS6wwQxV6tfR9>~E zf5RZ4J9{O{UWry|;fx1F-5F319Voa*_w=lBp`>yqi%JGaF1N1KlgxvnI0N+5RHsDHAf zw{}pAW?83}9Z1#e*h#Y7lGHQB5oi@upjCx>c3f+~X09B>q6dwtp3KwqfYzf0S`Ub_ zU0<(diX)KuO}44TbFBxc>sz2&%0A$rM+ccJNwzowtp_C8;V;nYEP>2z*#@a*t1ZyF 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 literal 0 HcmV?d00001 diff --git a/fonts/envypn-15.ttf b/fonts/envypn-15.ttf new file mode 100644 index 0000000000000000000000000000000000000000..984850d1784b1508b04e3cda1febf4c8ac06d8b7 GIT binary patch literal 14876 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 D7)>58 literal 0 HcmV?d00001 diff --git a/gui/gui.go b/gui/gui.go index d351d13..a5586d7 100644 --- a/gui/gui.go +++ b/gui/gui.go @@ -36,7 +36,7 @@ func New(config config.Config, terminal *terminal.Terminal, logger *zap.SugaredL width: 600, height: 300, terminal: terminal, - fontScale: 13.0, + fontScale: 15.0, } } @@ -100,9 +100,8 @@ func (gui *GUI) Render() error { gl.BindFragDataLocation(program, 0, gl.Str("outColour\x00")) gui.logger.Debugf("Loading font...") - //if err := gui.loadFont("/usr/share/fonts/nerd-fonts-complete/ttf/Roboto Mono Nerd Font Complete.ttf", 12); err != nil { - - if err := gui.loadFont("./fonts/Roboto.ttf"); err != nil { + if err := gui.loadFont("./fonts/envypn-15.ttf"); err != nil { + //if err := gui.loadFont("./fonts/Roboto.ttf"); err != nil { return fmt.Errorf("Failed to load font: %s", err) } @@ -200,13 +199,12 @@ func (gui *GUI) Render() error { } if gui.config.Rendering.AlwaysRepaint || frames > 0 { - glfw.PollEvents() - frameCount++ gui.window.SwapBuffers() + frameCount++ frames-- - } else { - glfw.WaitEventsTimeout(0.02) // every 20ms = 50fps on nothing changing } + + glfw.WaitEventsTimeout(0.02) // every 20ms = 50fps on nothing changing } gui.logger.Debugf("Stopping render...") @@ -229,8 +227,8 @@ func (gui *GUI) createWindow(width int, height int) (*glfw.Window, error) { } glfw.WindowHint(glfw.Resizable, glfw.True) - glfw.WindowHint(glfw.ContextVersionMajor, 4) // OR 2 - glfw.WindowHint(glfw.ContextVersionMinor, 1) + glfw.WindowHint(glfw.ContextVersionMajor, 3) // OR 2 + glfw.WindowHint(glfw.ContextVersionMinor, 2) glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile) glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True) diff --git a/gui/renderer.go b/gui/renderer.go index 1b9c4f2..da2528e 100644 --- a/gui/renderer.go +++ b/gui/renderer.go @@ -224,11 +224,11 @@ func (r *OpenGLRenderer) DrawCell(cell *buffer.Cell, col int, row int) { panic(fmt.Sprintf("Missing rectangle data for cell at %d,%d", col, row)) } + gl.UseProgram(r.program) + // don't bother rendering rectangles that are the same colour as the background if bg != r.config.ColourScheme.DefaultBg { rect.setColour(bg) - - gl.UseProgram(r.program) gl.BindVertexArray(rect.vao) gl.DrawArrays(gl.TRIANGLES, 0, 6) } diff --git a/terminal/escapes.go b/terminal/output.go similarity index 100% rename from terminal/escapes.go rename to terminal/output.go diff --git a/vendor/github.com/BurntSushi/toml/.gitignore b/vendor/github.com/BurntSushi/toml/.gitignore new file mode 100644 index 0000000..0cd3800 --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/.gitignore @@ -0,0 +1,5 @@ +TAGS +tags +.*.swp +tomlcheck/tomlcheck +toml.test diff --git a/vendor/github.com/BurntSushi/toml/.travis.yml b/vendor/github.com/BurntSushi/toml/.travis.yml new file mode 100644 index 0000000..8b8afc4 --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/.travis.yml @@ -0,0 +1,15 @@ +language: go +go: + - 1.1 + - 1.2 + - 1.3 + - 1.4 + - 1.5 + - 1.6 + - tip +install: + - go install ./... + - go get github.com/BurntSushi/toml-test +script: + - export PATH="$PATH:$HOME/gopath/bin" + - make test diff --git a/vendor/github.com/BurntSushi/toml/COMPATIBLE b/vendor/github.com/BurntSushi/toml/COMPATIBLE new file mode 100644 index 0000000..6efcfd0 --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/COMPATIBLE @@ -0,0 +1,3 @@ +Compatible with TOML version +[v0.4.0](https://github.com/toml-lang/toml/blob/v0.4.0/versions/en/toml-v0.4.0.md) + diff --git a/vendor/github.com/BurntSushi/toml/COPYING b/vendor/github.com/BurntSushi/toml/COPYING new file mode 100644 index 0000000..5a8e332 --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/COPYING @@ -0,0 +1,14 @@ + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + Version 2, December 2004 + + Copyright (C) 2004 Sam Hocevar + + Everyone is permitted to copy and distribute verbatim or modified + copies of this license document, and changing it is allowed as long + as the name is changed. + + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. You just DO WHAT THE FUCK YOU WANT TO. + diff --git a/vendor/github.com/BurntSushi/toml/Makefile b/vendor/github.com/BurntSushi/toml/Makefile new file mode 100644 index 0000000..3600848 --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/Makefile @@ -0,0 +1,19 @@ +install: + go install ./... + +test: install + go test -v + toml-test toml-test-decoder + toml-test -encoder toml-test-encoder + +fmt: + gofmt -w *.go */*.go + colcheck *.go */*.go + +tags: + find ./ -name '*.go' -print0 | xargs -0 gotags > TAGS + +push: + git push origin master + git push github master + diff --git a/vendor/github.com/BurntSushi/toml/README.md b/vendor/github.com/BurntSushi/toml/README.md new file mode 100644 index 0000000..7c1b37e --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/README.md @@ -0,0 +1,218 @@ +## TOML parser and encoder for Go with reflection + +TOML stands for Tom's Obvious, Minimal Language. This Go package provides a +reflection interface similar to Go's standard library `json` and `xml` +packages. This package also supports the `encoding.TextUnmarshaler` and +`encoding.TextMarshaler` interfaces so that you can define custom data +representations. (There is an example of this below.) + +Spec: https://github.com/toml-lang/toml + +Compatible with TOML version +[v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md) + +Documentation: https://godoc.org/github.com/BurntSushi/toml + +Installation: + +```bash +go get github.com/BurntSushi/toml +``` + +Try the toml validator: + +```bash +go get github.com/BurntSushi/toml/cmd/tomlv +tomlv some-toml-file.toml +``` + +[![Build Status](https://travis-ci.org/BurntSushi/toml.svg?branch=master)](https://travis-ci.org/BurntSushi/toml) [![GoDoc](https://godoc.org/github.com/BurntSushi/toml?status.svg)](https://godoc.org/github.com/BurntSushi/toml) + +### Testing + +This package passes all tests in +[toml-test](https://github.com/BurntSushi/toml-test) for both the decoder +and the encoder. + +### Examples + +This package works similarly to how the Go standard library handles `XML` +and `JSON`. Namely, data is loaded into Go values via reflection. + +For the simplest example, consider some TOML file as just a list of keys +and values: + +```toml +Age = 25 +Cats = [ "Cauchy", "Plato" ] +Pi = 3.14 +Perfection = [ 6, 28, 496, 8128 ] +DOB = 1987-07-05T05:45:00Z +``` + +Which could be defined in Go as: + +```go +type Config struct { + Age int + Cats []string + Pi float64 + Perfection []int + DOB time.Time // requires `import time` +} +``` + +And then decoded with: + +```go +var conf Config +if _, err := toml.Decode(tomlData, &conf); err != nil { + // handle error +} +``` + +You can also use struct tags if your struct field name doesn't map to a TOML +key value directly: + +```toml +some_key_NAME = "wat" +``` + +```go +type TOML struct { + ObscureKey string `toml:"some_key_NAME"` +} +``` + +### Using the `encoding.TextUnmarshaler` interface + +Here's an example that automatically parses duration strings into +`time.Duration` values: + +```toml +[[song]] +name = "Thunder Road" +duration = "4m49s" + +[[song]] +name = "Stairway to Heaven" +duration = "8m03s" +``` + +Which can be decoded with: + +```go +type song struct { + Name string + Duration duration +} +type songs struct { + Song []song +} +var favorites songs +if _, err := toml.Decode(blob, &favorites); err != nil { + log.Fatal(err) +} + +for _, s := range favorites.Song { + fmt.Printf("%s (%s)\n", s.Name, s.Duration) +} +``` + +And you'll also need a `duration` type that satisfies the +`encoding.TextUnmarshaler` interface: + +```go +type duration struct { + time.Duration +} + +func (d *duration) UnmarshalText(text []byte) error { + var err error + d.Duration, err = time.ParseDuration(string(text)) + return err +} +``` + +### More complex usage + +Here's an example of how to load the example from the official spec page: + +```toml +# This is a TOML document. Boom. + +title = "TOML Example" + +[owner] +name = "Tom Preston-Werner" +organization = "GitHub" +bio = "GitHub Cofounder & CEO\nLikes tater tots and beer." +dob = 1979-05-27T07:32:00Z # First class dates? Why not? + +[database] +server = "192.168.1.1" +ports = [ 8001, 8001, 8002 ] +connection_max = 5000 +enabled = true + +[servers] + + # You can indent as you please. Tabs or spaces. TOML don't care. + [servers.alpha] + ip = "10.0.0.1" + dc = "eqdc10" + + [servers.beta] + ip = "10.0.0.2" + dc = "eqdc10" + +[clients] +data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it + +# Line breaks are OK when inside arrays +hosts = [ + "alpha", + "omega" +] +``` + +And the corresponding Go types are: + +```go +type tomlConfig struct { + Title string + Owner ownerInfo + DB database `toml:"database"` + Servers map[string]server + Clients clients +} + +type ownerInfo struct { + Name string + Org string `toml:"organization"` + Bio string + DOB time.Time +} + +type database struct { + Server string + Ports []int + ConnMax int `toml:"connection_max"` + Enabled bool +} + +type server struct { + IP string + DC string +} + +type clients struct { + Data [][]interface{} + Hosts []string +} +``` + +Note that a case insensitive match will be tried if an exact match can't be +found. + +A working example of the above can be found in `_examples/example.{go,toml}`. diff --git a/vendor/github.com/BurntSushi/toml/cmd/toml-test-decoder/COPYING b/vendor/github.com/BurntSushi/toml/cmd/toml-test-decoder/COPYING new file mode 100644 index 0000000..5a8e332 --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/cmd/toml-test-decoder/COPYING @@ -0,0 +1,14 @@ + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + Version 2, December 2004 + + Copyright (C) 2004 Sam Hocevar + + Everyone is permitted to copy and distribute verbatim or modified + copies of this license document, and changing it is allowed as long + as the name is changed. + + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. You just DO WHAT THE FUCK YOU WANT TO. + diff --git a/vendor/github.com/BurntSushi/toml/cmd/toml-test-encoder/COPYING b/vendor/github.com/BurntSushi/toml/cmd/toml-test-encoder/COPYING new file mode 100644 index 0000000..5a8e332 --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/cmd/toml-test-encoder/COPYING @@ -0,0 +1,14 @@ + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + Version 2, December 2004 + + Copyright (C) 2004 Sam Hocevar + + Everyone is permitted to copy and distribute verbatim or modified + copies of this license document, and changing it is allowed as long + as the name is changed. + + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. You just DO WHAT THE FUCK YOU WANT TO. + diff --git a/vendor/github.com/BurntSushi/toml/cmd/tomlv/COPYING b/vendor/github.com/BurntSushi/toml/cmd/tomlv/COPYING new file mode 100644 index 0000000..5a8e332 --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/cmd/tomlv/COPYING @@ -0,0 +1,14 @@ + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + Version 2, December 2004 + + Copyright (C) 2004 Sam Hocevar + + Everyone is permitted to copy and distribute verbatim or modified + copies of this license document, and changing it is allowed as long + as the name is changed. + + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. You just DO WHAT THE FUCK YOU WANT TO. + diff --git a/vendor/github.com/BurntSushi/toml/decode.go b/vendor/github.com/BurntSushi/toml/decode.go new file mode 100644 index 0000000..b0fd51d --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/decode.go @@ -0,0 +1,509 @@ +package toml + +import ( + "fmt" + "io" + "io/ioutil" + "math" + "reflect" + "strings" + "time" +) + +func e(format string, args ...interface{}) error { + return fmt.Errorf("toml: "+format, args...) +} + +// Unmarshaler is the interface implemented by objects that can unmarshal a +// TOML description of themselves. +type Unmarshaler interface { + UnmarshalTOML(interface{}) error +} + +// Unmarshal decodes the contents of `p` in TOML format into a pointer `v`. +func Unmarshal(p []byte, v interface{}) error { + _, err := Decode(string(p), v) + return err +} + +// Primitive is a TOML value that hasn't been decoded into a Go value. +// When using the various `Decode*` functions, the type `Primitive` may +// be given to any value, and its decoding will be delayed. +// +// A `Primitive` value can be decoded using the `PrimitiveDecode` function. +// +// The underlying representation of a `Primitive` value is subject to change. +// Do not rely on it. +// +// N.B. Primitive values are still parsed, so using them will only avoid +// the overhead of reflection. They can be useful when you don't know the +// exact type of TOML data until run time. +type Primitive struct { + undecoded interface{} + context Key +} + +// DEPRECATED! +// +// Use MetaData.PrimitiveDecode instead. +func PrimitiveDecode(primValue Primitive, v interface{}) error { + md := MetaData{decoded: make(map[string]bool)} + return md.unify(primValue.undecoded, rvalue(v)) +} + +// PrimitiveDecode is just like the other `Decode*` functions, except it +// decodes a TOML value that has already been parsed. Valid primitive values +// can *only* be obtained from values filled by the decoder functions, +// including this method. (i.e., `v` may contain more `Primitive` +// values.) +// +// Meta data for primitive values is included in the meta data returned by +// the `Decode*` functions with one exception: keys returned by the Undecoded +// method will only reflect keys that were decoded. Namely, any keys hidden +// behind a Primitive will be considered undecoded. Executing this method will +// update the undecoded keys in the meta data. (See the example.) +func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) error { + md.context = primValue.context + defer func() { md.context = nil }() + return md.unify(primValue.undecoded, rvalue(v)) +} + +// Decode will decode the contents of `data` in TOML format into a pointer +// `v`. +// +// TOML hashes correspond to Go structs or maps. (Dealer's choice. They can be +// used interchangeably.) +// +// TOML arrays of tables correspond to either a slice of structs or a slice +// of maps. +// +// TOML datetimes correspond to Go `time.Time` values. +// +// All other TOML types (float, string, int, bool and array) correspond +// to the obvious Go types. +// +// An exception to the above rules is if a type implements the +// encoding.TextUnmarshaler interface. In this case, any primitive TOML value +// (floats, strings, integers, booleans and datetimes) will be converted to +// a byte string and given to the value's UnmarshalText method. See the +// Unmarshaler example for a demonstration with time duration strings. +// +// Key mapping +// +// TOML keys can map to either keys in a Go map or field names in a Go +// struct. The special `toml` struct tag may be used to map TOML keys to +// struct fields that don't match the key name exactly. (See the example.) +// A case insensitive match to struct names will be tried if an exact match +// can't be found. +// +// The mapping between TOML values and Go values is loose. That is, there +// may exist TOML values that cannot be placed into your representation, and +// there may be parts of your representation that do not correspond to +// TOML values. This loose mapping can be made stricter by using the IsDefined +// and/or Undecoded methods on the MetaData returned. +// +// This decoder will not handle cyclic types. If a cyclic type is passed, +// `Decode` will not terminate. +func Decode(data string, v interface{}) (MetaData, error) { + rv := reflect.ValueOf(v) + if rv.Kind() != reflect.Ptr { + return MetaData{}, e("Decode of non-pointer %s", reflect.TypeOf(v)) + } + if rv.IsNil() { + return MetaData{}, e("Decode of nil %s", reflect.TypeOf(v)) + } + p, err := parse(data) + if err != nil { + return MetaData{}, err + } + md := MetaData{ + p.mapping, p.types, p.ordered, + make(map[string]bool, len(p.ordered)), nil, + } + return md, md.unify(p.mapping, indirect(rv)) +} + +// DecodeFile is just like Decode, except it will automatically read the +// contents of the file at `fpath` and decode it for you. +func DecodeFile(fpath string, v interface{}) (MetaData, error) { + bs, err := ioutil.ReadFile(fpath) + if err != nil { + return MetaData{}, err + } + return Decode(string(bs), v) +} + +// DecodeReader is just like Decode, except it will consume all bytes +// from the reader and decode it for you. +func DecodeReader(r io.Reader, v interface{}) (MetaData, error) { + bs, err := ioutil.ReadAll(r) + if err != nil { + return MetaData{}, err + } + return Decode(string(bs), v) +} + +// unify performs a sort of type unification based on the structure of `rv`, +// which is the client representation. +// +// Any type mismatch produces an error. Finding a type that we don't know +// how to handle produces an unsupported type error. +func (md *MetaData) unify(data interface{}, rv reflect.Value) error { + + // Special case. Look for a `Primitive` value. + if rv.Type() == reflect.TypeOf((*Primitive)(nil)).Elem() { + // Save the undecoded data and the key context into the primitive + // value. + context := make(Key, len(md.context)) + copy(context, md.context) + rv.Set(reflect.ValueOf(Primitive{ + undecoded: data, + context: context, + })) + return nil + } + + // Special case. Unmarshaler Interface support. + if rv.CanAddr() { + if v, ok := rv.Addr().Interface().(Unmarshaler); ok { + return v.UnmarshalTOML(data) + } + } + + // Special case. Handle time.Time values specifically. + // TODO: Remove this code when we decide to drop support for Go 1.1. + // This isn't necessary in Go 1.2 because time.Time satisfies the encoding + // interfaces. + if rv.Type().AssignableTo(rvalue(time.Time{}).Type()) { + return md.unifyDatetime(data, rv) + } + + // Special case. Look for a value satisfying the TextUnmarshaler interface. + if v, ok := rv.Interface().(TextUnmarshaler); ok { + return md.unifyText(data, v) + } + // BUG(burntsushi) + // The behavior here is incorrect whenever a Go type satisfies the + // encoding.TextUnmarshaler interface but also corresponds to a TOML + // hash or array. In particular, the unmarshaler should only be applied + // to primitive TOML values. But at this point, it will be applied to + // all kinds of values and produce an incorrect error whenever those values + // are hashes or arrays (including arrays of tables). + + k := rv.Kind() + + // laziness + if k >= reflect.Int && k <= reflect.Uint64 { + return md.unifyInt(data, rv) + } + switch k { + case reflect.Ptr: + elem := reflect.New(rv.Type().Elem()) + err := md.unify(data, reflect.Indirect(elem)) + if err != nil { + return err + } + rv.Set(elem) + return nil + case reflect.Struct: + return md.unifyStruct(data, rv) + case reflect.Map: + return md.unifyMap(data, rv) + case reflect.Array: + return md.unifyArray(data, rv) + case reflect.Slice: + return md.unifySlice(data, rv) + case reflect.String: + return md.unifyString(data, rv) + case reflect.Bool: + return md.unifyBool(data, rv) + case reflect.Interface: + // we only support empty interfaces. + if rv.NumMethod() > 0 { + return e("unsupported type %s", rv.Type()) + } + return md.unifyAnything(data, rv) + case reflect.Float32: + fallthrough + case reflect.Float64: + return md.unifyFloat64(data, rv) + } + return e("unsupported type %s", rv.Kind()) +} + +func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error { + tmap, ok := mapping.(map[string]interface{}) + if !ok { + if mapping == nil { + return nil + } + return e("type mismatch for %s: expected table but found %T", + rv.Type().String(), mapping) + } + + for key, datum := range tmap { + var f *field + fields := cachedTypeFields(rv.Type()) + for i := range fields { + ff := &fields[i] + if ff.name == key { + f = ff + break + } + if f == nil && strings.EqualFold(ff.name, key) { + f = ff + } + } + if f != nil { + subv := rv + for _, i := range f.index { + subv = indirect(subv.Field(i)) + } + if isUnifiable(subv) { + md.decoded[md.context.add(key).String()] = true + md.context = append(md.context, key) + if err := md.unify(datum, subv); err != nil { + return err + } + md.context = md.context[0 : len(md.context)-1] + } else if f.name != "" { + // Bad user! No soup for you! + return e("cannot write unexported field %s.%s", + rv.Type().String(), f.name) + } + } + } + return nil +} + +func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error { + tmap, ok := mapping.(map[string]interface{}) + if !ok { + if tmap == nil { + return nil + } + return badtype("map", mapping) + } + if rv.IsNil() { + rv.Set(reflect.MakeMap(rv.Type())) + } + for k, v := range tmap { + md.decoded[md.context.add(k).String()] = true + md.context = append(md.context, k) + + rvkey := indirect(reflect.New(rv.Type().Key())) + rvval := reflect.Indirect(reflect.New(rv.Type().Elem())) + if err := md.unify(v, rvval); err != nil { + return err + } + md.context = md.context[0 : len(md.context)-1] + + rvkey.SetString(k) + rv.SetMapIndex(rvkey, rvval) + } + return nil +} + +func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error { + datav := reflect.ValueOf(data) + if datav.Kind() != reflect.Slice { + if !datav.IsValid() { + return nil + } + return badtype("slice", data) + } + sliceLen := datav.Len() + if sliceLen != rv.Len() { + return e("expected array length %d; got TOML array of length %d", + rv.Len(), sliceLen) + } + return md.unifySliceArray(datav, rv) +} + +func (md *MetaData) unifySlice(data interface{}, rv reflect.Value) error { + datav := reflect.ValueOf(data) + if datav.Kind() != reflect.Slice { + if !datav.IsValid() { + return nil + } + return badtype("slice", data) + } + n := datav.Len() + if rv.IsNil() || rv.Cap() < n { + rv.Set(reflect.MakeSlice(rv.Type(), n, n)) + } + rv.SetLen(n) + return md.unifySliceArray(datav, rv) +} + +func (md *MetaData) unifySliceArray(data, rv reflect.Value) error { + sliceLen := data.Len() + for i := 0; i < sliceLen; i++ { + v := data.Index(i).Interface() + sliceval := indirect(rv.Index(i)) + if err := md.unify(v, sliceval); err != nil { + return err + } + } + return nil +} + +func (md *MetaData) unifyDatetime(data interface{}, rv reflect.Value) error { + if _, ok := data.(time.Time); ok { + rv.Set(reflect.ValueOf(data)) + return nil + } + return badtype("time.Time", data) +} + +func (md *MetaData) unifyString(data interface{}, rv reflect.Value) error { + if s, ok := data.(string); ok { + rv.SetString(s) + return nil + } + return badtype("string", data) +} + +func (md *MetaData) unifyFloat64(data interface{}, rv reflect.Value) error { + if num, ok := data.(float64); ok { + switch rv.Kind() { + case reflect.Float32: + fallthrough + case reflect.Float64: + rv.SetFloat(num) + default: + panic("bug") + } + return nil + } + return badtype("float", data) +} + +func (md *MetaData) unifyInt(data interface{}, rv reflect.Value) error { + if num, ok := data.(int64); ok { + if rv.Kind() >= reflect.Int && rv.Kind() <= reflect.Int64 { + switch rv.Kind() { + case reflect.Int, reflect.Int64: + // No bounds checking necessary. + case reflect.Int8: + if num < math.MinInt8 || num > math.MaxInt8 { + return e("value %d is out of range for int8", num) + } + case reflect.Int16: + if num < math.MinInt16 || num > math.MaxInt16 { + return e("value %d is out of range for int16", num) + } + case reflect.Int32: + if num < math.MinInt32 || num > math.MaxInt32 { + return e("value %d is out of range for int32", num) + } + } + rv.SetInt(num) + } else if rv.Kind() >= reflect.Uint && rv.Kind() <= reflect.Uint64 { + unum := uint64(num) + switch rv.Kind() { + case reflect.Uint, reflect.Uint64: + // No bounds checking necessary. + case reflect.Uint8: + if num < 0 || unum > math.MaxUint8 { + return e("value %d is out of range for uint8", num) + } + case reflect.Uint16: + if num < 0 || unum > math.MaxUint16 { + return e("value %d is out of range for uint16", num) + } + case reflect.Uint32: + if num < 0 || unum > math.MaxUint32 { + return e("value %d is out of range for uint32", num) + } + } + rv.SetUint(unum) + } else { + panic("unreachable") + } + return nil + } + return badtype("integer", data) +} + +func (md *MetaData) unifyBool(data interface{}, rv reflect.Value) error { + if b, ok := data.(bool); ok { + rv.SetBool(b) + return nil + } + return badtype("boolean", data) +} + +func (md *MetaData) unifyAnything(data interface{}, rv reflect.Value) error { + rv.Set(reflect.ValueOf(data)) + return nil +} + +func (md *MetaData) unifyText(data interface{}, v TextUnmarshaler) error { + var s string + switch sdata := data.(type) { + case TextMarshaler: + text, err := sdata.MarshalText() + if err != nil { + return err + } + s = string(text) + case fmt.Stringer: + s = sdata.String() + case string: + s = sdata + case bool: + s = fmt.Sprintf("%v", sdata) + case int64: + s = fmt.Sprintf("%d", sdata) + case float64: + s = fmt.Sprintf("%f", sdata) + default: + return badtype("primitive (string-like)", data) + } + if err := v.UnmarshalText([]byte(s)); err != nil { + return err + } + return nil +} + +// rvalue returns a reflect.Value of `v`. All pointers are resolved. +func rvalue(v interface{}) reflect.Value { + return indirect(reflect.ValueOf(v)) +} + +// indirect returns the value pointed to by a pointer. +// Pointers are followed until the value is not a pointer. +// New values are allocated for each nil pointer. +// +// An exception to this rule is if the value satisfies an interface of +// interest to us (like encoding.TextUnmarshaler). +func indirect(v reflect.Value) reflect.Value { + if v.Kind() != reflect.Ptr { + if v.CanSet() { + pv := v.Addr() + if _, ok := pv.Interface().(TextUnmarshaler); ok { + return pv + } + } + return v + } + if v.IsNil() { + v.Set(reflect.New(v.Type().Elem())) + } + return indirect(reflect.Indirect(v)) +} + +func isUnifiable(rv reflect.Value) bool { + if rv.CanSet() { + return true + } + if _, ok := rv.Interface().(TextUnmarshaler); ok { + return true + } + return false +} + +func badtype(expected string, data interface{}) error { + return e("cannot load TOML value of type %T into a Go %s", data, expected) +} diff --git a/vendor/github.com/BurntSushi/toml/decode_meta.go b/vendor/github.com/BurntSushi/toml/decode_meta.go new file mode 100644 index 0000000..b9914a6 --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/decode_meta.go @@ -0,0 +1,121 @@ +package toml + +import "strings" + +// MetaData allows access to meta information about TOML data that may not +// be inferrable via reflection. In particular, whether a key has been defined +// and the TOML type of a key. +type MetaData struct { + mapping map[string]interface{} + types map[string]tomlType + keys []Key + decoded map[string]bool + context Key // Used only during decoding. +} + +// IsDefined returns true if the key given exists in the TOML data. The key +// should be specified hierarchially. e.g., +// +// // access the TOML key 'a.b.c' +// IsDefined("a", "b", "c") +// +// IsDefined will return false if an empty key given. Keys are case sensitive. +func (md *MetaData) IsDefined(key ...string) bool { + if len(key) == 0 { + return false + } + + var hash map[string]interface{} + var ok bool + var hashOrVal interface{} = md.mapping + for _, k := range key { + if hash, ok = hashOrVal.(map[string]interface{}); !ok { + return false + } + if hashOrVal, ok = hash[k]; !ok { + return false + } + } + return true +} + +// Type returns a string representation of the type of the key specified. +// +// Type will return the empty string if given an empty key or a key that +// does not exist. Keys are case sensitive. +func (md *MetaData) Type(key ...string) string { + fullkey := strings.Join(key, ".") + if typ, ok := md.types[fullkey]; ok { + return typ.typeString() + } + return "" +} + +// Key is the type of any TOML key, including key groups. Use (MetaData).Keys +// to get values of this type. +type Key []string + +func (k Key) String() string { + return strings.Join(k, ".") +} + +func (k Key) maybeQuotedAll() string { + var ss []string + for i := range k { + ss = append(ss, k.maybeQuoted(i)) + } + return strings.Join(ss, ".") +} + +func (k Key) maybeQuoted(i int) string { + quote := false + for _, c := range k[i] { + if !isBareKeyChar(c) { + quote = true + break + } + } + if quote { + return "\"" + strings.Replace(k[i], "\"", "\\\"", -1) + "\"" + } + return k[i] +} + +func (k Key) add(piece string) Key { + newKey := make(Key, len(k)+1) + copy(newKey, k) + newKey[len(k)] = piece + return newKey +} + +// Keys returns a slice of every key in the TOML data, including key groups. +// Each key is itself a slice, where the first element is the top of the +// hierarchy and the last is the most specific. +// +// The list will have the same order as the keys appeared in the TOML data. +// +// All keys returned are non-empty. +func (md *MetaData) Keys() []Key { + return md.keys +} + +// Undecoded returns all keys that have not been decoded in the order in which +// they appear in the original TOML document. +// +// This includes keys that haven't been decoded because of a Primitive value. +// Once the Primitive value is decoded, the keys will be considered decoded. +// +// Also note that decoding into an empty interface will result in no decoding, +// and so no keys will be considered decoded. +// +// In this sense, the Undecoded keys correspond to keys in the TOML document +// that do not have a concrete type in your representation. +func (md *MetaData) Undecoded() []Key { + undecoded := make([]Key, 0, len(md.keys)) + for _, key := range md.keys { + if !md.decoded[key.String()] { + undecoded = append(undecoded, key) + } + } + return undecoded +} diff --git a/vendor/github.com/BurntSushi/toml/doc.go b/vendor/github.com/BurntSushi/toml/doc.go new file mode 100644 index 0000000..b371f39 --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/doc.go @@ -0,0 +1,27 @@ +/* +Package toml provides facilities for decoding and encoding TOML configuration +files via reflection. There is also support for delaying decoding with +the Primitive type, and querying the set of keys in a TOML document with the +MetaData type. + +The specification implemented: https://github.com/toml-lang/toml + +The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify +whether a file is a valid TOML document. It can also be used to print the +type of each key in a TOML document. + +Testing + +There are two important types of tests used for this package. The first is +contained inside '*_test.go' files and uses the standard Go unit testing +framework. These tests are primarily devoted to holistically testing the +decoder and encoder. + +The second type of testing is used to verify the implementation's adherence +to the TOML specification. These tests have been factored into their own +project: https://github.com/BurntSushi/toml-test + +The reason the tests are in a separate project is so that they can be used by +any implementation of TOML. Namely, it is language agnostic. +*/ +package toml diff --git a/vendor/github.com/BurntSushi/toml/encode.go b/vendor/github.com/BurntSushi/toml/encode.go new file mode 100644 index 0000000..d905c21 --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/encode.go @@ -0,0 +1,568 @@ +package toml + +import ( + "bufio" + "errors" + "fmt" + "io" + "reflect" + "sort" + "strconv" + "strings" + "time" +) + +type tomlEncodeError struct{ error } + +var ( + errArrayMixedElementTypes = errors.New( + "toml: cannot encode array with mixed element types") + errArrayNilElement = errors.New( + "toml: cannot encode array with nil element") + errNonString = errors.New( + "toml: cannot encode a map with non-string key type") + errAnonNonStruct = errors.New( + "toml: cannot encode an anonymous field that is not a struct") + errArrayNoTable = errors.New( + "toml: TOML array element cannot contain a table") + errNoKey = errors.New( + "toml: top-level values must be Go maps or structs") + errAnything = errors.New("") // used in testing +) + +var quotedReplacer = strings.NewReplacer( + "\t", "\\t", + "\n", "\\n", + "\r", "\\r", + "\"", "\\\"", + "\\", "\\\\", +) + +// Encoder controls the encoding of Go values to a TOML document to some +// io.Writer. +// +// The indentation level can be controlled with the Indent field. +type Encoder struct { + // A single indentation level. By default it is two spaces. + Indent string + + // hasWritten is whether we have written any output to w yet. + hasWritten bool + w *bufio.Writer +} + +// NewEncoder returns a TOML encoder that encodes Go values to the io.Writer +// given. By default, a single indentation level is 2 spaces. +func NewEncoder(w io.Writer) *Encoder { + return &Encoder{ + w: bufio.NewWriter(w), + Indent: " ", + } +} + +// Encode writes a TOML representation of the Go value to the underlying +// io.Writer. If the value given cannot be encoded to a valid TOML document, +// then an error is returned. +// +// The mapping between Go values and TOML values should be precisely the same +// as for the Decode* functions. Similarly, the TextMarshaler interface is +// supported by encoding the resulting bytes as strings. (If you want to write +// arbitrary binary data then you will need to use something like base64 since +// TOML does not have any binary types.) +// +// When encoding TOML hashes (i.e., Go maps or structs), keys without any +// sub-hashes are encoded first. +// +// If a Go map is encoded, then its keys are sorted alphabetically for +// deterministic output. More control over this behavior may be provided if +// there is demand for it. +// +// Encoding Go values without a corresponding TOML representation---like map +// types with non-string keys---will cause an error to be returned. Similarly +// for mixed arrays/slices, arrays/slices with nil elements, embedded +// non-struct types and nested slices containing maps or structs. +// (e.g., [][]map[string]string is not allowed but []map[string]string is OK +// and so is []map[string][]string.) +func (enc *Encoder) Encode(v interface{}) error { + rv := eindirect(reflect.ValueOf(v)) + if err := enc.safeEncode(Key([]string{}), rv); err != nil { + return err + } + return enc.w.Flush() +} + +func (enc *Encoder) safeEncode(key Key, rv reflect.Value) (err error) { + defer func() { + if r := recover(); r != nil { + if terr, ok := r.(tomlEncodeError); ok { + err = terr.error + return + } + panic(r) + } + }() + enc.encode(key, rv) + return nil +} + +func (enc *Encoder) encode(key Key, rv reflect.Value) { + // Special case. Time needs to be in ISO8601 format. + // Special case. If we can marshal the type to text, then we used that. + // Basically, this prevents the encoder for handling these types as + // generic structs (or whatever the underlying type of a TextMarshaler is). + switch rv.Interface().(type) { + case time.Time, TextMarshaler: + enc.keyEqElement(key, rv) + return + } + + k := rv.Kind() + switch k { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, + reflect.Int64, + reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, + reflect.Uint64, + reflect.Float32, reflect.Float64, reflect.String, reflect.Bool: + enc.keyEqElement(key, rv) + case reflect.Array, reflect.Slice: + if typeEqual(tomlArrayHash, tomlTypeOfGo(rv)) { + enc.eArrayOfTables(key, rv) + } else { + enc.keyEqElement(key, rv) + } + case reflect.Interface: + if rv.IsNil() { + return + } + enc.encode(key, rv.Elem()) + case reflect.Map: + if rv.IsNil() { + return + } + enc.eTable(key, rv) + case reflect.Ptr: + if rv.IsNil() { + return + } + enc.encode(key, rv.Elem()) + case reflect.Struct: + enc.eTable(key, rv) + default: + panic(e("unsupported type for key '%s': %s", key, k)) + } +} + +// eElement encodes any value that can be an array element (primitives and +// arrays). +func (enc *Encoder) eElement(rv reflect.Value) { + switch v := rv.Interface().(type) { + case time.Time: + // Special case time.Time as a primitive. Has to come before + // TextMarshaler below because time.Time implements + // encoding.TextMarshaler, but we need to always use UTC. + enc.wf(v.UTC().Format("2006-01-02T15:04:05Z")) + return + case TextMarshaler: + // Special case. Use text marshaler if it's available for this value. + if s, err := v.MarshalText(); err != nil { + encPanic(err) + } else { + enc.writeQuoted(string(s)) + } + return + } + switch rv.Kind() { + case reflect.Bool: + enc.wf(strconv.FormatBool(rv.Bool())) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, + reflect.Int64: + enc.wf(strconv.FormatInt(rv.Int(), 10)) + case reflect.Uint, reflect.Uint8, reflect.Uint16, + reflect.Uint32, reflect.Uint64: + enc.wf(strconv.FormatUint(rv.Uint(), 10)) + case reflect.Float32: + enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 32))) + case reflect.Float64: + enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 64))) + case reflect.Array, reflect.Slice: + enc.eArrayOrSliceElement(rv) + case reflect.Interface: + enc.eElement(rv.Elem()) + case reflect.String: + enc.writeQuoted(rv.String()) + default: + panic(e("unexpected primitive type: %s", rv.Kind())) + } +} + +// By the TOML spec, all floats must have a decimal with at least one +// number on either side. +func floatAddDecimal(fstr string) string { + if !strings.Contains(fstr, ".") { + return fstr + ".0" + } + return fstr +} + +func (enc *Encoder) writeQuoted(s string) { + enc.wf("\"%s\"", quotedReplacer.Replace(s)) +} + +func (enc *Encoder) eArrayOrSliceElement(rv reflect.Value) { + length := rv.Len() + enc.wf("[") + for i := 0; i < length; i++ { + elem := rv.Index(i) + enc.eElement(elem) + if i != length-1 { + enc.wf(", ") + } + } + enc.wf("]") +} + +func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) { + if len(key) == 0 { + encPanic(errNoKey) + } + for i := 0; i < rv.Len(); i++ { + trv := rv.Index(i) + if isNil(trv) { + continue + } + panicIfInvalidKey(key) + enc.newline() + enc.wf("%s[[%s]]", enc.indentStr(key), key.maybeQuotedAll()) + enc.newline() + enc.eMapOrStruct(key, trv) + } +} + +func (enc *Encoder) eTable(key Key, rv reflect.Value) { + panicIfInvalidKey(key) + if len(key) == 1 { + // Output an extra newline between top-level tables. + // (The newline isn't written if nothing else has been written though.) + enc.newline() + } + if len(key) > 0 { + enc.wf("%s[%s]", enc.indentStr(key), key.maybeQuotedAll()) + enc.newline() + } + enc.eMapOrStruct(key, rv) +} + +func (enc *Encoder) eMapOrStruct(key Key, rv reflect.Value) { + switch rv := eindirect(rv); rv.Kind() { + case reflect.Map: + enc.eMap(key, rv) + case reflect.Struct: + enc.eStruct(key, rv) + default: + panic("eTable: unhandled reflect.Value Kind: " + rv.Kind().String()) + } +} + +func (enc *Encoder) eMap(key Key, rv reflect.Value) { + rt := rv.Type() + if rt.Key().Kind() != reflect.String { + encPanic(errNonString) + } + + // Sort keys so that we have deterministic output. And write keys directly + // underneath this key first, before writing sub-structs or sub-maps. + var mapKeysDirect, mapKeysSub []string + for _, mapKey := range rv.MapKeys() { + k := mapKey.String() + if typeIsHash(tomlTypeOfGo(rv.MapIndex(mapKey))) { + mapKeysSub = append(mapKeysSub, k) + } else { + mapKeysDirect = append(mapKeysDirect, k) + } + } + + var writeMapKeys = func(mapKeys []string) { + sort.Strings(mapKeys) + for _, mapKey := range mapKeys { + mrv := rv.MapIndex(reflect.ValueOf(mapKey)) + if isNil(mrv) { + // Don't write anything for nil fields. + continue + } + enc.encode(key.add(mapKey), mrv) + } + } + writeMapKeys(mapKeysDirect) + writeMapKeys(mapKeysSub) +} + +func (enc *Encoder) eStruct(key Key, rv reflect.Value) { + // Write keys for fields directly under this key first, because if we write + // a field that creates a new table, then all keys under it will be in that + // table (not the one we're writing here). + rt := rv.Type() + var fieldsDirect, fieldsSub [][]int + var addFields func(rt reflect.Type, rv reflect.Value, start []int) + addFields = func(rt reflect.Type, rv reflect.Value, start []int) { + for i := 0; i < rt.NumField(); i++ { + f := rt.Field(i) + // skip unexported fields + if f.PkgPath != "" && !f.Anonymous { + continue + } + frv := rv.Field(i) + if f.Anonymous { + t := f.Type + switch t.Kind() { + case reflect.Struct: + // Treat anonymous struct fields with + // tag names as though they are not + // anonymous, like encoding/json does. + if getOptions(f.Tag).name == "" { + addFields(t, frv, f.Index) + continue + } + case reflect.Ptr: + if t.Elem().Kind() == reflect.Struct && + getOptions(f.Tag).name == "" { + if !frv.IsNil() { + addFields(t.Elem(), frv.Elem(), f.Index) + } + continue + } + // Fall through to the normal field encoding logic below + // for non-struct anonymous fields. + } + } + + if typeIsHash(tomlTypeOfGo(frv)) { + fieldsSub = append(fieldsSub, append(start, f.Index...)) + } else { + fieldsDirect = append(fieldsDirect, append(start, f.Index...)) + } + } + } + addFields(rt, rv, nil) + + var writeFields = func(fields [][]int) { + for _, fieldIndex := range fields { + sft := rt.FieldByIndex(fieldIndex) + sf := rv.FieldByIndex(fieldIndex) + if isNil(sf) { + // Don't write anything for nil fields. + continue + } + + opts := getOptions(sft.Tag) + if opts.skip { + continue + } + keyName := sft.Name + if opts.name != "" { + keyName = opts.name + } + if opts.omitempty && isEmpty(sf) { + continue + } + if opts.omitzero && isZero(sf) { + continue + } + + enc.encode(key.add(keyName), sf) + } + } + writeFields(fieldsDirect) + writeFields(fieldsSub) +} + +// tomlTypeName returns the TOML type name of the Go value's type. It is +// used to determine whether the types of array elements are mixed (which is +// forbidden). If the Go value is nil, then it is illegal for it to be an array +// element, and valueIsNil is returned as true. + +// Returns the TOML type of a Go value. The type may be `nil`, which means +// no concrete TOML type could be found. +func tomlTypeOfGo(rv reflect.Value) tomlType { + if isNil(rv) || !rv.IsValid() { + return nil + } + switch rv.Kind() { + case reflect.Bool: + return tomlBool + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, + reflect.Int64, + reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, + reflect.Uint64: + return tomlInteger + case reflect.Float32, reflect.Float64: + return tomlFloat + case reflect.Array, reflect.Slice: + if typeEqual(tomlHash, tomlArrayType(rv)) { + return tomlArrayHash + } + return tomlArray + case reflect.Ptr, reflect.Interface: + return tomlTypeOfGo(rv.Elem()) + case reflect.String: + return tomlString + case reflect.Map: + return tomlHash + case reflect.Struct: + switch rv.Interface().(type) { + case time.Time: + return tomlDatetime + case TextMarshaler: + return tomlString + default: + return tomlHash + } + default: + panic("unexpected reflect.Kind: " + rv.Kind().String()) + } +} + +// tomlArrayType returns the element type of a TOML array. The type returned +// may be nil if it cannot be determined (e.g., a nil slice or a zero length +// slize). This function may also panic if it finds a type that cannot be +// expressed in TOML (such as nil elements, heterogeneous arrays or directly +// nested arrays of tables). +func tomlArrayType(rv reflect.Value) tomlType { + if isNil(rv) || !rv.IsValid() || rv.Len() == 0 { + return nil + } + firstType := tomlTypeOfGo(rv.Index(0)) + if firstType == nil { + encPanic(errArrayNilElement) + } + + rvlen := rv.Len() + for i := 1; i < rvlen; i++ { + elem := rv.Index(i) + switch elemType := tomlTypeOfGo(elem); { + case elemType == nil: + encPanic(errArrayNilElement) + case !typeEqual(firstType, elemType): + encPanic(errArrayMixedElementTypes) + } + } + // If we have a nested array, then we must make sure that the nested + // array contains ONLY primitives. + // This checks arbitrarily nested arrays. + if typeEqual(firstType, tomlArray) || typeEqual(firstType, tomlArrayHash) { + nest := tomlArrayType(eindirect(rv.Index(0))) + if typeEqual(nest, tomlHash) || typeEqual(nest, tomlArrayHash) { + encPanic(errArrayNoTable) + } + } + return firstType +} + +type tagOptions struct { + skip bool // "-" + name string + omitempty bool + omitzero bool +} + +func getOptions(tag reflect.StructTag) tagOptions { + t := tag.Get("toml") + if t == "-" { + return tagOptions{skip: true} + } + var opts tagOptions + parts := strings.Split(t, ",") + opts.name = parts[0] + for _, s := range parts[1:] { + switch s { + case "omitempty": + opts.omitempty = true + case "omitzero": + opts.omitzero = true + } + } + return opts +} + +func isZero(rv reflect.Value) bool { + switch rv.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return rv.Int() == 0 + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + return rv.Uint() == 0 + case reflect.Float32, reflect.Float64: + return rv.Float() == 0.0 + } + return false +} + +func isEmpty(rv reflect.Value) bool { + switch rv.Kind() { + case reflect.Array, reflect.Slice, reflect.Map, reflect.String: + return rv.Len() == 0 + case reflect.Bool: + return !rv.Bool() + } + return false +} + +func (enc *Encoder) newline() { + if enc.hasWritten { + enc.wf("\n") + } +} + +func (enc *Encoder) keyEqElement(key Key, val reflect.Value) { + if len(key) == 0 { + encPanic(errNoKey) + } + panicIfInvalidKey(key) + enc.wf("%s%s = ", enc.indentStr(key), key.maybeQuoted(len(key)-1)) + enc.eElement(val) + enc.newline() +} + +func (enc *Encoder) wf(format string, v ...interface{}) { + if _, err := fmt.Fprintf(enc.w, format, v...); err != nil { + encPanic(err) + } + enc.hasWritten = true +} + +func (enc *Encoder) indentStr(key Key) string { + return strings.Repeat(enc.Indent, len(key)-1) +} + +func encPanic(err error) { + panic(tomlEncodeError{err}) +} + +func eindirect(v reflect.Value) reflect.Value { + switch v.Kind() { + case reflect.Ptr, reflect.Interface: + return eindirect(v.Elem()) + default: + return v + } +} + +func isNil(rv reflect.Value) bool { + switch rv.Kind() { + case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: + return rv.IsNil() + default: + return false + } +} + +func panicIfInvalidKey(key Key) { + for _, k := range key { + if len(k) == 0 { + encPanic(e("Key '%s' is not a valid table name. Key names "+ + "cannot be empty.", key.maybeQuotedAll())) + } + } +} + +func isValidKeyName(s string) bool { + return len(s) != 0 +} diff --git a/vendor/github.com/BurntSushi/toml/encoding_types.go b/vendor/github.com/BurntSushi/toml/encoding_types.go new file mode 100644 index 0000000..d36e1dd --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/encoding_types.go @@ -0,0 +1,19 @@ +// +build go1.2 + +package toml + +// In order to support Go 1.1, we define our own TextMarshaler and +// TextUnmarshaler types. For Go 1.2+, we just alias them with the +// standard library interfaces. + +import ( + "encoding" +) + +// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here +// so that Go 1.1 can be supported. +type TextMarshaler encoding.TextMarshaler + +// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined +// here so that Go 1.1 can be supported. +type TextUnmarshaler encoding.TextUnmarshaler diff --git a/vendor/github.com/BurntSushi/toml/encoding_types_1.1.go b/vendor/github.com/BurntSushi/toml/encoding_types_1.1.go new file mode 100644 index 0000000..e8d503d --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/encoding_types_1.1.go @@ -0,0 +1,18 @@ +// +build !go1.2 + +package toml + +// These interfaces were introduced in Go 1.2, so we add them manually when +// compiling for Go 1.1. + +// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here +// so that Go 1.1 can be supported. +type TextMarshaler interface { + MarshalText() (text []byte, err error) +} + +// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined +// here so that Go 1.1 can be supported. +type TextUnmarshaler interface { + UnmarshalText(text []byte) error +} diff --git a/vendor/github.com/BurntSushi/toml/lex.go b/vendor/github.com/BurntSushi/toml/lex.go new file mode 100644 index 0000000..6dee7fc --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/lex.go @@ -0,0 +1,953 @@ +package toml + +import ( + "fmt" + "strings" + "unicode" + "unicode/utf8" +) + +type itemType int + +const ( + itemError itemType = iota + itemNIL // used in the parser to indicate no type + itemEOF + itemText + itemString + itemRawString + itemMultilineString + itemRawMultilineString + itemBool + itemInteger + itemFloat + itemDatetime + itemArray // the start of an array + itemArrayEnd + itemTableStart + itemTableEnd + itemArrayTableStart + itemArrayTableEnd + itemKeyStart + itemCommentStart + itemInlineTableStart + itemInlineTableEnd +) + +const ( + eof = 0 + comma = ',' + tableStart = '[' + tableEnd = ']' + arrayTableStart = '[' + arrayTableEnd = ']' + tableSep = '.' + keySep = '=' + arrayStart = '[' + arrayEnd = ']' + commentStart = '#' + stringStart = '"' + stringEnd = '"' + rawStringStart = '\'' + rawStringEnd = '\'' + inlineTableStart = '{' + inlineTableEnd = '}' +) + +type stateFn func(lx *lexer) stateFn + +type lexer struct { + input string + start int + pos int + line int + state stateFn + items chan item + + // Allow for backing up up to three runes. + // This is necessary because TOML contains 3-rune tokens (""" and '''). + prevWidths [3]int + nprev int // how many of prevWidths are in use + // If we emit an eof, we can still back up, but it is not OK to call + // next again. + atEOF bool + + // A stack of state functions used to maintain context. + // The idea is to reuse parts of the state machine in various places. + // For example, values can appear at the top level or within arbitrarily + // nested arrays. The last state on the stack is used after a value has + // been lexed. Similarly for comments. + stack []stateFn +} + +type item struct { + typ itemType + val string + line int +} + +func (lx *lexer) nextItem() item { + for { + select { + case item := <-lx.items: + return item + default: + lx.state = lx.state(lx) + } + } +} + +func lex(input string) *lexer { + lx := &lexer{ + input: input, + state: lexTop, + line: 1, + items: make(chan item, 10), + stack: make([]stateFn, 0, 10), + } + return lx +} + +func (lx *lexer) push(state stateFn) { + lx.stack = append(lx.stack, state) +} + +func (lx *lexer) pop() stateFn { + if len(lx.stack) == 0 { + return lx.errorf("BUG in lexer: no states to pop") + } + last := lx.stack[len(lx.stack)-1] + lx.stack = lx.stack[0 : len(lx.stack)-1] + return last +} + +func (lx *lexer) current() string { + return lx.input[lx.start:lx.pos] +} + +func (lx *lexer) emit(typ itemType) { + lx.items <- item{typ, lx.current(), lx.line} + lx.start = lx.pos +} + +func (lx *lexer) emitTrim(typ itemType) { + lx.items <- item{typ, strings.TrimSpace(lx.current()), lx.line} + lx.start = lx.pos +} + +func (lx *lexer) next() (r rune) { + if lx.atEOF { + panic("next called after EOF") + } + if lx.pos >= len(lx.input) { + lx.atEOF = true + return eof + } + + if lx.input[lx.pos] == '\n' { + lx.line++ + } + lx.prevWidths[2] = lx.prevWidths[1] + lx.prevWidths[1] = lx.prevWidths[0] + if lx.nprev < 3 { + lx.nprev++ + } + r, w := utf8.DecodeRuneInString(lx.input[lx.pos:]) + lx.prevWidths[0] = w + lx.pos += w + return r +} + +// ignore skips over the pending input before this point. +func (lx *lexer) ignore() { + lx.start = lx.pos +} + +// backup steps back one rune. Can be called only twice between calls to next. +func (lx *lexer) backup() { + if lx.atEOF { + lx.atEOF = false + return + } + if lx.nprev < 1 { + panic("backed up too far") + } + w := lx.prevWidths[0] + lx.prevWidths[0] = lx.prevWidths[1] + lx.prevWidths[1] = lx.prevWidths[2] + lx.nprev-- + lx.pos -= w + if lx.pos < len(lx.input) && lx.input[lx.pos] == '\n' { + lx.line-- + } +} + +// accept consumes the next rune if it's equal to `valid`. +func (lx *lexer) accept(valid rune) bool { + if lx.next() == valid { + return true + } + lx.backup() + return false +} + +// peek returns but does not consume the next rune in the input. +func (lx *lexer) peek() rune { + r := lx.next() + lx.backup() + return r +} + +// skip ignores all input that matches the given predicate. +func (lx *lexer) skip(pred func(rune) bool) { + for { + r := lx.next() + if pred(r) { + continue + } + lx.backup() + lx.ignore() + return + } +} + +// errorf stops all lexing by emitting an error and returning `nil`. +// Note that any value that is a character is escaped if it's a special +// character (newlines, tabs, etc.). +func (lx *lexer) errorf(format string, values ...interface{}) stateFn { + lx.items <- item{ + itemError, + fmt.Sprintf(format, values...), + lx.line, + } + return nil +} + +// lexTop consumes elements at the top level of TOML data. +func lexTop(lx *lexer) stateFn { + r := lx.next() + if isWhitespace(r) || isNL(r) { + return lexSkip(lx, lexTop) + } + switch r { + case commentStart: + lx.push(lexTop) + return lexCommentStart + case tableStart: + return lexTableStart + case eof: + if lx.pos > lx.start { + return lx.errorf("unexpected EOF") + } + lx.emit(itemEOF) + return nil + } + + // At this point, the only valid item can be a key, so we back up + // and let the key lexer do the rest. + lx.backup() + lx.push(lexTopEnd) + return lexKeyStart +} + +// lexTopEnd is entered whenever a top-level item has been consumed. (A value +// or a table.) It must see only whitespace, and will turn back to lexTop +// upon a newline. If it sees EOF, it will quit the lexer successfully. +func lexTopEnd(lx *lexer) stateFn { + r := lx.next() + switch { + case r == commentStart: + // a comment will read to a newline for us. + lx.push(lexTop) + return lexCommentStart + case isWhitespace(r): + return lexTopEnd + case isNL(r): + lx.ignore() + return lexTop + case r == eof: + lx.emit(itemEOF) + return nil + } + return lx.errorf("expected a top-level item to end with a newline, "+ + "comment, or EOF, but got %q instead", r) +} + +// lexTable lexes the beginning of a table. Namely, it makes sure that +// it starts with a character other than '.' and ']'. +// It assumes that '[' has already been consumed. +// It also handles the case that this is an item in an array of tables. +// e.g., '[[name]]'. +func lexTableStart(lx *lexer) stateFn { + if lx.peek() == arrayTableStart { + lx.next() + lx.emit(itemArrayTableStart) + lx.push(lexArrayTableEnd) + } else { + lx.emit(itemTableStart) + lx.push(lexTableEnd) + } + return lexTableNameStart +} + +func lexTableEnd(lx *lexer) stateFn { + lx.emit(itemTableEnd) + return lexTopEnd +} + +func lexArrayTableEnd(lx *lexer) stateFn { + if r := lx.next(); r != arrayTableEnd { + return lx.errorf("expected end of table array name delimiter %q, "+ + "but got %q instead", arrayTableEnd, r) + } + lx.emit(itemArrayTableEnd) + return lexTopEnd +} + +func lexTableNameStart(lx *lexer) stateFn { + lx.skip(isWhitespace) + switch r := lx.peek(); { + case r == tableEnd || r == eof: + return lx.errorf("unexpected end of table name " + + "(table names cannot be empty)") + case r == tableSep: + return lx.errorf("unexpected table separator " + + "(table names cannot be empty)") + case r == stringStart || r == rawStringStart: + lx.ignore() + lx.push(lexTableNameEnd) + return lexValue // reuse string lexing + default: + return lexBareTableName + } +} + +// lexBareTableName lexes the name of a table. It assumes that at least one +// valid character for the table has already been read. +func lexBareTableName(lx *lexer) stateFn { + r := lx.next() + if isBareKeyChar(r) { + return lexBareTableName + } + lx.backup() + lx.emit(itemText) + return lexTableNameEnd +} + +// lexTableNameEnd reads the end of a piece of a table name, optionally +// consuming whitespace. +func lexTableNameEnd(lx *lexer) stateFn { + lx.skip(isWhitespace) + switch r := lx.next(); { + case isWhitespace(r): + return lexTableNameEnd + case r == tableSep: + lx.ignore() + return lexTableNameStart + case r == tableEnd: + return lx.pop() + default: + return lx.errorf("expected '.' or ']' to end table name, "+ + "but got %q instead", r) + } +} + +// lexKeyStart consumes a key name up until the first non-whitespace character. +// lexKeyStart will ignore whitespace. +func lexKeyStart(lx *lexer) stateFn { + r := lx.peek() + switch { + case r == keySep: + return lx.errorf("unexpected key separator %q", keySep) + case isWhitespace(r) || isNL(r): + lx.next() + return lexSkip(lx, lexKeyStart) + case r == stringStart || r == rawStringStart: + lx.ignore() + lx.emit(itemKeyStart) + lx.push(lexKeyEnd) + return lexValue // reuse string lexing + default: + lx.ignore() + lx.emit(itemKeyStart) + return lexBareKey + } +} + +// lexBareKey consumes the text of a bare key. Assumes that the first character +// (which is not whitespace) has not yet been consumed. +func lexBareKey(lx *lexer) stateFn { + switch r := lx.next(); { + case isBareKeyChar(r): + return lexBareKey + case isWhitespace(r): + lx.backup() + lx.emit(itemText) + return lexKeyEnd + case r == keySep: + lx.backup() + lx.emit(itemText) + return lexKeyEnd + default: + return lx.errorf("bare keys cannot contain %q", r) + } +} + +// lexKeyEnd consumes the end of a key and trims whitespace (up to the key +// separator). +func lexKeyEnd(lx *lexer) stateFn { + switch r := lx.next(); { + case r == keySep: + return lexSkip(lx, lexValue) + case isWhitespace(r): + return lexSkip(lx, lexKeyEnd) + default: + return lx.errorf("expected key separator %q, but got %q instead", + keySep, r) + } +} + +// lexValue starts the consumption of a value anywhere a value is expected. +// lexValue will ignore whitespace. +// After a value is lexed, the last state on the next is popped and returned. +func lexValue(lx *lexer) stateFn { + // We allow whitespace to precede a value, but NOT newlines. + // In array syntax, the array states are responsible for ignoring newlines. + r := lx.next() + switch { + case isWhitespace(r): + return lexSkip(lx, lexValue) + case isDigit(r): + lx.backup() // avoid an extra state and use the same as above + return lexNumberOrDateStart + } + switch r { + case arrayStart: + lx.ignore() + lx.emit(itemArray) + return lexArrayValue + case inlineTableStart: + lx.ignore() + lx.emit(itemInlineTableStart) + return lexInlineTableValue + case stringStart: + if lx.accept(stringStart) { + if lx.accept(stringStart) { + lx.ignore() // Ignore """ + return lexMultilineString + } + lx.backup() + } + lx.ignore() // ignore the '"' + return lexString + case rawStringStart: + if lx.accept(rawStringStart) { + if lx.accept(rawStringStart) { + lx.ignore() // Ignore """ + return lexMultilineRawString + } + lx.backup() + } + lx.ignore() // ignore the "'" + return lexRawString + case '+', '-': + return lexNumberStart + case '.': // special error case, be kind to users + return lx.errorf("floats must start with a digit, not '.'") + } + if unicode.IsLetter(r) { + // Be permissive here; lexBool will give a nice error if the + // user wrote something like + // x = foo + // (i.e. not 'true' or 'false' but is something else word-like.) + lx.backup() + return lexBool + } + return lx.errorf("expected value but found %q instead", r) +} + +// lexArrayValue consumes one value in an array. It assumes that '[' or ',' +// have already been consumed. All whitespace and newlines are ignored. +func lexArrayValue(lx *lexer) stateFn { + r := lx.next() + switch { + case isWhitespace(r) || isNL(r): + return lexSkip(lx, lexArrayValue) + case r == commentStart: + lx.push(lexArrayValue) + return lexCommentStart + case r == comma: + return lx.errorf("unexpected comma") + case r == arrayEnd: + // NOTE(caleb): The spec isn't clear about whether you can have + // a trailing comma or not, so we'll allow it. + return lexArrayEnd + } + + lx.backup() + lx.push(lexArrayValueEnd) + return lexValue +} + +// lexArrayValueEnd consumes everything between the end of an array value and +// the next value (or the end of the array): it ignores whitespace and newlines +// and expects either a ',' or a ']'. +func lexArrayValueEnd(lx *lexer) stateFn { + r := lx.next() + switch { + case isWhitespace(r) || isNL(r): + return lexSkip(lx, lexArrayValueEnd) + case r == commentStart: + lx.push(lexArrayValueEnd) + return lexCommentStart + case r == comma: + lx.ignore() + return lexArrayValue // move on to the next value + case r == arrayEnd: + return lexArrayEnd + } + return lx.errorf( + "expected a comma or array terminator %q, but got %q instead", + arrayEnd, r, + ) +} + +// lexArrayEnd finishes the lexing of an array. +// It assumes that a ']' has just been consumed. +func lexArrayEnd(lx *lexer) stateFn { + lx.ignore() + lx.emit(itemArrayEnd) + return lx.pop() +} + +// lexInlineTableValue consumes one key/value pair in an inline table. +// It assumes that '{' or ',' have already been consumed. Whitespace is ignored. +func lexInlineTableValue(lx *lexer) stateFn { + r := lx.next() + switch { + case isWhitespace(r): + return lexSkip(lx, lexInlineTableValue) + case isNL(r): + return lx.errorf("newlines not allowed within inline tables") + case r == commentStart: + lx.push(lexInlineTableValue) + return lexCommentStart + case r == comma: + return lx.errorf("unexpected comma") + case r == inlineTableEnd: + return lexInlineTableEnd + } + lx.backup() + lx.push(lexInlineTableValueEnd) + return lexKeyStart +} + +// lexInlineTableValueEnd consumes everything between the end of an inline table +// key/value pair and the next pair (or the end of the table): +// it ignores whitespace and expects either a ',' or a '}'. +func lexInlineTableValueEnd(lx *lexer) stateFn { + r := lx.next() + switch { + case isWhitespace(r): + return lexSkip(lx, lexInlineTableValueEnd) + case isNL(r): + return lx.errorf("newlines not allowed within inline tables") + case r == commentStart: + lx.push(lexInlineTableValueEnd) + return lexCommentStart + case r == comma: + lx.ignore() + return lexInlineTableValue + case r == inlineTableEnd: + return lexInlineTableEnd + } + return lx.errorf("expected a comma or an inline table terminator %q, "+ + "but got %q instead", inlineTableEnd, r) +} + +// lexInlineTableEnd finishes the lexing of an inline table. +// It assumes that a '}' has just been consumed. +func lexInlineTableEnd(lx *lexer) stateFn { + lx.ignore() + lx.emit(itemInlineTableEnd) + return lx.pop() +} + +// lexString consumes the inner contents of a string. It assumes that the +// beginning '"' has already been consumed and ignored. +func lexString(lx *lexer) stateFn { + r := lx.next() + switch { + case r == eof: + return lx.errorf("unexpected EOF") + case isNL(r): + return lx.errorf("strings cannot contain newlines") + case r == '\\': + lx.push(lexString) + return lexStringEscape + case r == stringEnd: + lx.backup() + lx.emit(itemString) + lx.next() + lx.ignore() + return lx.pop() + } + return lexString +} + +// lexMultilineString consumes the inner contents of a string. It assumes that +// the beginning '"""' has already been consumed and ignored. +func lexMultilineString(lx *lexer) stateFn { + switch lx.next() { + case eof: + return lx.errorf("unexpected EOF") + case '\\': + return lexMultilineStringEscape + case stringEnd: + if lx.accept(stringEnd) { + if lx.accept(stringEnd) { + lx.backup() + lx.backup() + lx.backup() + lx.emit(itemMultilineString) + lx.next() + lx.next() + lx.next() + lx.ignore() + return lx.pop() + } + lx.backup() + } + } + return lexMultilineString +} + +// lexRawString consumes a raw string. Nothing can be escaped in such a string. +// It assumes that the beginning "'" has already been consumed and ignored. +func lexRawString(lx *lexer) stateFn { + r := lx.next() + switch { + case r == eof: + return lx.errorf("unexpected EOF") + case isNL(r): + return lx.errorf("strings cannot contain newlines") + case r == rawStringEnd: + lx.backup() + lx.emit(itemRawString) + lx.next() + lx.ignore() + return lx.pop() + } + return lexRawString +} + +// lexMultilineRawString consumes a raw string. Nothing can be escaped in such +// a string. It assumes that the beginning "'''" has already been consumed and +// ignored. +func lexMultilineRawString(lx *lexer) stateFn { + switch lx.next() { + case eof: + return lx.errorf("unexpected EOF") + case rawStringEnd: + if lx.accept(rawStringEnd) { + if lx.accept(rawStringEnd) { + lx.backup() + lx.backup() + lx.backup() + lx.emit(itemRawMultilineString) + lx.next() + lx.next() + lx.next() + lx.ignore() + return lx.pop() + } + lx.backup() + } + } + return lexMultilineRawString +} + +// lexMultilineStringEscape consumes an escaped character. It assumes that the +// preceding '\\' has already been consumed. +func lexMultilineStringEscape(lx *lexer) stateFn { + // Handle the special case first: + if isNL(lx.next()) { + return lexMultilineString + } + lx.backup() + lx.push(lexMultilineString) + return lexStringEscape(lx) +} + +func lexStringEscape(lx *lexer) stateFn { + r := lx.next() + switch r { + case 'b': + fallthrough + case 't': + fallthrough + case 'n': + fallthrough + case 'f': + fallthrough + case 'r': + fallthrough + case '"': + fallthrough + case '\\': + return lx.pop() + case 'u': + return lexShortUnicodeEscape + case 'U': + return lexLongUnicodeEscape + } + return lx.errorf("invalid escape character %q; only the following "+ + "escape characters are allowed: "+ + `\b, \t, \n, \f, \r, \", \\, \uXXXX, and \UXXXXXXXX`, r) +} + +func lexShortUnicodeEscape(lx *lexer) stateFn { + var r rune + for i := 0; i < 4; i++ { + r = lx.next() + if !isHexadecimal(r) { + return lx.errorf(`expected four hexadecimal digits after '\u', `+ + "but got %q instead", lx.current()) + } + } + return lx.pop() +} + +func lexLongUnicodeEscape(lx *lexer) stateFn { + var r rune + for i := 0; i < 8; i++ { + r = lx.next() + if !isHexadecimal(r) { + return lx.errorf(`expected eight hexadecimal digits after '\U', `+ + "but got %q instead", lx.current()) + } + } + return lx.pop() +} + +// lexNumberOrDateStart consumes either an integer, a float, or datetime. +func lexNumberOrDateStart(lx *lexer) stateFn { + r := lx.next() + if isDigit(r) { + return lexNumberOrDate + } + switch r { + case '_': + return lexNumber + case 'e', 'E': + return lexFloat + case '.': + return lx.errorf("floats must start with a digit, not '.'") + } + return lx.errorf("expected a digit but got %q", r) +} + +// lexNumberOrDate consumes either an integer, float or datetime. +func lexNumberOrDate(lx *lexer) stateFn { + r := lx.next() + if isDigit(r) { + return lexNumberOrDate + } + switch r { + case '-': + return lexDatetime + case '_': + return lexNumber + case '.', 'e', 'E': + return lexFloat + } + + lx.backup() + lx.emit(itemInteger) + return lx.pop() +} + +// lexDatetime consumes a Datetime, to a first approximation. +// The parser validates that it matches one of the accepted formats. +func lexDatetime(lx *lexer) stateFn { + r := lx.next() + if isDigit(r) { + return lexDatetime + } + switch r { + case '-', 'T', ':', '.', 'Z': + return lexDatetime + } + + lx.backup() + lx.emit(itemDatetime) + return lx.pop() +} + +// lexNumberStart consumes either an integer or a float. It assumes that a sign +// has already been read, but that *no* digits have been consumed. +// lexNumberStart will move to the appropriate integer or float states. +func lexNumberStart(lx *lexer) stateFn { + // We MUST see a digit. Even floats have to start with a digit. + r := lx.next() + if !isDigit(r) { + if r == '.' { + return lx.errorf("floats must start with a digit, not '.'") + } + return lx.errorf("expected a digit but got %q", r) + } + return lexNumber +} + +// lexNumber consumes an integer or a float after seeing the first digit. +func lexNumber(lx *lexer) stateFn { + r := lx.next() + if isDigit(r) { + return lexNumber + } + switch r { + case '_': + return lexNumber + case '.', 'e', 'E': + return lexFloat + } + + lx.backup() + lx.emit(itemInteger) + return lx.pop() +} + +// lexFloat consumes the elements of a float. It allows any sequence of +// float-like characters, so floats emitted by the lexer are only a first +// approximation and must be validated by the parser. +func lexFloat(lx *lexer) stateFn { + r := lx.next() + if isDigit(r) { + return lexFloat + } + switch r { + case '_', '.', '-', '+', 'e', 'E': + return lexFloat + } + + lx.backup() + lx.emit(itemFloat) + return lx.pop() +} + +// lexBool consumes a bool string: 'true' or 'false. +func lexBool(lx *lexer) stateFn { + var rs []rune + for { + r := lx.next() + if !unicode.IsLetter(r) { + lx.backup() + break + } + rs = append(rs, r) + } + s := string(rs) + switch s { + case "true", "false": + lx.emit(itemBool) + return lx.pop() + } + return lx.errorf("expected value but found %q instead", s) +} + +// lexCommentStart begins the lexing of a comment. It will emit +// itemCommentStart and consume no characters, passing control to lexComment. +func lexCommentStart(lx *lexer) stateFn { + lx.ignore() + lx.emit(itemCommentStart) + return lexComment +} + +// lexComment lexes an entire comment. It assumes that '#' has been consumed. +// It will consume *up to* the first newline character, and pass control +// back to the last state on the stack. +func lexComment(lx *lexer) stateFn { + r := lx.peek() + if isNL(r) || r == eof { + lx.emit(itemText) + return lx.pop() + } + lx.next() + return lexComment +} + +// lexSkip ignores all slurped input and moves on to the next state. +func lexSkip(lx *lexer, nextState stateFn) stateFn { + return func(lx *lexer) stateFn { + lx.ignore() + return nextState + } +} + +// isWhitespace returns true if `r` is a whitespace character according +// to the spec. +func isWhitespace(r rune) bool { + return r == '\t' || r == ' ' +} + +func isNL(r rune) bool { + return r == '\n' || r == '\r' +} + +func isDigit(r rune) bool { + return r >= '0' && r <= '9' +} + +func isHexadecimal(r rune) bool { + return (r >= '0' && r <= '9') || + (r >= 'a' && r <= 'f') || + (r >= 'A' && r <= 'F') +} + +func isBareKeyChar(r rune) bool { + return (r >= 'A' && r <= 'Z') || + (r >= 'a' && r <= 'z') || + (r >= '0' && r <= '9') || + r == '_' || + r == '-' +} + +func (itype itemType) String() string { + switch itype { + case itemError: + return "Error" + case itemNIL: + return "NIL" + case itemEOF: + return "EOF" + case itemText: + return "Text" + case itemString, itemRawString, itemMultilineString, itemRawMultilineString: + return "String" + case itemBool: + return "Bool" + case itemInteger: + return "Integer" + case itemFloat: + return "Float" + case itemDatetime: + return "DateTime" + case itemTableStart: + return "TableStart" + case itemTableEnd: + return "TableEnd" + case itemKeyStart: + return "KeyStart" + case itemArray: + return "Array" + case itemArrayEnd: + return "ArrayEnd" + case itemCommentStart: + return "CommentStart" + } + panic(fmt.Sprintf("BUG: Unknown type '%d'.", int(itype))) +} + +func (item item) String() string { + return fmt.Sprintf("(%s, %s)", item.typ.String(), item.val) +} diff --git a/vendor/github.com/BurntSushi/toml/parse.go b/vendor/github.com/BurntSushi/toml/parse.go new file mode 100644 index 0000000..50869ef --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/parse.go @@ -0,0 +1,592 @@ +package toml + +import ( + "fmt" + "strconv" + "strings" + "time" + "unicode" + "unicode/utf8" +) + +type parser struct { + mapping map[string]interface{} + types map[string]tomlType + lx *lexer + + // A list of keys in the order that they appear in the TOML data. + ordered []Key + + // the full key for the current hash in scope + context Key + + // the base key name for everything except hashes + currentKey string + + // rough approximation of line number + approxLine int + + // A map of 'key.group.names' to whether they were created implicitly. + implicits map[string]bool +} + +type parseError string + +func (pe parseError) Error() string { + return string(pe) +} + +func parse(data string) (p *parser, err error) { + defer func() { + if r := recover(); r != nil { + var ok bool + if err, ok = r.(parseError); ok { + return + } + panic(r) + } + }() + + p = &parser{ + mapping: make(map[string]interface{}), + types: make(map[string]tomlType), + lx: lex(data), + ordered: make([]Key, 0), + implicits: make(map[string]bool), + } + for { + item := p.next() + if item.typ == itemEOF { + break + } + p.topLevel(item) + } + + return p, nil +} + +func (p *parser) panicf(format string, v ...interface{}) { + msg := fmt.Sprintf("Near line %d (last key parsed '%s'): %s", + p.approxLine, p.current(), fmt.Sprintf(format, v...)) + panic(parseError(msg)) +} + +func (p *parser) next() item { + it := p.lx.nextItem() + if it.typ == itemError { + p.panicf("%s", it.val) + } + return it +} + +func (p *parser) bug(format string, v ...interface{}) { + panic(fmt.Sprintf("BUG: "+format+"\n\n", v...)) +} + +func (p *parser) expect(typ itemType) item { + it := p.next() + p.assertEqual(typ, it.typ) + return it +} + +func (p *parser) assertEqual(expected, got itemType) { + if expected != got { + p.bug("Expected '%s' but got '%s'.", expected, got) + } +} + +func (p *parser) topLevel(item item) { + switch item.typ { + case itemCommentStart: + p.approxLine = item.line + p.expect(itemText) + case itemTableStart: + kg := p.next() + p.approxLine = kg.line + + var key Key + for ; kg.typ != itemTableEnd && kg.typ != itemEOF; kg = p.next() { + key = append(key, p.keyString(kg)) + } + p.assertEqual(itemTableEnd, kg.typ) + + p.establishContext(key, false) + p.setType("", tomlHash) + p.ordered = append(p.ordered, key) + case itemArrayTableStart: + kg := p.next() + p.approxLine = kg.line + + var key Key + for ; kg.typ != itemArrayTableEnd && kg.typ != itemEOF; kg = p.next() { + key = append(key, p.keyString(kg)) + } + p.assertEqual(itemArrayTableEnd, kg.typ) + + p.establishContext(key, true) + p.setType("", tomlArrayHash) + p.ordered = append(p.ordered, key) + case itemKeyStart: + kname := p.next() + p.approxLine = kname.line + p.currentKey = p.keyString(kname) + + val, typ := p.value(p.next()) + p.setValue(p.currentKey, val) + p.setType(p.currentKey, typ) + p.ordered = append(p.ordered, p.context.add(p.currentKey)) + p.currentKey = "" + default: + p.bug("Unexpected type at top level: %s", item.typ) + } +} + +// Gets a string for a key (or part of a key in a table name). +func (p *parser) keyString(it item) string { + switch it.typ { + case itemText: + return it.val + case itemString, itemMultilineString, + itemRawString, itemRawMultilineString: + s, _ := p.value(it) + return s.(string) + default: + p.bug("Unexpected key type: %s", it.typ) + panic("unreachable") + } +} + +// value translates an expected value from the lexer into a Go value wrapped +// as an empty interface. +func (p *parser) value(it item) (interface{}, tomlType) { + switch it.typ { + case itemString: + return p.replaceEscapes(it.val), p.typeOfPrimitive(it) + case itemMultilineString: + trimmed := stripFirstNewline(stripEscapedWhitespace(it.val)) + return p.replaceEscapes(trimmed), p.typeOfPrimitive(it) + case itemRawString: + return it.val, p.typeOfPrimitive(it) + case itemRawMultilineString: + return stripFirstNewline(it.val), p.typeOfPrimitive(it) + case itemBool: + switch it.val { + case "true": + return true, p.typeOfPrimitive(it) + case "false": + return false, p.typeOfPrimitive(it) + } + p.bug("Expected boolean value, but got '%s'.", it.val) + case itemInteger: + if !numUnderscoresOK(it.val) { + p.panicf("Invalid integer %q: underscores must be surrounded by digits", + it.val) + } + val := strings.Replace(it.val, "_", "", -1) + num, err := strconv.ParseInt(val, 10, 64) + if err != nil { + // Distinguish integer values. Normally, it'd be a bug if the lexer + // provides an invalid integer, but it's possible that the number is + // out of range of valid values (which the lexer cannot determine). + // So mark the former as a bug but the latter as a legitimate user + // error. + if e, ok := err.(*strconv.NumError); ok && + e.Err == strconv.ErrRange { + + p.panicf("Integer '%s' is out of the range of 64-bit "+ + "signed integers.", it.val) + } else { + p.bug("Expected integer value, but got '%s'.", it.val) + } + } + return num, p.typeOfPrimitive(it) + case itemFloat: + parts := strings.FieldsFunc(it.val, func(r rune) bool { + switch r { + case '.', 'e', 'E': + return true + } + return false + }) + for _, part := range parts { + if !numUnderscoresOK(part) { + p.panicf("Invalid float %q: underscores must be "+ + "surrounded by digits", it.val) + } + } + if !numPeriodsOK(it.val) { + // As a special case, numbers like '123.' or '1.e2', + // which are valid as far as Go/strconv are concerned, + // must be rejected because TOML says that a fractional + // part consists of '.' followed by 1+ digits. + p.panicf("Invalid float %q: '.' must be followed "+ + "by one or more digits", it.val) + } + val := strings.Replace(it.val, "_", "", -1) + num, err := strconv.ParseFloat(val, 64) + if err != nil { + if e, ok := err.(*strconv.NumError); ok && + e.Err == strconv.ErrRange { + + p.panicf("Float '%s' is out of the range of 64-bit "+ + "IEEE-754 floating-point numbers.", it.val) + } else { + p.panicf("Invalid float value: %q", it.val) + } + } + return num, p.typeOfPrimitive(it) + case itemDatetime: + var t time.Time + var ok bool + var err error + for _, format := range []string{ + "2006-01-02T15:04:05Z07:00", + "2006-01-02T15:04:05", + "2006-01-02", + } { + t, err = time.ParseInLocation(format, it.val, time.Local) + if err == nil { + ok = true + break + } + } + if !ok { + p.panicf("Invalid TOML Datetime: %q.", it.val) + } + return t, p.typeOfPrimitive(it) + case itemArray: + array := make([]interface{}, 0) + types := make([]tomlType, 0) + + for it = p.next(); it.typ != itemArrayEnd; it = p.next() { + if it.typ == itemCommentStart { + p.expect(itemText) + continue + } + + val, typ := p.value(it) + array = append(array, val) + types = append(types, typ) + } + return array, p.typeOfArray(types) + case itemInlineTableStart: + var ( + hash = make(map[string]interface{}) + outerContext = p.context + outerKey = p.currentKey + ) + + p.context = append(p.context, p.currentKey) + p.currentKey = "" + for it := p.next(); it.typ != itemInlineTableEnd; it = p.next() { + if it.typ != itemKeyStart { + p.bug("Expected key start but instead found %q, around line %d", + it.val, p.approxLine) + } + if it.typ == itemCommentStart { + p.expect(itemText) + continue + } + + // retrieve key + k := p.next() + p.approxLine = k.line + kname := p.keyString(k) + + // retrieve value + p.currentKey = kname + val, typ := p.value(p.next()) + // make sure we keep metadata up to date + p.setType(kname, typ) + p.ordered = append(p.ordered, p.context.add(p.currentKey)) + hash[kname] = val + } + p.context = outerContext + p.currentKey = outerKey + return hash, tomlHash + } + p.bug("Unexpected value type: %s", it.typ) + panic("unreachable") +} + +// numUnderscoresOK checks whether each underscore in s is surrounded by +// characters that are not underscores. +func numUnderscoresOK(s string) bool { + accept := false + for _, r := range s { + if r == '_' { + if !accept { + return false + } + accept = false + continue + } + accept = true + } + return accept +} + +// numPeriodsOK checks whether every period in s is followed by a digit. +func numPeriodsOK(s string) bool { + period := false + for _, r := range s { + if period && !isDigit(r) { + return false + } + period = r == '.' + } + return !period +} + +// establishContext sets the current context of the parser, +// where the context is either a hash or an array of hashes. Which one is +// set depends on the value of the `array` parameter. +// +// Establishing the context also makes sure that the key isn't a duplicate, and +// will create implicit hashes automatically. +func (p *parser) establishContext(key Key, array bool) { + var ok bool + + // Always start at the top level and drill down for our context. + hashContext := p.mapping + keyContext := make(Key, 0) + + // We only need implicit hashes for key[0:-1] + for _, k := range key[0 : len(key)-1] { + _, ok = hashContext[k] + keyContext = append(keyContext, k) + + // No key? Make an implicit hash and move on. + if !ok { + p.addImplicit(keyContext) + hashContext[k] = make(map[string]interface{}) + } + + // If the hash context is actually an array of tables, then set + // the hash context to the last element in that array. + // + // Otherwise, it better be a table, since this MUST be a key group (by + // virtue of it not being the last element in a key). + switch t := hashContext[k].(type) { + case []map[string]interface{}: + hashContext = t[len(t)-1] + case map[string]interface{}: + hashContext = t + default: + p.panicf("Key '%s' was already created as a hash.", keyContext) + } + } + + p.context = keyContext + if array { + // If this is the first element for this array, then allocate a new + // list of tables for it. + k := key[len(key)-1] + if _, ok := hashContext[k]; !ok { + hashContext[k] = make([]map[string]interface{}, 0, 5) + } + + // Add a new table. But make sure the key hasn't already been used + // for something else. + if hash, ok := hashContext[k].([]map[string]interface{}); ok { + hashContext[k] = append(hash, make(map[string]interface{})) + } else { + p.panicf("Key '%s' was already created and cannot be used as "+ + "an array.", keyContext) + } + } else { + p.setValue(key[len(key)-1], make(map[string]interface{})) + } + p.context = append(p.context, key[len(key)-1]) +} + +// setValue sets the given key to the given value in the current context. +// It will make sure that the key hasn't already been defined, account for +// implicit key groups. +func (p *parser) setValue(key string, value interface{}) { + var tmpHash interface{} + var ok bool + + hash := p.mapping + keyContext := make(Key, 0) + for _, k := range p.context { + keyContext = append(keyContext, k) + if tmpHash, ok = hash[k]; !ok { + p.bug("Context for key '%s' has not been established.", keyContext) + } + switch t := tmpHash.(type) { + case []map[string]interface{}: + // The context is a table of hashes. Pick the most recent table + // defined as the current hash. + hash = t[len(t)-1] + case map[string]interface{}: + hash = t + default: + p.bug("Expected hash to have type 'map[string]interface{}', but "+ + "it has '%T' instead.", tmpHash) + } + } + keyContext = append(keyContext, key) + + if _, ok := hash[key]; ok { + // Typically, if the given key has already been set, then we have + // to raise an error since duplicate keys are disallowed. However, + // it's possible that a key was previously defined implicitly. In this + // case, it is allowed to be redefined concretely. (See the + // `tests/valid/implicit-and-explicit-after.toml` test in `toml-test`.) + // + // But we have to make sure to stop marking it as an implicit. (So that + // another redefinition provokes an error.) + // + // Note that since it has already been defined (as a hash), we don't + // want to overwrite it. So our business is done. + if p.isImplicit(keyContext) { + p.removeImplicit(keyContext) + return + } + + // Otherwise, we have a concrete key trying to override a previous + // key, which is *always* wrong. + p.panicf("Key '%s' has already been defined.", keyContext) + } + hash[key] = value +} + +// setType sets the type of a particular value at a given key. +// It should be called immediately AFTER setValue. +// +// Note that if `key` is empty, then the type given will be applied to the +// current context (which is either a table or an array of tables). +func (p *parser) setType(key string, typ tomlType) { + keyContext := make(Key, 0, len(p.context)+1) + for _, k := range p.context { + keyContext = append(keyContext, k) + } + if len(key) > 0 { // allow type setting for hashes + keyContext = append(keyContext, key) + } + p.types[keyContext.String()] = typ +} + +// addImplicit sets the given Key as having been created implicitly. +func (p *parser) addImplicit(key Key) { + p.implicits[key.String()] = true +} + +// removeImplicit stops tagging the given key as having been implicitly +// created. +func (p *parser) removeImplicit(key Key) { + p.implicits[key.String()] = false +} + +// isImplicit returns true if the key group pointed to by the key was created +// implicitly. +func (p *parser) isImplicit(key Key) bool { + return p.implicits[key.String()] +} + +// current returns the full key name of the current context. +func (p *parser) current() string { + if len(p.currentKey) == 0 { + return p.context.String() + } + if len(p.context) == 0 { + return p.currentKey + } + return fmt.Sprintf("%s.%s", p.context, p.currentKey) +} + +func stripFirstNewline(s string) string { + if len(s) == 0 || s[0] != '\n' { + return s + } + return s[1:] +} + +func stripEscapedWhitespace(s string) string { + esc := strings.Split(s, "\\\n") + if len(esc) > 1 { + for i := 1; i < len(esc); i++ { + esc[i] = strings.TrimLeftFunc(esc[i], unicode.IsSpace) + } + } + return strings.Join(esc, "") +} + +func (p *parser) replaceEscapes(str string) string { + var replaced []rune + s := []byte(str) + r := 0 + for r < len(s) { + if s[r] != '\\' { + c, size := utf8.DecodeRune(s[r:]) + r += size + replaced = append(replaced, c) + continue + } + r += 1 + if r >= len(s) { + p.bug("Escape sequence at end of string.") + return "" + } + switch s[r] { + default: + p.bug("Expected valid escape code after \\, but got %q.", s[r]) + return "" + case 'b': + replaced = append(replaced, rune(0x0008)) + r += 1 + case 't': + replaced = append(replaced, rune(0x0009)) + r += 1 + case 'n': + replaced = append(replaced, rune(0x000A)) + r += 1 + case 'f': + replaced = append(replaced, rune(0x000C)) + r += 1 + case 'r': + replaced = append(replaced, rune(0x000D)) + r += 1 + case '"': + replaced = append(replaced, rune(0x0022)) + r += 1 + case '\\': + replaced = append(replaced, rune(0x005C)) + r += 1 + case 'u': + // At this point, we know we have a Unicode escape of the form + // `uXXXX` at [r, r+5). (Because the lexer guarantees this + // for us.) + escaped := p.asciiEscapeToUnicode(s[r+1 : r+5]) + replaced = append(replaced, escaped) + r += 5 + case 'U': + // At this point, we know we have a Unicode escape of the form + // `uXXXX` at [r, r+9). (Because the lexer guarantees this + // for us.) + escaped := p.asciiEscapeToUnicode(s[r+1 : r+9]) + replaced = append(replaced, escaped) + r += 9 + } + } + return string(replaced) +} + +func (p *parser) asciiEscapeToUnicode(bs []byte) rune { + s := string(bs) + hex, err := strconv.ParseUint(strings.ToLower(s), 16, 32) + if err != nil { + p.bug("Could not parse '%s' as a hexadecimal number, but the "+ + "lexer claims it's OK: %s", s, err) + } + if !utf8.ValidRune(rune(hex)) { + p.panicf("Escaped character '\\u%s' is not valid UTF-8.", s) + } + return rune(hex) +} + +func isStringType(ty itemType) bool { + return ty == itemString || ty == itemMultilineString || + ty == itemRawString || ty == itemRawMultilineString +} diff --git a/vendor/github.com/BurntSushi/toml/session.vim b/vendor/github.com/BurntSushi/toml/session.vim new file mode 100644 index 0000000..562164b --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/session.vim @@ -0,0 +1 @@ +au BufWritePost *.go silent!make tags > /dev/null 2>&1 diff --git a/vendor/github.com/BurntSushi/toml/type_check.go b/vendor/github.com/BurntSushi/toml/type_check.go new file mode 100644 index 0000000..c73f8af --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/type_check.go @@ -0,0 +1,91 @@ +package toml + +// tomlType represents any Go type that corresponds to a TOML type. +// While the first draft of the TOML spec has a simplistic type system that +// probably doesn't need this level of sophistication, we seem to be militating +// toward adding real composite types. +type tomlType interface { + typeString() string +} + +// typeEqual accepts any two types and returns true if they are equal. +func typeEqual(t1, t2 tomlType) bool { + if t1 == nil || t2 == nil { + return false + } + return t1.typeString() == t2.typeString() +} + +func typeIsHash(t tomlType) bool { + return typeEqual(t, tomlHash) || typeEqual(t, tomlArrayHash) +} + +type tomlBaseType string + +func (btype tomlBaseType) typeString() string { + return string(btype) +} + +func (btype tomlBaseType) String() string { + return btype.typeString() +} + +var ( + tomlInteger tomlBaseType = "Integer" + tomlFloat tomlBaseType = "Float" + tomlDatetime tomlBaseType = "Datetime" + tomlString tomlBaseType = "String" + tomlBool tomlBaseType = "Bool" + tomlArray tomlBaseType = "Array" + tomlHash tomlBaseType = "Hash" + tomlArrayHash tomlBaseType = "ArrayHash" +) + +// typeOfPrimitive returns a tomlType of any primitive value in TOML. +// Primitive values are: Integer, Float, Datetime, String and Bool. +// +// Passing a lexer item other than the following will cause a BUG message +// to occur: itemString, itemBool, itemInteger, itemFloat, itemDatetime. +func (p *parser) typeOfPrimitive(lexItem item) tomlType { + switch lexItem.typ { + case itemInteger: + return tomlInteger + case itemFloat: + return tomlFloat + case itemDatetime: + return tomlDatetime + case itemString: + return tomlString + case itemMultilineString: + return tomlString + case itemRawString: + return tomlString + case itemRawMultilineString: + return tomlString + case itemBool: + return tomlBool + } + p.bug("Cannot infer primitive type of lex item '%s'.", lexItem) + panic("unreachable") +} + +// typeOfArray returns a tomlType for an array given a list of types of its +// values. +// +// In the current spec, if an array is homogeneous, then its type is always +// "Array". If the array is not homogeneous, an error is generated. +func (p *parser) typeOfArray(types []tomlType) tomlType { + // Empty arrays are cool. + if len(types) == 0 { + return tomlArray + } + + theType := types[0] + for _, t := range types[1:] { + if !typeEqual(theType, t) { + p.panicf("Array contains values of type '%s' and '%s', but "+ + "arrays must be homogeneous.", theType, t) + } + } + return tomlArray +} diff --git a/vendor/github.com/BurntSushi/toml/type_fields.go b/vendor/github.com/BurntSushi/toml/type_fields.go new file mode 100644 index 0000000..608997c --- /dev/null +++ b/vendor/github.com/BurntSushi/toml/type_fields.go @@ -0,0 +1,242 @@ +package toml + +// Struct field handling is adapted from code in encoding/json: +// +// Copyright 2010 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the Go distribution. + +import ( + "reflect" + "sort" + "sync" +) + +// A field represents a single field found in a struct. +type field struct { + name string // the name of the field (`toml` tag included) + tag bool // whether field has a `toml` tag + index []int // represents the depth of an anonymous field + typ reflect.Type // the type of the field +} + +// byName sorts field by name, breaking ties with depth, +// then breaking ties with "name came from toml tag", then +// breaking ties with index sequence. +type byName []field + +func (x byName) Len() int { return len(x) } + +func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +func (x byName) Less(i, j int) bool { + if x[i].name != x[j].name { + return x[i].name < x[j].name + } + if len(x[i].index) != len(x[j].index) { + return len(x[i].index) < len(x[j].index) + } + if x[i].tag != x[j].tag { + return x[i].tag + } + return byIndex(x).Less(i, j) +} + +// byIndex sorts field by index sequence. +type byIndex []field + +func (x byIndex) Len() int { return len(x) } + +func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] } + +func (x byIndex) Less(i, j int) bool { + for k, xik := range x[i].index { + if k >= len(x[j].index) { + return false + } + if xik != x[j].index[k] { + return xik < x[j].index[k] + } + } + return len(x[i].index) < len(x[j].index) +} + +// typeFields returns a list of fields that TOML should recognize for the given +// type. The algorithm is breadth-first search over the set of structs to +// include - the top struct and then any reachable anonymous structs. +func typeFields(t reflect.Type) []field { + // Anonymous fields to explore at the current level and the next. + current := []field{} + next := []field{{typ: t}} + + // Count of queued names for current level and the next. + count := map[reflect.Type]int{} + nextCount := map[reflect.Type]int{} + + // Types already visited at an earlier level. + visited := map[reflect.Type]bool{} + + // Fields found. + var fields []field + + for len(next) > 0 { + current, next = next, current[:0] + count, nextCount = nextCount, map[reflect.Type]int{} + + for _, f := range current { + if visited[f.typ] { + continue + } + visited[f.typ] = true + + // Scan f.typ for fields to include. + for i := 0; i < f.typ.NumField(); i++ { + sf := f.typ.Field(i) + if sf.PkgPath != "" && !sf.Anonymous { // unexported + continue + } + opts := getOptions(sf.Tag) + if opts.skip { + continue + } + index := make([]int, len(f.index)+1) + copy(index, f.index) + index[len(f.index)] = i + + ft := sf.Type + if ft.Name() == "" && ft.Kind() == reflect.Ptr { + // Follow pointer. + ft = ft.Elem() + } + + // Record found field and index sequence. + if opts.name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct { + tagged := opts.name != "" + name := opts.name + if name == "" { + name = sf.Name + } + fields = append(fields, field{name, tagged, index, ft}) + if count[f.typ] > 1 { + // If there were multiple instances, add a second, + // so that the annihilation code will see a duplicate. + // It only cares about the distinction between 1 or 2, + // so don't bother generating any more copies. + fields = append(fields, fields[len(fields)-1]) + } + continue + } + + // Record new anonymous struct to explore in next round. + nextCount[ft]++ + if nextCount[ft] == 1 { + f := field{name: ft.Name(), index: index, typ: ft} + next = append(next, f) + } + } + } + } + + sort.Sort(byName(fields)) + + // Delete all fields that are hidden by the Go rules for embedded fields, + // except that fields with TOML tags are promoted. + + // The fields are sorted in primary order of name, secondary order + // of field index length. Loop over names; for each name, delete + // hidden fields by choosing the one dominant field that survives. + out := fields[:0] + for advance, i := 0, 0; i < len(fields); i += advance { + // One iteration per name. + // Find the sequence of fields with the name of this first field. + fi := fields[i] + name := fi.name + for advance = 1; i+advance < len(fields); advance++ { + fj := fields[i+advance] + if fj.name != name { + break + } + } + if advance == 1 { // Only one field with this name + out = append(out, fi) + continue + } + dominant, ok := dominantField(fields[i : i+advance]) + if ok { + out = append(out, dominant) + } + } + + fields = out + sort.Sort(byIndex(fields)) + + return fields +} + +// dominantField looks through the fields, all of which are known to +// have the same name, to find the single field that dominates the +// others using Go's embedding rules, modified by the presence of +// TOML tags. If there are multiple top-level fields, the boolean +// will be false: This condition is an error in Go and we skip all +// the fields. +func dominantField(fields []field) (field, bool) { + // The fields are sorted in increasing index-length order. The winner + // must therefore be one with the shortest index length. Drop all + // longer entries, which is easy: just truncate the slice. + length := len(fields[0].index) + tagged := -1 // Index of first tagged field. + for i, f := range fields { + if len(f.index) > length { + fields = fields[:i] + break + } + if f.tag { + if tagged >= 0 { + // Multiple tagged fields at the same level: conflict. + // Return no field. + return field{}, false + } + tagged = i + } + } + if tagged >= 0 { + return fields[tagged], true + } + // All remaining fields have the same length. If there's more than one, + // we have a conflict (two fields named "X" at the same level) and we + // return no field. + if len(fields) > 1 { + return field{}, false + } + return fields[0], true +} + +var fieldCache struct { + sync.RWMutex + m map[reflect.Type][]field +} + +// cachedTypeFields is like typeFields but uses a cache to avoid repeated work. +func cachedTypeFields(t reflect.Type) []field { + fieldCache.RLock() + f := fieldCache.m[t] + fieldCache.RUnlock() + if f != nil { + return f + } + + // Compute fields without lock. + // Might duplicate effort but won't hold other computations back. + f = typeFields(t) + if f == nil { + f = []field{} + } + + fieldCache.Lock() + if fieldCache.m == nil { + fieldCache.m = map[reflect.Type][]field{} + } + fieldCache.m[t] = f + fieldCache.Unlock() + return f +} diff --git a/vendor/github.com/liamg/glfont/font.go b/vendor/github.com/liamg/glfont/font.go index d708af4..20617a6 100644 --- a/vendor/github.com/liamg/glfont/font.go +++ b/vendor/github.com/liamg/glfont/font.go @@ -1,7 +1,6 @@ package glfont import ( - "fmt" "os" "github.com/go-gl/gl/all-core/gl" @@ -107,7 +106,6 @@ func (f *Font) Print(x, y float32, scale float32, text string) error { //skip runes that are not in font chacter range if int(runeIndex)-int(lowChar) > len(f.fontChar) || runeIndex < lowChar { - fmt.Printf("%c %d\n", runeIndex, runeIndex) continue } @@ -183,7 +181,6 @@ func (f *Font) Width(scale float32, text string) float32 { //skip runes that are not in font chacter range if int(runeIndex)-int(lowChar) > len(f.fontChar) || runeIndex < lowChar { - fmt.Printf("%c %d\n", runeIndex, runeIndex) continue } diff --git a/vendor/gopkg.in/yaml.v2/.travis.yml b/vendor/gopkg.in/yaml.v2/.travis.yml deleted file mode 100644 index 9f55693..0000000 --- a/vendor/gopkg.in/yaml.v2/.travis.yml +++ /dev/null @@ -1,12 +0,0 @@ -language: go - -go: - - 1.4 - - 1.5 - - 1.6 - - 1.7 - - 1.8 - - 1.9 - - tip - -go_import_path: gopkg.in/yaml.v2 diff --git a/vendor/gopkg.in/yaml.v2/LICENSE b/vendor/gopkg.in/yaml.v2/LICENSE deleted file mode 100644 index 8dada3e..0000000 --- a/vendor/gopkg.in/yaml.v2/LICENSE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright {yyyy} {name of copyright owner} - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/vendor/gopkg.in/yaml.v2/LICENSE.libyaml b/vendor/gopkg.in/yaml.v2/LICENSE.libyaml deleted file mode 100644 index 8da58fb..0000000 --- a/vendor/gopkg.in/yaml.v2/LICENSE.libyaml +++ /dev/null @@ -1,31 +0,0 @@ -The following files were ported to Go from C files of libyaml, and thus -are still covered by their original copyright and license: - - apic.go - emitterc.go - parserc.go - readerc.go - scannerc.go - writerc.go - yamlh.go - yamlprivateh.go - -Copyright (c) 2006 Kirill Simonov - -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal in -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is furnished to do -so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/vendor/gopkg.in/yaml.v2/NOTICE b/vendor/gopkg.in/yaml.v2/NOTICE deleted file mode 100644 index 866d74a..0000000 --- a/vendor/gopkg.in/yaml.v2/NOTICE +++ /dev/null @@ -1,13 +0,0 @@ -Copyright 2011-2016 Canonical Ltd. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/vendor/gopkg.in/yaml.v2/README.md b/vendor/gopkg.in/yaml.v2/README.md deleted file mode 100644 index b50c6e8..0000000 --- a/vendor/gopkg.in/yaml.v2/README.md +++ /dev/null @@ -1,133 +0,0 @@ -# YAML support for the Go language - -Introduction ------------- - -The yaml package enables Go programs to comfortably encode and decode YAML -values. It was developed within [Canonical](https://www.canonical.com) as -part of the [juju](https://juju.ubuntu.com) project, and is based on a -pure Go port of the well-known [libyaml](http://pyyaml.org/wiki/LibYAML) -C library to parse and generate YAML data quickly and reliably. - -Compatibility -------------- - -The yaml package supports most of YAML 1.1 and 1.2, including support for -anchors, tags, map merging, etc. Multi-document unmarshalling is not yet -implemented, and base-60 floats from YAML 1.1 are purposefully not -supported since they're a poor design and are gone in YAML 1.2. - -Installation and usage ----------------------- - -The import path for the package is *gopkg.in/yaml.v2*. - -To install it, run: - - go get gopkg.in/yaml.v2 - -API documentation ------------------ - -If opened in a browser, the import path itself leads to the API documentation: - - * [https://gopkg.in/yaml.v2](https://gopkg.in/yaml.v2) - -API stability -------------- - -The package API for yaml v2 will remain stable as described in [gopkg.in](https://gopkg.in). - - -License -------- - -The yaml package is licensed under the Apache License 2.0. Please see the LICENSE file for details. - - -Example -------- - -```Go -package main - -import ( - "fmt" - "log" - - "gopkg.in/yaml.v2" -) - -var data = ` -a: Easy! -b: - c: 2 - d: [3, 4] -` - -// Note: struct fields must be public in order for unmarshal to -// correctly populate the data. -type T struct { - A string - B struct { - RenamedC int `yaml:"c"` - D []int `yaml:",flow"` - } -} - -func main() { - t := T{} - - err := yaml.Unmarshal([]byte(data), &t) - if err != nil { - log.Fatalf("error: %v", err) - } - fmt.Printf("--- t:\n%v\n\n", t) - - d, err := yaml.Marshal(&t) - if err != nil { - log.Fatalf("error: %v", err) - } - fmt.Printf("--- t dump:\n%s\n\n", string(d)) - - m := make(map[interface{}]interface{}) - - err = yaml.Unmarshal([]byte(data), &m) - if err != nil { - log.Fatalf("error: %v", err) - } - fmt.Printf("--- m:\n%v\n\n", m) - - d, err = yaml.Marshal(&m) - if err != nil { - log.Fatalf("error: %v", err) - } - fmt.Printf("--- m dump:\n%s\n\n", string(d)) -} -``` - -This example will generate the following output: - -``` ---- t: -{Easy! {2 [3 4]}} - ---- t dump: -a: Easy! -b: - c: 2 - d: [3, 4] - - ---- m: -map[a:Easy! b:map[c:2 d:[3 4]]] - ---- m dump: -a: Easy! -b: - c: 2 - d: - - 3 - - 4 -``` - diff --git a/vendor/gopkg.in/yaml.v2/apic.go b/vendor/gopkg.in/yaml.v2/apic.go deleted file mode 100644 index 1f7e87e..0000000 --- a/vendor/gopkg.in/yaml.v2/apic.go +++ /dev/null @@ -1,739 +0,0 @@ -package yaml - -import ( - "io" -) - -func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) { - //fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens)) - - // Check if we can move the queue at the beginning of the buffer. - if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) { - if parser.tokens_head != len(parser.tokens) { - copy(parser.tokens, parser.tokens[parser.tokens_head:]) - } - parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head] - parser.tokens_head = 0 - } - parser.tokens = append(parser.tokens, *token) - if pos < 0 { - return - } - copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:]) - parser.tokens[parser.tokens_head+pos] = *token -} - -// Create a new parser object. -func yaml_parser_initialize(parser *yaml_parser_t) bool { - *parser = yaml_parser_t{ - raw_buffer: make([]byte, 0, input_raw_buffer_size), - buffer: make([]byte, 0, input_buffer_size), - } - return true -} - -// Destroy a parser object. -func yaml_parser_delete(parser *yaml_parser_t) { - *parser = yaml_parser_t{} -} - -// String read handler. -func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) { - if parser.input_pos == len(parser.input) { - return 0, io.EOF - } - n = copy(buffer, parser.input[parser.input_pos:]) - parser.input_pos += n - return n, nil -} - -// Reader read handler. -func yaml_reader_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) { - return parser.input_reader.Read(buffer) -} - -// Set a string input. -func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) { - if parser.read_handler != nil { - panic("must set the input source only once") - } - parser.read_handler = yaml_string_read_handler - parser.input = input - parser.input_pos = 0 -} - -// Set a file input. -func yaml_parser_set_input_reader(parser *yaml_parser_t, r io.Reader) { - if parser.read_handler != nil { - panic("must set the input source only once") - } - parser.read_handler = yaml_reader_read_handler - parser.input_reader = r -} - -// Set the source encoding. -func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) { - if parser.encoding != yaml_ANY_ENCODING { - panic("must set the encoding only once") - } - parser.encoding = encoding -} - -// Create a new emitter object. -func yaml_emitter_initialize(emitter *yaml_emitter_t) { - *emitter = yaml_emitter_t{ - buffer: make([]byte, output_buffer_size), - raw_buffer: make([]byte, 0, output_raw_buffer_size), - states: make([]yaml_emitter_state_t, 0, initial_stack_size), - events: make([]yaml_event_t, 0, initial_queue_size), - } -} - -// Destroy an emitter object. -func yaml_emitter_delete(emitter *yaml_emitter_t) { - *emitter = yaml_emitter_t{} -} - -// String write handler. -func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error { - *emitter.output_buffer = append(*emitter.output_buffer, buffer...) - return nil -} - -// yaml_writer_write_handler uses emitter.output_writer to write the -// emitted text. -func yaml_writer_write_handler(emitter *yaml_emitter_t, buffer []byte) error { - _, err := emitter.output_writer.Write(buffer) - return err -} - -// Set a string output. -func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) { - if emitter.write_handler != nil { - panic("must set the output target only once") - } - emitter.write_handler = yaml_string_write_handler - emitter.output_buffer = output_buffer -} - -// Set a file output. -func yaml_emitter_set_output_writer(emitter *yaml_emitter_t, w io.Writer) { - if emitter.write_handler != nil { - panic("must set the output target only once") - } - emitter.write_handler = yaml_writer_write_handler - emitter.output_writer = w -} - -// Set the output encoding. -func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) { - if emitter.encoding != yaml_ANY_ENCODING { - panic("must set the output encoding only once") - } - emitter.encoding = encoding -} - -// Set the canonical output style. -func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) { - emitter.canonical = canonical -} - -//// Set the indentation increment. -func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) { - if indent < 2 || indent > 9 { - indent = 2 - } - emitter.best_indent = indent -} - -// Set the preferred line width. -func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) { - if width < 0 { - width = -1 - } - emitter.best_width = width -} - -// Set if unescaped non-ASCII characters are allowed. -func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) { - emitter.unicode = unicode -} - -// Set the preferred line break character. -func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) { - emitter.line_break = line_break -} - -///* -// * Destroy a token object. -// */ -// -//YAML_DECLARE(void) -//yaml_token_delete(yaml_token_t *token) -//{ -// assert(token); // Non-NULL token object expected. -// -// switch (token.type) -// { -// case YAML_TAG_DIRECTIVE_TOKEN: -// yaml_free(token.data.tag_directive.handle); -// yaml_free(token.data.tag_directive.prefix); -// break; -// -// case YAML_ALIAS_TOKEN: -// yaml_free(token.data.alias.value); -// break; -// -// case YAML_ANCHOR_TOKEN: -// yaml_free(token.data.anchor.value); -// break; -// -// case YAML_TAG_TOKEN: -// yaml_free(token.data.tag.handle); -// yaml_free(token.data.tag.suffix); -// break; -// -// case YAML_SCALAR_TOKEN: -// yaml_free(token.data.scalar.value); -// break; -// -// default: -// break; -// } -// -// memset(token, 0, sizeof(yaml_token_t)); -//} -// -///* -// * Check if a string is a valid UTF-8 sequence. -// * -// * Check 'reader.c' for more details on UTF-8 encoding. -// */ -// -//static int -//yaml_check_utf8(yaml_char_t *start, size_t length) -//{ -// yaml_char_t *end = start+length; -// yaml_char_t *pointer = start; -// -// while (pointer < end) { -// unsigned char octet; -// unsigned int width; -// unsigned int value; -// size_t k; -// -// octet = pointer[0]; -// width = (octet & 0x80) == 0x00 ? 1 : -// (octet & 0xE0) == 0xC0 ? 2 : -// (octet & 0xF0) == 0xE0 ? 3 : -// (octet & 0xF8) == 0xF0 ? 4 : 0; -// value = (octet & 0x80) == 0x00 ? octet & 0x7F : -// (octet & 0xE0) == 0xC0 ? octet & 0x1F : -// (octet & 0xF0) == 0xE0 ? octet & 0x0F : -// (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0; -// if (!width) return 0; -// if (pointer+width > end) return 0; -// for (k = 1; k < width; k ++) { -// octet = pointer[k]; -// if ((octet & 0xC0) != 0x80) return 0; -// value = (value << 6) + (octet & 0x3F); -// } -// if (!((width == 1) || -// (width == 2 && value >= 0x80) || -// (width == 3 && value >= 0x800) || -// (width == 4 && value >= 0x10000))) return 0; -// -// pointer += width; -// } -// -// return 1; -//} -// - -// Create STREAM-START. -func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) { - *event = yaml_event_t{ - typ: yaml_STREAM_START_EVENT, - encoding: encoding, - } -} - -// Create STREAM-END. -func yaml_stream_end_event_initialize(event *yaml_event_t) { - *event = yaml_event_t{ - typ: yaml_STREAM_END_EVENT, - } -} - -// Create DOCUMENT-START. -func yaml_document_start_event_initialize( - event *yaml_event_t, - version_directive *yaml_version_directive_t, - tag_directives []yaml_tag_directive_t, - implicit bool, -) { - *event = yaml_event_t{ - typ: yaml_DOCUMENT_START_EVENT, - version_directive: version_directive, - tag_directives: tag_directives, - implicit: implicit, - } -} - -// Create DOCUMENT-END. -func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) { - *event = yaml_event_t{ - typ: yaml_DOCUMENT_END_EVENT, - implicit: implicit, - } -} - -///* -// * Create ALIAS. -// */ -// -//YAML_DECLARE(int) -//yaml_alias_event_initialize(event *yaml_event_t, anchor *yaml_char_t) -//{ -// mark yaml_mark_t = { 0, 0, 0 } -// anchor_copy *yaml_char_t = NULL -// -// assert(event) // Non-NULL event object is expected. -// assert(anchor) // Non-NULL anchor is expected. -// -// if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0 -// -// anchor_copy = yaml_strdup(anchor) -// if (!anchor_copy) -// return 0 -// -// ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark) -// -// return 1 -//} - -// Create SCALAR. -func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool { - *event = yaml_event_t{ - typ: yaml_SCALAR_EVENT, - anchor: anchor, - tag: tag, - value: value, - implicit: plain_implicit, - quoted_implicit: quoted_implicit, - style: yaml_style_t(style), - } - return true -} - -// Create SEQUENCE-START. -func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool { - *event = yaml_event_t{ - typ: yaml_SEQUENCE_START_EVENT, - anchor: anchor, - tag: tag, - implicit: implicit, - style: yaml_style_t(style), - } - return true -} - -// Create SEQUENCE-END. -func yaml_sequence_end_event_initialize(event *yaml_event_t) bool { - *event = yaml_event_t{ - typ: yaml_SEQUENCE_END_EVENT, - } - return true -} - -// Create MAPPING-START. -func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) { - *event = yaml_event_t{ - typ: yaml_MAPPING_START_EVENT, - anchor: anchor, - tag: tag, - implicit: implicit, - style: yaml_style_t(style), - } -} - -// Create MAPPING-END. -func yaml_mapping_end_event_initialize(event *yaml_event_t) { - *event = yaml_event_t{ - typ: yaml_MAPPING_END_EVENT, - } -} - -// Destroy an event object. -func yaml_event_delete(event *yaml_event_t) { - *event = yaml_event_t{} -} - -///* -// * Create a document object. -// */ -// -//YAML_DECLARE(int) -//yaml_document_initialize(document *yaml_document_t, -// version_directive *yaml_version_directive_t, -// tag_directives_start *yaml_tag_directive_t, -// tag_directives_end *yaml_tag_directive_t, -// start_implicit int, end_implicit int) -//{ -// struct { -// error yaml_error_type_t -// } context -// struct { -// start *yaml_node_t -// end *yaml_node_t -// top *yaml_node_t -// } nodes = { NULL, NULL, NULL } -// version_directive_copy *yaml_version_directive_t = NULL -// struct { -// start *yaml_tag_directive_t -// end *yaml_tag_directive_t -// top *yaml_tag_directive_t -// } tag_directives_copy = { NULL, NULL, NULL } -// value yaml_tag_directive_t = { NULL, NULL } -// mark yaml_mark_t = { 0, 0, 0 } -// -// assert(document) // Non-NULL document object is expected. -// assert((tag_directives_start && tag_directives_end) || -// (tag_directives_start == tag_directives_end)) -// // Valid tag directives are expected. -// -// if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error -// -// if (version_directive) { -// version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t)) -// if (!version_directive_copy) goto error -// version_directive_copy.major = version_directive.major -// version_directive_copy.minor = version_directive.minor -// } -// -// if (tag_directives_start != tag_directives_end) { -// tag_directive *yaml_tag_directive_t -// if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE)) -// goto error -// for (tag_directive = tag_directives_start -// tag_directive != tag_directives_end; tag_directive ++) { -// assert(tag_directive.handle) -// assert(tag_directive.prefix) -// if (!yaml_check_utf8(tag_directive.handle, -// strlen((char *)tag_directive.handle))) -// goto error -// if (!yaml_check_utf8(tag_directive.prefix, -// strlen((char *)tag_directive.prefix))) -// goto error -// value.handle = yaml_strdup(tag_directive.handle) -// value.prefix = yaml_strdup(tag_directive.prefix) -// if (!value.handle || !value.prefix) goto error -// if (!PUSH(&context, tag_directives_copy, value)) -// goto error -// value.handle = NULL -// value.prefix = NULL -// } -// } -// -// DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy, -// tag_directives_copy.start, tag_directives_copy.top, -// start_implicit, end_implicit, mark, mark) -// -// return 1 -// -//error: -// STACK_DEL(&context, nodes) -// yaml_free(version_directive_copy) -// while (!STACK_EMPTY(&context, tag_directives_copy)) { -// value yaml_tag_directive_t = POP(&context, tag_directives_copy) -// yaml_free(value.handle) -// yaml_free(value.prefix) -// } -// STACK_DEL(&context, tag_directives_copy) -// yaml_free(value.handle) -// yaml_free(value.prefix) -// -// return 0 -//} -// -///* -// * Destroy a document object. -// */ -// -//YAML_DECLARE(void) -//yaml_document_delete(document *yaml_document_t) -//{ -// struct { -// error yaml_error_type_t -// } context -// tag_directive *yaml_tag_directive_t -// -// context.error = YAML_NO_ERROR // Eliminate a compiler warning. -// -// assert(document) // Non-NULL document object is expected. -// -// while (!STACK_EMPTY(&context, document.nodes)) { -// node yaml_node_t = POP(&context, document.nodes) -// yaml_free(node.tag) -// switch (node.type) { -// case YAML_SCALAR_NODE: -// yaml_free(node.data.scalar.value) -// break -// case YAML_SEQUENCE_NODE: -// STACK_DEL(&context, node.data.sequence.items) -// break -// case YAML_MAPPING_NODE: -// STACK_DEL(&context, node.data.mapping.pairs) -// break -// default: -// assert(0) // Should not happen. -// } -// } -// STACK_DEL(&context, document.nodes) -// -// yaml_free(document.version_directive) -// for (tag_directive = document.tag_directives.start -// tag_directive != document.tag_directives.end -// tag_directive++) { -// yaml_free(tag_directive.handle) -// yaml_free(tag_directive.prefix) -// } -// yaml_free(document.tag_directives.start) -// -// memset(document, 0, sizeof(yaml_document_t)) -//} -// -///** -// * Get a document node. -// */ -// -//YAML_DECLARE(yaml_node_t *) -//yaml_document_get_node(document *yaml_document_t, index int) -//{ -// assert(document) // Non-NULL document object is expected. -// -// if (index > 0 && document.nodes.start + index <= document.nodes.top) { -// return document.nodes.start + index - 1 -// } -// return NULL -//} -// -///** -// * Get the root object. -// */ -// -//YAML_DECLARE(yaml_node_t *) -//yaml_document_get_root_node(document *yaml_document_t) -//{ -// assert(document) // Non-NULL document object is expected. -// -// if (document.nodes.top != document.nodes.start) { -// return document.nodes.start -// } -// return NULL -//} -// -///* -// * Add a scalar node to a document. -// */ -// -//YAML_DECLARE(int) -//yaml_document_add_scalar(document *yaml_document_t, -// tag *yaml_char_t, value *yaml_char_t, length int, -// style yaml_scalar_style_t) -//{ -// struct { -// error yaml_error_type_t -// } context -// mark yaml_mark_t = { 0, 0, 0 } -// tag_copy *yaml_char_t = NULL -// value_copy *yaml_char_t = NULL -// node yaml_node_t -// -// assert(document) // Non-NULL document object is expected. -// assert(value) // Non-NULL value is expected. -// -// if (!tag) { -// tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG -// } -// -// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error -// tag_copy = yaml_strdup(tag) -// if (!tag_copy) goto error -// -// if (length < 0) { -// length = strlen((char *)value) -// } -// -// if (!yaml_check_utf8(value, length)) goto error -// value_copy = yaml_malloc(length+1) -// if (!value_copy) goto error -// memcpy(value_copy, value, length) -// value_copy[length] = '\0' -// -// SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark) -// if (!PUSH(&context, document.nodes, node)) goto error -// -// return document.nodes.top - document.nodes.start -// -//error: -// yaml_free(tag_copy) -// yaml_free(value_copy) -// -// return 0 -//} -// -///* -// * Add a sequence node to a document. -// */ -// -//YAML_DECLARE(int) -//yaml_document_add_sequence(document *yaml_document_t, -// tag *yaml_char_t, style yaml_sequence_style_t) -//{ -// struct { -// error yaml_error_type_t -// } context -// mark yaml_mark_t = { 0, 0, 0 } -// tag_copy *yaml_char_t = NULL -// struct { -// start *yaml_node_item_t -// end *yaml_node_item_t -// top *yaml_node_item_t -// } items = { NULL, NULL, NULL } -// node yaml_node_t -// -// assert(document) // Non-NULL document object is expected. -// -// if (!tag) { -// tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG -// } -// -// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error -// tag_copy = yaml_strdup(tag) -// if (!tag_copy) goto error -// -// if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error -// -// SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end, -// style, mark, mark) -// if (!PUSH(&context, document.nodes, node)) goto error -// -// return document.nodes.top - document.nodes.start -// -//error: -// STACK_DEL(&context, items) -// yaml_free(tag_copy) -// -// return 0 -//} -// -///* -// * Add a mapping node to a document. -// */ -// -//YAML_DECLARE(int) -//yaml_document_add_mapping(document *yaml_document_t, -// tag *yaml_char_t, style yaml_mapping_style_t) -//{ -// struct { -// error yaml_error_type_t -// } context -// mark yaml_mark_t = { 0, 0, 0 } -// tag_copy *yaml_char_t = NULL -// struct { -// start *yaml_node_pair_t -// end *yaml_node_pair_t -// top *yaml_node_pair_t -// } pairs = { NULL, NULL, NULL } -// node yaml_node_t -// -// assert(document) // Non-NULL document object is expected. -// -// if (!tag) { -// tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG -// } -// -// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error -// tag_copy = yaml_strdup(tag) -// if (!tag_copy) goto error -// -// if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error -// -// MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end, -// style, mark, mark) -// if (!PUSH(&context, document.nodes, node)) goto error -// -// return document.nodes.top - document.nodes.start -// -//error: -// STACK_DEL(&context, pairs) -// yaml_free(tag_copy) -// -// return 0 -//} -// -///* -// * Append an item to a sequence node. -// */ -// -//YAML_DECLARE(int) -//yaml_document_append_sequence_item(document *yaml_document_t, -// sequence int, item int) -//{ -// struct { -// error yaml_error_type_t -// } context -// -// assert(document) // Non-NULL document is required. -// assert(sequence > 0 -// && document.nodes.start + sequence <= document.nodes.top) -// // Valid sequence id is required. -// assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE) -// // A sequence node is required. -// assert(item > 0 && document.nodes.start + item <= document.nodes.top) -// // Valid item id is required. -// -// if (!PUSH(&context, -// document.nodes.start[sequence-1].data.sequence.items, item)) -// return 0 -// -// return 1 -//} -// -///* -// * Append a pair of a key and a value to a mapping node. -// */ -// -//YAML_DECLARE(int) -//yaml_document_append_mapping_pair(document *yaml_document_t, -// mapping int, key int, value int) -//{ -// struct { -// error yaml_error_type_t -// } context -// -// pair yaml_node_pair_t -// -// assert(document) // Non-NULL document is required. -// assert(mapping > 0 -// && document.nodes.start + mapping <= document.nodes.top) -// // Valid mapping id is required. -// assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE) -// // A mapping node is required. -// assert(key > 0 && document.nodes.start + key <= document.nodes.top) -// // Valid key id is required. -// assert(value > 0 && document.nodes.start + value <= document.nodes.top) -// // Valid value id is required. -// -// pair.key = key -// pair.value = value -// -// if (!PUSH(&context, -// document.nodes.start[mapping-1].data.mapping.pairs, pair)) -// return 0 -// -// return 1 -//} -// -// diff --git a/vendor/gopkg.in/yaml.v2/decode.go b/vendor/gopkg.in/yaml.v2/decode.go deleted file mode 100644 index e4e56e2..0000000 --- a/vendor/gopkg.in/yaml.v2/decode.go +++ /dev/null @@ -1,775 +0,0 @@ -package yaml - -import ( - "encoding" - "encoding/base64" - "fmt" - "io" - "math" - "reflect" - "strconv" - "time" -) - -const ( - documentNode = 1 << iota - mappingNode - sequenceNode - scalarNode - aliasNode -) - -type node struct { - kind int - line, column int - tag string - // For an alias node, alias holds the resolved alias. - alias *node - value string - implicit bool - children []*node - anchors map[string]*node -} - -// ---------------------------------------------------------------------------- -// Parser, produces a node tree out of a libyaml event stream. - -type parser struct { - parser yaml_parser_t - event yaml_event_t - doc *node - doneInit bool -} - -func newParser(b []byte) *parser { - p := parser{} - if !yaml_parser_initialize(&p.parser) { - panic("failed to initialize YAML emitter") - } - if len(b) == 0 { - b = []byte{'\n'} - } - yaml_parser_set_input_string(&p.parser, b) - return &p -} - -func newParserFromReader(r io.Reader) *parser { - p := parser{} - if !yaml_parser_initialize(&p.parser) { - panic("failed to initialize YAML emitter") - } - yaml_parser_set_input_reader(&p.parser, r) - return &p -} - -func (p *parser) init() { - if p.doneInit { - return - } - p.expect(yaml_STREAM_START_EVENT) - p.doneInit = true -} - -func (p *parser) destroy() { - if p.event.typ != yaml_NO_EVENT { - yaml_event_delete(&p.event) - } - yaml_parser_delete(&p.parser) -} - -// expect consumes an event from the event stream and -// checks that it's of the expected type. -func (p *parser) expect(e yaml_event_type_t) { - if p.event.typ == yaml_NO_EVENT { - if !yaml_parser_parse(&p.parser, &p.event) { - p.fail() - } - } - if p.event.typ == yaml_STREAM_END_EVENT { - failf("attempted to go past the end of stream; corrupted value?") - } - if p.event.typ != e { - p.parser.problem = fmt.Sprintf("expected %s event but got %s", e, p.event.typ) - p.fail() - } - yaml_event_delete(&p.event) - p.event.typ = yaml_NO_EVENT -} - -// peek peeks at the next event in the event stream, -// puts the results into p.event and returns the event type. -func (p *parser) peek() yaml_event_type_t { - if p.event.typ != yaml_NO_EVENT { - return p.event.typ - } - if !yaml_parser_parse(&p.parser, &p.event) { - p.fail() - } - return p.event.typ -} - -func (p *parser) fail() { - var where string - var line int - if p.parser.problem_mark.line != 0 { - line = p.parser.problem_mark.line - // Scanner errors don't iterate line before returning error - if p.parser.error == yaml_SCANNER_ERROR { - line++ - } - } else if p.parser.context_mark.line != 0 { - line = p.parser.context_mark.line - } - if line != 0 { - where = "line " + strconv.Itoa(line) + ": " - } - var msg string - if len(p.parser.problem) > 0 { - msg = p.parser.problem - } else { - msg = "unknown problem parsing YAML content" - } - failf("%s%s", where, msg) -} - -func (p *parser) anchor(n *node, anchor []byte) { - if anchor != nil { - p.doc.anchors[string(anchor)] = n - } -} - -func (p *parser) parse() *node { - p.init() - switch p.peek() { - case yaml_SCALAR_EVENT: - return p.scalar() - case yaml_ALIAS_EVENT: - return p.alias() - case yaml_MAPPING_START_EVENT: - return p.mapping() - case yaml_SEQUENCE_START_EVENT: - return p.sequence() - case yaml_DOCUMENT_START_EVENT: - return p.document() - case yaml_STREAM_END_EVENT: - // Happens when attempting to decode an empty buffer. - return nil - default: - panic("attempted to parse unknown event: " + p.event.typ.String()) - } -} - -func (p *parser) node(kind int) *node { - return &node{ - kind: kind, - line: p.event.start_mark.line, - column: p.event.start_mark.column, - } -} - -func (p *parser) document() *node { - n := p.node(documentNode) - n.anchors = make(map[string]*node) - p.doc = n - p.expect(yaml_DOCUMENT_START_EVENT) - n.children = append(n.children, p.parse()) - p.expect(yaml_DOCUMENT_END_EVENT) - return n -} - -func (p *parser) alias() *node { - n := p.node(aliasNode) - n.value = string(p.event.anchor) - n.alias = p.doc.anchors[n.value] - if n.alias == nil { - failf("unknown anchor '%s' referenced", n.value) - } - p.expect(yaml_ALIAS_EVENT) - return n -} - -func (p *parser) scalar() *node { - n := p.node(scalarNode) - n.value = string(p.event.value) - n.tag = string(p.event.tag) - n.implicit = p.event.implicit - p.anchor(n, p.event.anchor) - p.expect(yaml_SCALAR_EVENT) - return n -} - -func (p *parser) sequence() *node { - n := p.node(sequenceNode) - p.anchor(n, p.event.anchor) - p.expect(yaml_SEQUENCE_START_EVENT) - for p.peek() != yaml_SEQUENCE_END_EVENT { - n.children = append(n.children, p.parse()) - } - p.expect(yaml_SEQUENCE_END_EVENT) - return n -} - -func (p *parser) mapping() *node { - n := p.node(mappingNode) - p.anchor(n, p.event.anchor) - p.expect(yaml_MAPPING_START_EVENT) - for p.peek() != yaml_MAPPING_END_EVENT { - n.children = append(n.children, p.parse(), p.parse()) - } - p.expect(yaml_MAPPING_END_EVENT) - return n -} - -// ---------------------------------------------------------------------------- -// Decoder, unmarshals a node into a provided value. - -type decoder struct { - doc *node - aliases map[*node]bool - mapType reflect.Type - terrors []string - strict bool -} - -var ( - mapItemType = reflect.TypeOf(MapItem{}) - durationType = reflect.TypeOf(time.Duration(0)) - defaultMapType = reflect.TypeOf(map[interface{}]interface{}{}) - ifaceType = defaultMapType.Elem() - timeType = reflect.TypeOf(time.Time{}) - ptrTimeType = reflect.TypeOf(&time.Time{}) -) - -func newDecoder(strict bool) *decoder { - d := &decoder{mapType: defaultMapType, strict: strict} - d.aliases = make(map[*node]bool) - return d -} - -func (d *decoder) terror(n *node, tag string, out reflect.Value) { - if n.tag != "" { - tag = n.tag - } - value := n.value - if tag != yaml_SEQ_TAG && tag != yaml_MAP_TAG { - if len(value) > 10 { - value = " `" + value[:7] + "...`" - } else { - value = " `" + value + "`" - } - } - d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.line+1, shortTag(tag), value, out.Type())) -} - -func (d *decoder) callUnmarshaler(n *node, u Unmarshaler) (good bool) { - terrlen := len(d.terrors) - err := u.UnmarshalYAML(func(v interface{}) (err error) { - defer handleErr(&err) - d.unmarshal(n, reflect.ValueOf(v)) - if len(d.terrors) > terrlen { - issues := d.terrors[terrlen:] - d.terrors = d.terrors[:terrlen] - return &TypeError{issues} - } - return nil - }) - if e, ok := err.(*TypeError); ok { - d.terrors = append(d.terrors, e.Errors...) - return false - } - if err != nil { - fail(err) - } - return true -} - -// d.prepare initializes and dereferences pointers and calls UnmarshalYAML -// if a value is found to implement it. -// It returns the initialized and dereferenced out value, whether -// unmarshalling was already done by UnmarshalYAML, and if so whether -// its types unmarshalled appropriately. -// -// If n holds a null value, prepare returns before doing anything. -func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) { - if n.tag == yaml_NULL_TAG || n.kind == scalarNode && n.tag == "" && (n.value == "null" || n.value == "~" || n.value == "" && n.implicit) { - return out, false, false - } - again := true - for again { - again = false - if out.Kind() == reflect.Ptr { - if out.IsNil() { - out.Set(reflect.New(out.Type().Elem())) - } - out = out.Elem() - again = true - } - if out.CanAddr() { - if u, ok := out.Addr().Interface().(Unmarshaler); ok { - good = d.callUnmarshaler(n, u) - return out, true, good - } - } - } - return out, false, false -} - -func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) { - switch n.kind { - case documentNode: - return d.document(n, out) - case aliasNode: - return d.alias(n, out) - } - out, unmarshaled, good := d.prepare(n, out) - if unmarshaled { - return good - } - switch n.kind { - case scalarNode: - good = d.scalar(n, out) - case mappingNode: - good = d.mapping(n, out) - case sequenceNode: - good = d.sequence(n, out) - default: - panic("internal error: unknown node kind: " + strconv.Itoa(n.kind)) - } - return good -} - -func (d *decoder) document(n *node, out reflect.Value) (good bool) { - if len(n.children) == 1 { - d.doc = n - d.unmarshal(n.children[0], out) - return true - } - return false -} - -func (d *decoder) alias(n *node, out reflect.Value) (good bool) { - if d.aliases[n] { - // TODO this could actually be allowed in some circumstances. - failf("anchor '%s' value contains itself", n.value) - } - d.aliases[n] = true - good = d.unmarshal(n.alias, out) - delete(d.aliases, n) - return good -} - -var zeroValue reflect.Value - -func resetMap(out reflect.Value) { - for _, k := range out.MapKeys() { - out.SetMapIndex(k, zeroValue) - } -} - -func (d *decoder) scalar(n *node, out reflect.Value) bool { - var tag string - var resolved interface{} - if n.tag == "" && !n.implicit { - tag = yaml_STR_TAG - resolved = n.value - } else { - tag, resolved = resolve(n.tag, n.value) - if tag == yaml_BINARY_TAG { - data, err := base64.StdEncoding.DecodeString(resolved.(string)) - if err != nil { - failf("!!binary value contains invalid base64 data") - } - resolved = string(data) - } - } - if resolved == nil { - if out.Kind() == reflect.Map && !out.CanAddr() { - resetMap(out) - } else { - out.Set(reflect.Zero(out.Type())) - } - return true - } - if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() { - // We've resolved to exactly the type we want, so use that. - out.Set(resolvedv) - return true - } - // Perhaps we can use the value as a TextUnmarshaler to - // set its value. - if out.CanAddr() { - u, ok := out.Addr().Interface().(encoding.TextUnmarshaler) - if ok { - var text []byte - if tag == yaml_BINARY_TAG { - text = []byte(resolved.(string)) - } else { - // We let any value be unmarshaled into TextUnmarshaler. - // That might be more lax than we'd like, but the - // TextUnmarshaler itself should bowl out any dubious values. - text = []byte(n.value) - } - err := u.UnmarshalText(text) - if err != nil { - fail(err) - } - return true - } - } - switch out.Kind() { - case reflect.String: - if tag == yaml_BINARY_TAG { - out.SetString(resolved.(string)) - return true - } - if resolved != nil { - out.SetString(n.value) - return true - } - case reflect.Interface: - if resolved == nil { - out.Set(reflect.Zero(out.Type())) - } else if tag == yaml_TIMESTAMP_TAG { - // It looks like a timestamp but for backward compatibility - // reasons we set it as a string, so that code that unmarshals - // timestamp-like values into interface{} will continue to - // see a string and not a time.Time. - // TODO(v3) Drop this. - out.Set(reflect.ValueOf(n.value)) - } else { - out.Set(reflect.ValueOf(resolved)) - } - return true - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - switch resolved := resolved.(type) { - case int: - if !out.OverflowInt(int64(resolved)) { - out.SetInt(int64(resolved)) - return true - } - case int64: - if !out.OverflowInt(resolved) { - out.SetInt(resolved) - return true - } - case uint64: - if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) { - out.SetInt(int64(resolved)) - return true - } - case float64: - if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) { - out.SetInt(int64(resolved)) - return true - } - case string: - if out.Type() == durationType { - d, err := time.ParseDuration(resolved) - if err == nil { - out.SetInt(int64(d)) - return true - } - } - } - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: - switch resolved := resolved.(type) { - case int: - if resolved >= 0 && !out.OverflowUint(uint64(resolved)) { - out.SetUint(uint64(resolved)) - return true - } - case int64: - if resolved >= 0 && !out.OverflowUint(uint64(resolved)) { - out.SetUint(uint64(resolved)) - return true - } - case uint64: - if !out.OverflowUint(uint64(resolved)) { - out.SetUint(uint64(resolved)) - return true - } - case float64: - if resolved <= math.MaxUint64 && !out.OverflowUint(uint64(resolved)) { - out.SetUint(uint64(resolved)) - return true - } - } - case reflect.Bool: - switch resolved := resolved.(type) { - case bool: - out.SetBool(resolved) - return true - } - case reflect.Float32, reflect.Float64: - switch resolved := resolved.(type) { - case int: - out.SetFloat(float64(resolved)) - return true - case int64: - out.SetFloat(float64(resolved)) - return true - case uint64: - out.SetFloat(float64(resolved)) - return true - case float64: - out.SetFloat(resolved) - return true - } - case reflect.Struct: - if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() { - out.Set(resolvedv) - return true - } - case reflect.Ptr: - if out.Type().Elem() == reflect.TypeOf(resolved) { - // TODO DOes this make sense? When is out a Ptr except when decoding a nil value? - elem := reflect.New(out.Type().Elem()) - elem.Elem().Set(reflect.ValueOf(resolved)) - out.Set(elem) - return true - } - } - d.terror(n, tag, out) - return false -} - -func settableValueOf(i interface{}) reflect.Value { - v := reflect.ValueOf(i) - sv := reflect.New(v.Type()).Elem() - sv.Set(v) - return sv -} - -func (d *decoder) sequence(n *node, out reflect.Value) (good bool) { - l := len(n.children) - - var iface reflect.Value - switch out.Kind() { - case reflect.Slice: - out.Set(reflect.MakeSlice(out.Type(), l, l)) - case reflect.Array: - if l != out.Len() { - failf("invalid array: want %d elements but got %d", out.Len(), l) - } - case reflect.Interface: - // No type hints. Will have to use a generic sequence. - iface = out - out = settableValueOf(make([]interface{}, l)) - default: - d.terror(n, yaml_SEQ_TAG, out) - return false - } - et := out.Type().Elem() - - j := 0 - for i := 0; i < l; i++ { - e := reflect.New(et).Elem() - if ok := d.unmarshal(n.children[i], e); ok { - out.Index(j).Set(e) - j++ - } - } - if out.Kind() != reflect.Array { - out.Set(out.Slice(0, j)) - } - if iface.IsValid() { - iface.Set(out) - } - return true -} - -func (d *decoder) mapping(n *node, out reflect.Value) (good bool) { - switch out.Kind() { - case reflect.Struct: - return d.mappingStruct(n, out) - case reflect.Slice: - return d.mappingSlice(n, out) - case reflect.Map: - // okay - case reflect.Interface: - if d.mapType.Kind() == reflect.Map { - iface := out - out = reflect.MakeMap(d.mapType) - iface.Set(out) - } else { - slicev := reflect.New(d.mapType).Elem() - if !d.mappingSlice(n, slicev) { - return false - } - out.Set(slicev) - return true - } - default: - d.terror(n, yaml_MAP_TAG, out) - return false - } - outt := out.Type() - kt := outt.Key() - et := outt.Elem() - - mapType := d.mapType - if outt.Key() == ifaceType && outt.Elem() == ifaceType { - d.mapType = outt - } - - if out.IsNil() { - out.Set(reflect.MakeMap(outt)) - } - l := len(n.children) - for i := 0; i < l; i += 2 { - if isMerge(n.children[i]) { - d.merge(n.children[i+1], out) - continue - } - k := reflect.New(kt).Elem() - if d.unmarshal(n.children[i], k) { - kkind := k.Kind() - if kkind == reflect.Interface { - kkind = k.Elem().Kind() - } - if kkind == reflect.Map || kkind == reflect.Slice { - failf("invalid map key: %#v", k.Interface()) - } - e := reflect.New(et).Elem() - if d.unmarshal(n.children[i+1], e) { - d.setMapIndex(n.children[i+1], out, k, e) - } - } - } - d.mapType = mapType - return true -} - -func (d *decoder) setMapIndex(n *node, out, k, v reflect.Value) { - if d.strict && out.MapIndex(k) != zeroValue { - d.terrors = append(d.terrors, fmt.Sprintf("line %d: key %#v already set in map", n.line+1, k.Interface())) - return - } - out.SetMapIndex(k, v) -} - -func (d *decoder) mappingSlice(n *node, out reflect.Value) (good bool) { - outt := out.Type() - if outt.Elem() != mapItemType { - d.terror(n, yaml_MAP_TAG, out) - return false - } - - mapType := d.mapType - d.mapType = outt - - var slice []MapItem - var l = len(n.children) - for i := 0; i < l; i += 2 { - if isMerge(n.children[i]) { - d.merge(n.children[i+1], out) - continue - } - item := MapItem{} - k := reflect.ValueOf(&item.Key).Elem() - if d.unmarshal(n.children[i], k) { - v := reflect.ValueOf(&item.Value).Elem() - if d.unmarshal(n.children[i+1], v) { - slice = append(slice, item) - } - } - } - out.Set(reflect.ValueOf(slice)) - d.mapType = mapType - return true -} - -func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) { - sinfo, err := getStructInfo(out.Type()) - if err != nil { - panic(err) - } - name := settableValueOf("") - l := len(n.children) - - var inlineMap reflect.Value - var elemType reflect.Type - if sinfo.InlineMap != -1 { - inlineMap = out.Field(sinfo.InlineMap) - inlineMap.Set(reflect.New(inlineMap.Type()).Elem()) - elemType = inlineMap.Type().Elem() - } - - var doneFields []bool - if d.strict { - doneFields = make([]bool, len(sinfo.FieldsList)) - } - for i := 0; i < l; i += 2 { - ni := n.children[i] - if isMerge(ni) { - d.merge(n.children[i+1], out) - continue - } - if !d.unmarshal(ni, name) { - continue - } - if info, ok := sinfo.FieldsMap[name.String()]; ok { - if d.strict { - if doneFields[info.Id] { - d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s already set in type %s", ni.line+1, name.String(), out.Type())) - continue - } - doneFields[info.Id] = true - } - var field reflect.Value - if info.Inline == nil { - field = out.Field(info.Num) - } else { - field = out.FieldByIndex(info.Inline) - } - d.unmarshal(n.children[i+1], field) - } else if sinfo.InlineMap != -1 { - if inlineMap.IsNil() { - inlineMap.Set(reflect.MakeMap(inlineMap.Type())) - } - value := reflect.New(elemType).Elem() - d.unmarshal(n.children[i+1], value) - d.setMapIndex(n.children[i+1], inlineMap, name, value) - } else if d.strict { - d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s not found in type %s", ni.line+1, name.String(), out.Type())) - } - } - return true -} - -func failWantMap() { - failf("map merge requires map or sequence of maps as the value") -} - -func (d *decoder) merge(n *node, out reflect.Value) { - switch n.kind { - case mappingNode: - d.unmarshal(n, out) - case aliasNode: - an, ok := d.doc.anchors[n.value] - if ok && an.kind != mappingNode { - failWantMap() - } - d.unmarshal(n, out) - case sequenceNode: - // Step backwards as earlier nodes take precedence. - for i := len(n.children) - 1; i >= 0; i-- { - ni := n.children[i] - if ni.kind == aliasNode { - an, ok := d.doc.anchors[ni.value] - if ok && an.kind != mappingNode { - failWantMap() - } - } else if ni.kind != mappingNode { - failWantMap() - } - d.unmarshal(ni, out) - } - default: - failWantMap() - } -} - -func isMerge(n *node) bool { - return n.kind == scalarNode && n.value == "<<" && (n.implicit == true || n.tag == yaml_MERGE_TAG) -} diff --git a/vendor/gopkg.in/yaml.v2/emitterc.go b/vendor/gopkg.in/yaml.v2/emitterc.go deleted file mode 100644 index a1c2cc5..0000000 --- a/vendor/gopkg.in/yaml.v2/emitterc.go +++ /dev/null @@ -1,1685 +0,0 @@ -package yaml - -import ( - "bytes" - "fmt" -) - -// Flush the buffer if needed. -func flush(emitter *yaml_emitter_t) bool { - if emitter.buffer_pos+5 >= len(emitter.buffer) { - return yaml_emitter_flush(emitter) - } - return true -} - -// Put a character to the output buffer. -func put(emitter *yaml_emitter_t, value byte) bool { - if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) { - return false - } - emitter.buffer[emitter.buffer_pos] = value - emitter.buffer_pos++ - emitter.column++ - return true -} - -// Put a line break to the output buffer. -func put_break(emitter *yaml_emitter_t) bool { - if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) { - return false - } - switch emitter.line_break { - case yaml_CR_BREAK: - emitter.buffer[emitter.buffer_pos] = '\r' - emitter.buffer_pos += 1 - case yaml_LN_BREAK: - emitter.buffer[emitter.buffer_pos] = '\n' - emitter.buffer_pos += 1 - case yaml_CRLN_BREAK: - emitter.buffer[emitter.buffer_pos+0] = '\r' - emitter.buffer[emitter.buffer_pos+1] = '\n' - emitter.buffer_pos += 2 - default: - panic("unknown line break setting") - } - emitter.column = 0 - emitter.line++ - return true -} - -// Copy a character from a string into buffer. -func write(emitter *yaml_emitter_t, s []byte, i *int) bool { - if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) { - return false - } - p := emitter.buffer_pos - w := width(s[*i]) - switch w { - case 4: - emitter.buffer[p+3] = s[*i+3] - fallthrough - case 3: - emitter.buffer[p+2] = s[*i+2] - fallthrough - case 2: - emitter.buffer[p+1] = s[*i+1] - fallthrough - case 1: - emitter.buffer[p+0] = s[*i+0] - default: - panic("unknown character width") - } - emitter.column++ - emitter.buffer_pos += w - *i += w - return true -} - -// Write a whole string into buffer. -func write_all(emitter *yaml_emitter_t, s []byte) bool { - for i := 0; i < len(s); { - if !write(emitter, s, &i) { - return false - } - } - return true -} - -// Copy a line break character from a string into buffer. -func write_break(emitter *yaml_emitter_t, s []byte, i *int) bool { - if s[*i] == '\n' { - if !put_break(emitter) { - return false - } - *i++ - } else { - if !write(emitter, s, i) { - return false - } - emitter.column = 0 - emitter.line++ - } - return true -} - -// Set an emitter error and return false. -func yaml_emitter_set_emitter_error(emitter *yaml_emitter_t, problem string) bool { - emitter.error = yaml_EMITTER_ERROR - emitter.problem = problem - return false -} - -// Emit an event. -func yaml_emitter_emit(emitter *yaml_emitter_t, event *yaml_event_t) bool { - emitter.events = append(emitter.events, *event) - for !yaml_emitter_need_more_events(emitter) { - event := &emitter.events[emitter.events_head] - if !yaml_emitter_analyze_event(emitter, event) { - return false - } - if !yaml_emitter_state_machine(emitter, event) { - return false - } - yaml_event_delete(event) - emitter.events_head++ - } - return true -} - -// Check if we need to accumulate more events before emitting. -// -// We accumulate extra -// - 1 event for DOCUMENT-START -// - 2 events for SEQUENCE-START -// - 3 events for MAPPING-START -// -func yaml_emitter_need_more_events(emitter *yaml_emitter_t) bool { - if emitter.events_head == len(emitter.events) { - return true - } - var accumulate int - switch emitter.events[emitter.events_head].typ { - case yaml_DOCUMENT_START_EVENT: - accumulate = 1 - break - case yaml_SEQUENCE_START_EVENT: - accumulate = 2 - break - case yaml_MAPPING_START_EVENT: - accumulate = 3 - break - default: - return false - } - if len(emitter.events)-emitter.events_head > accumulate { - return false - } - var level int - for i := emitter.events_head; i < len(emitter.events); i++ { - switch emitter.events[i].typ { - case yaml_STREAM_START_EVENT, yaml_DOCUMENT_START_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT: - level++ - case yaml_STREAM_END_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_END_EVENT, yaml_MAPPING_END_EVENT: - level-- - } - if level == 0 { - return false - } - } - return true -} - -// Append a directive to the directives stack. -func yaml_emitter_append_tag_directive(emitter *yaml_emitter_t, value *yaml_tag_directive_t, allow_duplicates bool) bool { - for i := 0; i < len(emitter.tag_directives); i++ { - if bytes.Equal(value.handle, emitter.tag_directives[i].handle) { - if allow_duplicates { - return true - } - return yaml_emitter_set_emitter_error(emitter, "duplicate %TAG directive") - } - } - - // [Go] Do we actually need to copy this given garbage collection - // and the lack of deallocating destructors? - tag_copy := yaml_tag_directive_t{ - handle: make([]byte, len(value.handle)), - prefix: make([]byte, len(value.prefix)), - } - copy(tag_copy.handle, value.handle) - copy(tag_copy.prefix, value.prefix) - emitter.tag_directives = append(emitter.tag_directives, tag_copy) - return true -} - -// Increase the indentation level. -func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool) bool { - emitter.indents = append(emitter.indents, emitter.indent) - if emitter.indent < 0 { - if flow { - emitter.indent = emitter.best_indent - } else { - emitter.indent = 0 - } - } else if !indentless { - emitter.indent += emitter.best_indent - } - return true -} - -// State dispatcher. -func yaml_emitter_state_machine(emitter *yaml_emitter_t, event *yaml_event_t) bool { - switch emitter.state { - default: - case yaml_EMIT_STREAM_START_STATE: - return yaml_emitter_emit_stream_start(emitter, event) - - case yaml_EMIT_FIRST_DOCUMENT_START_STATE: - return yaml_emitter_emit_document_start(emitter, event, true) - - case yaml_EMIT_DOCUMENT_START_STATE: - return yaml_emitter_emit_document_start(emitter, event, false) - - case yaml_EMIT_DOCUMENT_CONTENT_STATE: - return yaml_emitter_emit_document_content(emitter, event) - - case yaml_EMIT_DOCUMENT_END_STATE: - return yaml_emitter_emit_document_end(emitter, event) - - case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE: - return yaml_emitter_emit_flow_sequence_item(emitter, event, true) - - case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE: - return yaml_emitter_emit_flow_sequence_item(emitter, event, false) - - case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE: - return yaml_emitter_emit_flow_mapping_key(emitter, event, true) - - case yaml_EMIT_FLOW_MAPPING_KEY_STATE: - return yaml_emitter_emit_flow_mapping_key(emitter, event, false) - - case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE: - return yaml_emitter_emit_flow_mapping_value(emitter, event, true) - - case yaml_EMIT_FLOW_MAPPING_VALUE_STATE: - return yaml_emitter_emit_flow_mapping_value(emitter, event, false) - - case yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE: - return yaml_emitter_emit_block_sequence_item(emitter, event, true) - - case yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE: - return yaml_emitter_emit_block_sequence_item(emitter, event, false) - - case yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE: - return yaml_emitter_emit_block_mapping_key(emitter, event, true) - - case yaml_EMIT_BLOCK_MAPPING_KEY_STATE: - return yaml_emitter_emit_block_mapping_key(emitter, event, false) - - case yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE: - return yaml_emitter_emit_block_mapping_value(emitter, event, true) - - case yaml_EMIT_BLOCK_MAPPING_VALUE_STATE: - return yaml_emitter_emit_block_mapping_value(emitter, event, false) - - case yaml_EMIT_END_STATE: - return yaml_emitter_set_emitter_error(emitter, "expected nothing after STREAM-END") - } - panic("invalid emitter state") -} - -// Expect STREAM-START. -func yaml_emitter_emit_stream_start(emitter *yaml_emitter_t, event *yaml_event_t) bool { - if event.typ != yaml_STREAM_START_EVENT { - return yaml_emitter_set_emitter_error(emitter, "expected STREAM-START") - } - if emitter.encoding == yaml_ANY_ENCODING { - emitter.encoding = event.encoding - if emitter.encoding == yaml_ANY_ENCODING { - emitter.encoding = yaml_UTF8_ENCODING - } - } - if emitter.best_indent < 2 || emitter.best_indent > 9 { - emitter.best_indent = 2 - } - if emitter.best_width >= 0 && emitter.best_width <= emitter.best_indent*2 { - emitter.best_width = 80 - } - if emitter.best_width < 0 { - emitter.best_width = 1<<31 - 1 - } - if emitter.line_break == yaml_ANY_BREAK { - emitter.line_break = yaml_LN_BREAK - } - - emitter.indent = -1 - emitter.line = 0 - emitter.column = 0 - emitter.whitespace = true - emitter.indention = true - - if emitter.encoding != yaml_UTF8_ENCODING { - if !yaml_emitter_write_bom(emitter) { - return false - } - } - emitter.state = yaml_EMIT_FIRST_DOCUMENT_START_STATE - return true -} - -// Expect DOCUMENT-START or STREAM-END. -func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool { - - if event.typ == yaml_DOCUMENT_START_EVENT { - - if event.version_directive != nil { - if !yaml_emitter_analyze_version_directive(emitter, event.version_directive) { - return false - } - } - - for i := 0; i < len(event.tag_directives); i++ { - tag_directive := &event.tag_directives[i] - if !yaml_emitter_analyze_tag_directive(emitter, tag_directive) { - return false - } - if !yaml_emitter_append_tag_directive(emitter, tag_directive, false) { - return false - } - } - - for i := 0; i < len(default_tag_directives); i++ { - tag_directive := &default_tag_directives[i] - if !yaml_emitter_append_tag_directive(emitter, tag_directive, true) { - return false - } - } - - implicit := event.implicit - if !first || emitter.canonical { - implicit = false - } - - if emitter.open_ended && (event.version_directive != nil || len(event.tag_directives) > 0) { - if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) { - return false - } - if !yaml_emitter_write_indent(emitter) { - return false - } - } - - if event.version_directive != nil { - implicit = false - if !yaml_emitter_write_indicator(emitter, []byte("%YAML"), true, false, false) { - return false - } - if !yaml_emitter_write_indicator(emitter, []byte("1.1"), true, false, false) { - return false - } - if !yaml_emitter_write_indent(emitter) { - return false - } - } - - if len(event.tag_directives) > 0 { - implicit = false - for i := 0; i < len(event.tag_directives); i++ { - tag_directive := &event.tag_directives[i] - if !yaml_emitter_write_indicator(emitter, []byte("%TAG"), true, false, false) { - return false - } - if !yaml_emitter_write_tag_handle(emitter, tag_directive.handle) { - return false - } - if !yaml_emitter_write_tag_content(emitter, tag_directive.prefix, true) { - return false - } - if !yaml_emitter_write_indent(emitter) { - return false - } - } - } - - if yaml_emitter_check_empty_document(emitter) { - implicit = false - } - if !implicit { - if !yaml_emitter_write_indent(emitter) { - return false - } - if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) { - return false - } - if emitter.canonical { - if !yaml_emitter_write_indent(emitter) { - return false - } - } - } - - emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE - return true - } - - if event.typ == yaml_STREAM_END_EVENT { - if emitter.open_ended { - if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) { - return false - } - if !yaml_emitter_write_indent(emitter) { - return false - } - } - if !yaml_emitter_flush(emitter) { - return false - } - emitter.state = yaml_EMIT_END_STATE - return true - } - - return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-START or STREAM-END") -} - -// Expect the root node. -func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool { - emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE) - return yaml_emitter_emit_node(emitter, event, true, false, false, false) -} - -// Expect DOCUMENT-END. -func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t) bool { - if event.typ != yaml_DOCUMENT_END_EVENT { - return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END") - } - if !yaml_emitter_write_indent(emitter) { - return false - } - if !event.implicit { - // [Go] Allocate the slice elsewhere. - if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) { - return false - } - if !yaml_emitter_write_indent(emitter) { - return false - } - } - if !yaml_emitter_flush(emitter) { - return false - } - emitter.state = yaml_EMIT_DOCUMENT_START_STATE - emitter.tag_directives = emitter.tag_directives[:0] - return true -} - -// Expect a flow item node. -func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool { - if first { - if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) { - return false - } - if !yaml_emitter_increase_indent(emitter, true, false) { - return false - } - emitter.flow_level++ - } - - if event.typ == yaml_SEQUENCE_END_EVENT { - emitter.flow_level-- - emitter.indent = emitter.indents[len(emitter.indents)-1] - emitter.indents = emitter.indents[:len(emitter.indents)-1] - if emitter.canonical && !first { - if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) { - return false - } - if !yaml_emitter_write_indent(emitter) { - return false - } - } - if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) { - return false - } - emitter.state = emitter.states[len(emitter.states)-1] - emitter.states = emitter.states[:len(emitter.states)-1] - - return true - } - - if !first { - if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) { - return false - } - } - - if emitter.canonical || emitter.column > emitter.best_width { - if !yaml_emitter_write_indent(emitter) { - return false - } - } - emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE) - return yaml_emitter_emit_node(emitter, event, false, true, false, false) -} - -// Expect a flow key node. -func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool { - if first { - if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) { - return false - } - if !yaml_emitter_increase_indent(emitter, true, false) { - return false - } - emitter.flow_level++ - } - - if event.typ == yaml_MAPPING_END_EVENT { - emitter.flow_level-- - emitter.indent = emitter.indents[len(emitter.indents)-1] - emitter.indents = emitter.indents[:len(emitter.indents)-1] - if emitter.canonical && !first { - if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) { - return false - } - if !yaml_emitter_write_indent(emitter) { - return false - } - } - if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) { - return false - } - emitter.state = emitter.states[len(emitter.states)-1] - emitter.states = emitter.states[:len(emitter.states)-1] - return true - } - - if !first { - if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) { - return false - } - } - if emitter.canonical || emitter.column > emitter.best_width { - if !yaml_emitter_write_indent(emitter) { - return false - } - } - - if !emitter.canonical && yaml_emitter_check_simple_key(emitter) { - emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE) - return yaml_emitter_emit_node(emitter, event, false, false, true, true) - } - if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, false) { - return false - } - emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_VALUE_STATE) - return yaml_emitter_emit_node(emitter, event, false, false, true, false) -} - -// Expect a flow value node. -func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool { - if simple { - if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) { - return false - } - } else { - if emitter.canonical || emitter.column > emitter.best_width { - if !yaml_emitter_write_indent(emitter) { - return false - } - } - if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, false) { - return false - } - } - emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE) - return yaml_emitter_emit_node(emitter, event, false, false, true, false) -} - -// Expect a block item node. -func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool { - if first { - if !yaml_emitter_increase_indent(emitter, false, emitter.mapping_context && !emitter.indention) { - return false - } - } - if event.typ == yaml_SEQUENCE_END_EVENT { - emitter.indent = emitter.indents[len(emitter.indents)-1] - emitter.indents = emitter.indents[:len(emitter.indents)-1] - emitter.state = emitter.states[len(emitter.states)-1] - emitter.states = emitter.states[:len(emitter.states)-1] - return true - } - if !yaml_emitter_write_indent(emitter) { - return false - } - if !yaml_emitter_write_indicator(emitter, []byte{'-'}, true, false, true) { - return false - } - emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE) - return yaml_emitter_emit_node(emitter, event, false, true, false, false) -} - -// Expect a block key node. -func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool { - if first { - if !yaml_emitter_increase_indent(emitter, false, false) { - return false - } - } - if event.typ == yaml_MAPPING_END_EVENT { - emitter.indent = emitter.indents[len(emitter.indents)-1] - emitter.indents = emitter.indents[:len(emitter.indents)-1] - emitter.state = emitter.states[len(emitter.states)-1] - emitter.states = emitter.states[:len(emitter.states)-1] - return true - } - if !yaml_emitter_write_indent(emitter) { - return false - } - if yaml_emitter_check_simple_key(emitter) { - emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE) - return yaml_emitter_emit_node(emitter, event, false, false, true, true) - } - if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, true) { - return false - } - emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_VALUE_STATE) - return yaml_emitter_emit_node(emitter, event, false, false, true, false) -} - -// Expect a block value node. -func yaml_emitter_emit_block_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool { - if simple { - if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) { - return false - } - } else { - if !yaml_emitter_write_indent(emitter) { - return false - } - if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, true) { - return false - } - } - emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE) - return yaml_emitter_emit_node(emitter, event, false, false, true, false) -} - -// Expect a node. -func yaml_emitter_emit_node(emitter *yaml_emitter_t, event *yaml_event_t, - root bool, sequence bool, mapping bool, simple_key bool) bool { - - emitter.root_context = root - emitter.sequence_context = sequence - emitter.mapping_context = mapping - emitter.simple_key_context = simple_key - - switch event.typ { - case yaml_ALIAS_EVENT: - return yaml_emitter_emit_alias(emitter, event) - case yaml_SCALAR_EVENT: - return yaml_emitter_emit_scalar(emitter, event) - case yaml_SEQUENCE_START_EVENT: - return yaml_emitter_emit_sequence_start(emitter, event) - case yaml_MAPPING_START_EVENT: - return yaml_emitter_emit_mapping_start(emitter, event) - default: - return yaml_emitter_set_emitter_error(emitter, - fmt.Sprintf("expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, but got %v", event.typ)) - } -} - -// Expect ALIAS. -func yaml_emitter_emit_alias(emitter *yaml_emitter_t, event *yaml_event_t) bool { - if !yaml_emitter_process_anchor(emitter) { - return false - } - emitter.state = emitter.states[len(emitter.states)-1] - emitter.states = emitter.states[:len(emitter.states)-1] - return true -} - -// Expect SCALAR. -func yaml_emitter_emit_scalar(emitter *yaml_emitter_t, event *yaml_event_t) bool { - if !yaml_emitter_select_scalar_style(emitter, event) { - return false - } - if !yaml_emitter_process_anchor(emitter) { - return false - } - if !yaml_emitter_process_tag(emitter) { - return false - } - if !yaml_emitter_increase_indent(emitter, true, false) { - return false - } - if !yaml_emitter_process_scalar(emitter) { - return false - } - emitter.indent = emitter.indents[len(emitter.indents)-1] - emitter.indents = emitter.indents[:len(emitter.indents)-1] - emitter.state = emitter.states[len(emitter.states)-1] - emitter.states = emitter.states[:len(emitter.states)-1] - return true -} - -// Expect SEQUENCE-START. -func yaml_emitter_emit_sequence_start(emitter *yaml_emitter_t, event *yaml_event_t) bool { - if !yaml_emitter_process_anchor(emitter) { - return false - } - if !yaml_emitter_process_tag(emitter) { - return false - } - if emitter.flow_level > 0 || emitter.canonical || event.sequence_style() == yaml_FLOW_SEQUENCE_STYLE || - yaml_emitter_check_empty_sequence(emitter) { - emitter.state = yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE - } else { - emitter.state = yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE - } - return true -} - -// Expect MAPPING-START. -func yaml_emitter_emit_mapping_start(emitter *yaml_emitter_t, event *yaml_event_t) bool { - if !yaml_emitter_process_anchor(emitter) { - return false - } - if !yaml_emitter_process_tag(emitter) { - return false - } - if emitter.flow_level > 0 || emitter.canonical || event.mapping_style() == yaml_FLOW_MAPPING_STYLE || - yaml_emitter_check_empty_mapping(emitter) { - emitter.state = yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE - } else { - emitter.state = yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE - } - return true -} - -// Check if the document content is an empty scalar. -func yaml_emitter_check_empty_document(emitter *yaml_emitter_t) bool { - return false // [Go] Huh? -} - -// Check if the next events represent an empty sequence. -func yaml_emitter_check_empty_sequence(emitter *yaml_emitter_t) bool { - if len(emitter.events)-emitter.events_head < 2 { - return false - } - return emitter.events[emitter.events_head].typ == yaml_SEQUENCE_START_EVENT && - emitter.events[emitter.events_head+1].typ == yaml_SEQUENCE_END_EVENT -} - -// Check if the next events represent an empty mapping. -func yaml_emitter_check_empty_mapping(emitter *yaml_emitter_t) bool { - if len(emitter.events)-emitter.events_head < 2 { - return false - } - return emitter.events[emitter.events_head].typ == yaml_MAPPING_START_EVENT && - emitter.events[emitter.events_head+1].typ == yaml_MAPPING_END_EVENT -} - -// Check if the next node can be expressed as a simple key. -func yaml_emitter_check_simple_key(emitter *yaml_emitter_t) bool { - length := 0 - switch emitter.events[emitter.events_head].typ { - case yaml_ALIAS_EVENT: - length += len(emitter.anchor_data.anchor) - case yaml_SCALAR_EVENT: - if emitter.scalar_data.multiline { - return false - } - length += len(emitter.anchor_data.anchor) + - len(emitter.tag_data.handle) + - len(emitter.tag_data.suffix) + - len(emitter.scalar_data.value) - case yaml_SEQUENCE_START_EVENT: - if !yaml_emitter_check_empty_sequence(emitter) { - return false - } - length += len(emitter.anchor_data.anchor) + - len(emitter.tag_data.handle) + - len(emitter.tag_data.suffix) - case yaml_MAPPING_START_EVENT: - if !yaml_emitter_check_empty_mapping(emitter) { - return false - } - length += len(emitter.anchor_data.anchor) + - len(emitter.tag_data.handle) + - len(emitter.tag_data.suffix) - default: - return false - } - return length <= 128 -} - -// Determine an acceptable scalar style. -func yaml_emitter_select_scalar_style(emitter *yaml_emitter_t, event *yaml_event_t) bool { - - no_tag := len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 - if no_tag && !event.implicit && !event.quoted_implicit { - return yaml_emitter_set_emitter_error(emitter, "neither tag nor implicit flags are specified") - } - - style := event.scalar_style() - if style == yaml_ANY_SCALAR_STYLE { - style = yaml_PLAIN_SCALAR_STYLE - } - if emitter.canonical { - style = yaml_DOUBLE_QUOTED_SCALAR_STYLE - } - if emitter.simple_key_context && emitter.scalar_data.multiline { - style = yaml_DOUBLE_QUOTED_SCALAR_STYLE - } - - if style == yaml_PLAIN_SCALAR_STYLE { - if emitter.flow_level > 0 && !emitter.scalar_data.flow_plain_allowed || - emitter.flow_level == 0 && !emitter.scalar_data.block_plain_allowed { - style = yaml_SINGLE_QUOTED_SCALAR_STYLE - } - if len(emitter.scalar_data.value) == 0 && (emitter.flow_level > 0 || emitter.simple_key_context) { - style = yaml_SINGLE_QUOTED_SCALAR_STYLE - } - if no_tag && !event.implicit { - style = yaml_SINGLE_QUOTED_SCALAR_STYLE - } - } - if style == yaml_SINGLE_QUOTED_SCALAR_STYLE { - if !emitter.scalar_data.single_quoted_allowed { - style = yaml_DOUBLE_QUOTED_SCALAR_STYLE - } - } - if style == yaml_LITERAL_SCALAR_STYLE || style == yaml_FOLDED_SCALAR_STYLE { - if !emitter.scalar_data.block_allowed || emitter.flow_level > 0 || emitter.simple_key_context { - style = yaml_DOUBLE_QUOTED_SCALAR_STYLE - } - } - - if no_tag && !event.quoted_implicit && style != yaml_PLAIN_SCALAR_STYLE { - emitter.tag_data.handle = []byte{'!'} - } - emitter.scalar_data.style = style - return true -} - -// Write an anchor. -func yaml_emitter_process_anchor(emitter *yaml_emitter_t) bool { - if emitter.anchor_data.anchor == nil { - return true - } - c := []byte{'&'} - if emitter.anchor_data.alias { - c[0] = '*' - } - if !yaml_emitter_write_indicator(emitter, c, true, false, false) { - return false - } - return yaml_emitter_write_anchor(emitter, emitter.anchor_data.anchor) -} - -// Write a tag. -func yaml_emitter_process_tag(emitter *yaml_emitter_t) bool { - if len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 { - return true - } - if len(emitter.tag_data.handle) > 0 { - if !yaml_emitter_write_tag_handle(emitter, emitter.tag_data.handle) { - return false - } - if len(emitter.tag_data.suffix) > 0 { - if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) { - return false - } - } - } else { - // [Go] Allocate these slices elsewhere. - if !yaml_emitter_write_indicator(emitter, []byte("!<"), true, false, false) { - return false - } - if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) { - return false - } - if !yaml_emitter_write_indicator(emitter, []byte{'>'}, false, false, false) { - return false - } - } - return true -} - -// Write a scalar. -func yaml_emitter_process_scalar(emitter *yaml_emitter_t) bool { - switch emitter.scalar_data.style { - case yaml_PLAIN_SCALAR_STYLE: - return yaml_emitter_write_plain_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context) - - case yaml_SINGLE_QUOTED_SCALAR_STYLE: - return yaml_emitter_write_single_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context) - - case yaml_DOUBLE_QUOTED_SCALAR_STYLE: - return yaml_emitter_write_double_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context) - - case yaml_LITERAL_SCALAR_STYLE: - return yaml_emitter_write_literal_scalar(emitter, emitter.scalar_data.value) - - case yaml_FOLDED_SCALAR_STYLE: - return yaml_emitter_write_folded_scalar(emitter, emitter.scalar_data.value) - } - panic("unknown scalar style") -} - -// Check if a %YAML directive is valid. -func yaml_emitter_analyze_version_directive(emitter *yaml_emitter_t, version_directive *yaml_version_directive_t) bool { - if version_directive.major != 1 || version_directive.minor != 1 { - return yaml_emitter_set_emitter_error(emitter, "incompatible %YAML directive") - } - return true -} - -// Check if a %TAG directive is valid. -func yaml_emitter_analyze_tag_directive(emitter *yaml_emitter_t, tag_directive *yaml_tag_directive_t) bool { - handle := tag_directive.handle - prefix := tag_directive.prefix - if len(handle) == 0 { - return yaml_emitter_set_emitter_error(emitter, "tag handle must not be empty") - } - if handle[0] != '!' { - return yaml_emitter_set_emitter_error(emitter, "tag handle must start with '!'") - } - if handle[len(handle)-1] != '!' { - return yaml_emitter_set_emitter_error(emitter, "tag handle must end with '!'") - } - for i := 1; i < len(handle)-1; i += width(handle[i]) { - if !is_alpha(handle, i) { - return yaml_emitter_set_emitter_error(emitter, "tag handle must contain alphanumerical characters only") - } - } - if len(prefix) == 0 { - return yaml_emitter_set_emitter_error(emitter, "tag prefix must not be empty") - } - return true -} - -// Check if an anchor is valid. -func yaml_emitter_analyze_anchor(emitter *yaml_emitter_t, anchor []byte, alias bool) bool { - if len(anchor) == 0 { - problem := "anchor value must not be empty" - if alias { - problem = "alias value must not be empty" - } - return yaml_emitter_set_emitter_error(emitter, problem) - } - for i := 0; i < len(anchor); i += width(anchor[i]) { - if !is_alpha(anchor, i) { - problem := "anchor value must contain alphanumerical characters only" - if alias { - problem = "alias value must contain alphanumerical characters only" - } - return yaml_emitter_set_emitter_error(emitter, problem) - } - } - emitter.anchor_data.anchor = anchor - emitter.anchor_data.alias = alias - return true -} - -// Check if a tag is valid. -func yaml_emitter_analyze_tag(emitter *yaml_emitter_t, tag []byte) bool { - if len(tag) == 0 { - return yaml_emitter_set_emitter_error(emitter, "tag value must not be empty") - } - for i := 0; i < len(emitter.tag_directives); i++ { - tag_directive := &emitter.tag_directives[i] - if bytes.HasPrefix(tag, tag_directive.prefix) { - emitter.tag_data.handle = tag_directive.handle - emitter.tag_data.suffix = tag[len(tag_directive.prefix):] - return true - } - } - emitter.tag_data.suffix = tag - return true -} - -// Check if a scalar is valid. -func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool { - var ( - block_indicators = false - flow_indicators = false - line_breaks = false - special_characters = false - - leading_space = false - leading_break = false - trailing_space = false - trailing_break = false - break_space = false - space_break = false - - preceded_by_whitespace = false - followed_by_whitespace = false - previous_space = false - previous_break = false - ) - - emitter.scalar_data.value = value - - if len(value) == 0 { - emitter.scalar_data.multiline = false - emitter.scalar_data.flow_plain_allowed = false - emitter.scalar_data.block_plain_allowed = true - emitter.scalar_data.single_quoted_allowed = true - emitter.scalar_data.block_allowed = false - return true - } - - if len(value) >= 3 && ((value[0] == '-' && value[1] == '-' && value[2] == '-') || (value[0] == '.' && value[1] == '.' && value[2] == '.')) { - block_indicators = true - flow_indicators = true - } - - preceded_by_whitespace = true - for i, w := 0, 0; i < len(value); i += w { - w = width(value[i]) - followed_by_whitespace = i+w >= len(value) || is_blank(value, i+w) - - if i == 0 { - switch value[i] { - case '#', ',', '[', ']', '{', '}', '&', '*', '!', '|', '>', '\'', '"', '%', '@', '`': - flow_indicators = true - block_indicators = true - case '?', ':': - flow_indicators = true - if followed_by_whitespace { - block_indicators = true - } - case '-': - if followed_by_whitespace { - flow_indicators = true - block_indicators = true - } - } - } else { - switch value[i] { - case ',', '?', '[', ']', '{', '}': - flow_indicators = true - case ':': - flow_indicators = true - if followed_by_whitespace { - block_indicators = true - } - case '#': - if preceded_by_whitespace { - flow_indicators = true - block_indicators = true - } - } - } - - if !is_printable(value, i) || !is_ascii(value, i) && !emitter.unicode { - special_characters = true - } - if is_space(value, i) { - if i == 0 { - leading_space = true - } - if i+width(value[i]) == len(value) { - trailing_space = true - } - if previous_break { - break_space = true - } - previous_space = true - previous_break = false - } else if is_break(value, i) { - line_breaks = true - if i == 0 { - leading_break = true - } - if i+width(value[i]) == len(value) { - trailing_break = true - } - if previous_space { - space_break = true - } - previous_space = false - previous_break = true - } else { - previous_space = false - previous_break = false - } - - // [Go]: Why 'z'? Couldn't be the end of the string as that's the loop condition. - preceded_by_whitespace = is_blankz(value, i) - } - - emitter.scalar_data.multiline = line_breaks - emitter.scalar_data.flow_plain_allowed = true - emitter.scalar_data.block_plain_allowed = true - emitter.scalar_data.single_quoted_allowed = true - emitter.scalar_data.block_allowed = true - - if leading_space || leading_break || trailing_space || trailing_break { - emitter.scalar_data.flow_plain_allowed = false - emitter.scalar_data.block_plain_allowed = false - } - if trailing_space { - emitter.scalar_data.block_allowed = false - } - if break_space { - emitter.scalar_data.flow_plain_allowed = false - emitter.scalar_data.block_plain_allowed = false - emitter.scalar_data.single_quoted_allowed = false - } - if space_break || special_characters { - emitter.scalar_data.flow_plain_allowed = false - emitter.scalar_data.block_plain_allowed = false - emitter.scalar_data.single_quoted_allowed = false - emitter.scalar_data.block_allowed = false - } - if line_breaks { - emitter.scalar_data.flow_plain_allowed = false - emitter.scalar_data.block_plain_allowed = false - } - if flow_indicators { - emitter.scalar_data.flow_plain_allowed = false - } - if block_indicators { - emitter.scalar_data.block_plain_allowed = false - } - return true -} - -// Check if the event data is valid. -func yaml_emitter_analyze_event(emitter *yaml_emitter_t, event *yaml_event_t) bool { - - emitter.anchor_data.anchor = nil - emitter.tag_data.handle = nil - emitter.tag_data.suffix = nil - emitter.scalar_data.value = nil - - switch event.typ { - case yaml_ALIAS_EVENT: - if !yaml_emitter_analyze_anchor(emitter, event.anchor, true) { - return false - } - - case yaml_SCALAR_EVENT: - if len(event.anchor) > 0 { - if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) { - return false - } - } - if len(event.tag) > 0 && (emitter.canonical || (!event.implicit && !event.quoted_implicit)) { - if !yaml_emitter_analyze_tag(emitter, event.tag) { - return false - } - } - if !yaml_emitter_analyze_scalar(emitter, event.value) { - return false - } - - case yaml_SEQUENCE_START_EVENT: - if len(event.anchor) > 0 { - if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) { - return false - } - } - if len(event.tag) > 0 && (emitter.canonical || !event.implicit) { - if !yaml_emitter_analyze_tag(emitter, event.tag) { - return false - } - } - - case yaml_MAPPING_START_EVENT: - if len(event.anchor) > 0 { - if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) { - return false - } - } - if len(event.tag) > 0 && (emitter.canonical || !event.implicit) { - if !yaml_emitter_analyze_tag(emitter, event.tag) { - return false - } - } - } - return true -} - -// Write the BOM character. -func yaml_emitter_write_bom(emitter *yaml_emitter_t) bool { - if !flush(emitter) { - return false - } - pos := emitter.buffer_pos - emitter.buffer[pos+0] = '\xEF' - emitter.buffer[pos+1] = '\xBB' - emitter.buffer[pos+2] = '\xBF' - emitter.buffer_pos += 3 - return true -} - -func yaml_emitter_write_indent(emitter *yaml_emitter_t) bool { - indent := emitter.indent - if indent < 0 { - indent = 0 - } - if !emitter.indention || emitter.column > indent || (emitter.column == indent && !emitter.whitespace) { - if !put_break(emitter) { - return false - } - } - for emitter.column < indent { - if !put(emitter, ' ') { - return false - } - } - emitter.whitespace = true - emitter.indention = true - return true -} - -func yaml_emitter_write_indicator(emitter *yaml_emitter_t, indicator []byte, need_whitespace, is_whitespace, is_indention bool) bool { - if need_whitespace && !emitter.whitespace { - if !put(emitter, ' ') { - return false - } - } - if !write_all(emitter, indicator) { - return false - } - emitter.whitespace = is_whitespace - emitter.indention = (emitter.indention && is_indention) - emitter.open_ended = false - return true -} - -func yaml_emitter_write_anchor(emitter *yaml_emitter_t, value []byte) bool { - if !write_all(emitter, value) { - return false - } - emitter.whitespace = false - emitter.indention = false - return true -} - -func yaml_emitter_write_tag_handle(emitter *yaml_emitter_t, value []byte) bool { - if !emitter.whitespace { - if !put(emitter, ' ') { - return false - } - } - if !write_all(emitter, value) { - return false - } - emitter.whitespace = false - emitter.indention = false - return true -} - -func yaml_emitter_write_tag_content(emitter *yaml_emitter_t, value []byte, need_whitespace bool) bool { - if need_whitespace && !emitter.whitespace { - if !put(emitter, ' ') { - return false - } - } - for i := 0; i < len(value); { - var must_write bool - switch value[i] { - case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '_', '.', '~', '*', '\'', '(', ')', '[', ']': - must_write = true - default: - must_write = is_alpha(value, i) - } - if must_write { - if !write(emitter, value, &i) { - return false - } - } else { - w := width(value[i]) - for k := 0; k < w; k++ { - octet := value[i] - i++ - if !put(emitter, '%') { - return false - } - - c := octet >> 4 - if c < 10 { - c += '0' - } else { - c += 'A' - 10 - } - if !put(emitter, c) { - return false - } - - c = octet & 0x0f - if c < 10 { - c += '0' - } else { - c += 'A' - 10 - } - if !put(emitter, c) { - return false - } - } - } - } - emitter.whitespace = false - emitter.indention = false - return true -} - -func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool { - if !emitter.whitespace { - if !put(emitter, ' ') { - return false - } - } - - spaces := false - breaks := false - for i := 0; i < len(value); { - if is_space(value, i) { - if allow_breaks && !spaces && emitter.column > emitter.best_width && !is_space(value, i+1) { - if !yaml_emitter_write_indent(emitter) { - return false - } - i += width(value[i]) - } else { - if !write(emitter, value, &i) { - return false - } - } - spaces = true - } else if is_break(value, i) { - if !breaks && value[i] == '\n' { - if !put_break(emitter) { - return false - } - } - if !write_break(emitter, value, &i) { - return false - } - emitter.indention = true - breaks = true - } else { - if breaks { - if !yaml_emitter_write_indent(emitter) { - return false - } - } - if !write(emitter, value, &i) { - return false - } - emitter.indention = false - spaces = false - breaks = false - } - } - - emitter.whitespace = false - emitter.indention = false - if emitter.root_context { - emitter.open_ended = true - } - - return true -} - -func yaml_emitter_write_single_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool { - - if !yaml_emitter_write_indicator(emitter, []byte{'\''}, true, false, false) { - return false - } - - spaces := false - breaks := false - for i := 0; i < len(value); { - if is_space(value, i) { - if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 && !is_space(value, i+1) { - if !yaml_emitter_write_indent(emitter) { - return false - } - i += width(value[i]) - } else { - if !write(emitter, value, &i) { - return false - } - } - spaces = true - } else if is_break(value, i) { - if !breaks && value[i] == '\n' { - if !put_break(emitter) { - return false - } - } - if !write_break(emitter, value, &i) { - return false - } - emitter.indention = true - breaks = true - } else { - if breaks { - if !yaml_emitter_write_indent(emitter) { - return false - } - } - if value[i] == '\'' { - if !put(emitter, '\'') { - return false - } - } - if !write(emitter, value, &i) { - return false - } - emitter.indention = false - spaces = false - breaks = false - } - } - if !yaml_emitter_write_indicator(emitter, []byte{'\''}, false, false, false) { - return false - } - emitter.whitespace = false - emitter.indention = false - return true -} - -func yaml_emitter_write_double_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool { - spaces := false - if !yaml_emitter_write_indicator(emitter, []byte{'"'}, true, false, false) { - return false - } - - for i := 0; i < len(value); { - if !is_printable(value, i) || (!emitter.unicode && !is_ascii(value, i)) || - is_bom(value, i) || is_break(value, i) || - value[i] == '"' || value[i] == '\\' { - - octet := value[i] - - var w int - var v rune - switch { - case octet&0x80 == 0x00: - w, v = 1, rune(octet&0x7F) - case octet&0xE0 == 0xC0: - w, v = 2, rune(octet&0x1F) - case octet&0xF0 == 0xE0: - w, v = 3, rune(octet&0x0F) - case octet&0xF8 == 0xF0: - w, v = 4, rune(octet&0x07) - } - for k := 1; k < w; k++ { - octet = value[i+k] - v = (v << 6) + (rune(octet) & 0x3F) - } - i += w - - if !put(emitter, '\\') { - return false - } - - var ok bool - switch v { - case 0x00: - ok = put(emitter, '0') - case 0x07: - ok = put(emitter, 'a') - case 0x08: - ok = put(emitter, 'b') - case 0x09: - ok = put(emitter, 't') - case 0x0A: - ok = put(emitter, 'n') - case 0x0b: - ok = put(emitter, 'v') - case 0x0c: - ok = put(emitter, 'f') - case 0x0d: - ok = put(emitter, 'r') - case 0x1b: - ok = put(emitter, 'e') - case 0x22: - ok = put(emitter, '"') - case 0x5c: - ok = put(emitter, '\\') - case 0x85: - ok = put(emitter, 'N') - case 0xA0: - ok = put(emitter, '_') - case 0x2028: - ok = put(emitter, 'L') - case 0x2029: - ok = put(emitter, 'P') - default: - if v <= 0xFF { - ok = put(emitter, 'x') - w = 2 - } else if v <= 0xFFFF { - ok = put(emitter, 'u') - w = 4 - } else { - ok = put(emitter, 'U') - w = 8 - } - for k := (w - 1) * 4; ok && k >= 0; k -= 4 { - digit := byte((v >> uint(k)) & 0x0F) - if digit < 10 { - ok = put(emitter, digit+'0') - } else { - ok = put(emitter, digit+'A'-10) - } - } - } - if !ok { - return false - } - spaces = false - } else if is_space(value, i) { - if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 { - if !yaml_emitter_write_indent(emitter) { - return false - } - if is_space(value, i+1) { - if !put(emitter, '\\') { - return false - } - } - i += width(value[i]) - } else if !write(emitter, value, &i) { - return false - } - spaces = true - } else { - if !write(emitter, value, &i) { - return false - } - spaces = false - } - } - if !yaml_emitter_write_indicator(emitter, []byte{'"'}, false, false, false) { - return false - } - emitter.whitespace = false - emitter.indention = false - return true -} - -func yaml_emitter_write_block_scalar_hints(emitter *yaml_emitter_t, value []byte) bool { - if is_space(value, 0) || is_break(value, 0) { - indent_hint := []byte{'0' + byte(emitter.best_indent)} - if !yaml_emitter_write_indicator(emitter, indent_hint, false, false, false) { - return false - } - } - - emitter.open_ended = false - - var chomp_hint [1]byte - if len(value) == 0 { - chomp_hint[0] = '-' - } else { - i := len(value) - 1 - for value[i]&0xC0 == 0x80 { - i-- - } - if !is_break(value, i) { - chomp_hint[0] = '-' - } else if i == 0 { - chomp_hint[0] = '+' - emitter.open_ended = true - } else { - i-- - for value[i]&0xC0 == 0x80 { - i-- - } - if is_break(value, i) { - chomp_hint[0] = '+' - emitter.open_ended = true - } - } - } - if chomp_hint[0] != 0 { - if !yaml_emitter_write_indicator(emitter, chomp_hint[:], false, false, false) { - return false - } - } - return true -} - -func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bool { - if !yaml_emitter_write_indicator(emitter, []byte{'|'}, true, false, false) { - return false - } - if !yaml_emitter_write_block_scalar_hints(emitter, value) { - return false - } - if !put_break(emitter) { - return false - } - emitter.indention = true - emitter.whitespace = true - breaks := true - for i := 0; i < len(value); { - if is_break(value, i) { - if !write_break(emitter, value, &i) { - return false - } - emitter.indention = true - breaks = true - } else { - if breaks { - if !yaml_emitter_write_indent(emitter) { - return false - } - } - if !write(emitter, value, &i) { - return false - } - emitter.indention = false - breaks = false - } - } - - return true -} - -func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) bool { - if !yaml_emitter_write_indicator(emitter, []byte{'>'}, true, false, false) { - return false - } - if !yaml_emitter_write_block_scalar_hints(emitter, value) { - return false - } - - if !put_break(emitter) { - return false - } - emitter.indention = true - emitter.whitespace = true - - breaks := true - leading_spaces := true - for i := 0; i < len(value); { - if is_break(value, i) { - if !breaks && !leading_spaces && value[i] == '\n' { - k := 0 - for is_break(value, k) { - k += width(value[k]) - } - if !is_blankz(value, k) { - if !put_break(emitter) { - return false - } - } - } - if !write_break(emitter, value, &i) { - return false - } - emitter.indention = true - breaks = true - } else { - if breaks { - if !yaml_emitter_write_indent(emitter) { - return false - } - leading_spaces = is_blank(value, i) - } - if !breaks && is_space(value, i) && !is_space(value, i+1) && emitter.column > emitter.best_width { - if !yaml_emitter_write_indent(emitter) { - return false - } - i += width(value[i]) - } else { - if !write(emitter, value, &i) { - return false - } - } - emitter.indention = false - breaks = false - } - } - return true -} diff --git a/vendor/gopkg.in/yaml.v2/encode.go b/vendor/gopkg.in/yaml.v2/encode.go deleted file mode 100644 index a14435e..0000000 --- a/vendor/gopkg.in/yaml.v2/encode.go +++ /dev/null @@ -1,362 +0,0 @@ -package yaml - -import ( - "encoding" - "fmt" - "io" - "reflect" - "regexp" - "sort" - "strconv" - "strings" - "time" - "unicode/utf8" -) - -type encoder struct { - emitter yaml_emitter_t - event yaml_event_t - out []byte - flow bool - // doneInit holds whether the initial stream_start_event has been - // emitted. - doneInit bool -} - -func newEncoder() *encoder { - e := &encoder{} - yaml_emitter_initialize(&e.emitter) - yaml_emitter_set_output_string(&e.emitter, &e.out) - yaml_emitter_set_unicode(&e.emitter, true) - return e -} - -func newEncoderWithWriter(w io.Writer) *encoder { - e := &encoder{} - yaml_emitter_initialize(&e.emitter) - yaml_emitter_set_output_writer(&e.emitter, w) - yaml_emitter_set_unicode(&e.emitter, true) - return e -} - -func (e *encoder) init() { - if e.doneInit { - return - } - yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING) - e.emit() - e.doneInit = true -} - -func (e *encoder) finish() { - e.emitter.open_ended = false - yaml_stream_end_event_initialize(&e.event) - e.emit() -} - -func (e *encoder) destroy() { - yaml_emitter_delete(&e.emitter) -} - -func (e *encoder) emit() { - // This will internally delete the e.event value. - e.must(yaml_emitter_emit(&e.emitter, &e.event)) -} - -func (e *encoder) must(ok bool) { - if !ok { - msg := e.emitter.problem - if msg == "" { - msg = "unknown problem generating YAML content" - } - failf("%s", msg) - } -} - -func (e *encoder) marshalDoc(tag string, in reflect.Value) { - e.init() - yaml_document_start_event_initialize(&e.event, nil, nil, true) - e.emit() - e.marshal(tag, in) - yaml_document_end_event_initialize(&e.event, true) - e.emit() -} - -func (e *encoder) marshal(tag string, in reflect.Value) { - if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() { - e.nilv() - return - } - iface := in.Interface() - switch m := iface.(type) { - case time.Time, *time.Time: - // Although time.Time implements TextMarshaler, - // we don't want to treat it as a string for YAML - // purposes because YAML has special support for - // timestamps. - case Marshaler: - v, err := m.MarshalYAML() - if err != nil { - fail(err) - } - if v == nil { - e.nilv() - return - } - in = reflect.ValueOf(v) - case encoding.TextMarshaler: - text, err := m.MarshalText() - if err != nil { - fail(err) - } - in = reflect.ValueOf(string(text)) - case nil: - e.nilv() - return - } - switch in.Kind() { - case reflect.Interface: - e.marshal(tag, in.Elem()) - case reflect.Map: - e.mapv(tag, in) - case reflect.Ptr: - if in.Type() == ptrTimeType { - e.timev(tag, in.Elem()) - } else { - e.marshal(tag, in.Elem()) - } - case reflect.Struct: - if in.Type() == timeType { - e.timev(tag, in) - } else { - e.structv(tag, in) - } - case reflect.Slice, reflect.Array: - if in.Type().Elem() == mapItemType { - e.itemsv(tag, in) - } else { - e.slicev(tag, in) - } - case reflect.String: - e.stringv(tag, in) - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - if in.Type() == durationType { - e.stringv(tag, reflect.ValueOf(iface.(time.Duration).String())) - } else { - e.intv(tag, in) - } - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: - e.uintv(tag, in) - case reflect.Float32, reflect.Float64: - e.floatv(tag, in) - case reflect.Bool: - e.boolv(tag, in) - default: - panic("cannot marshal type: " + in.Type().String()) - } -} - -func (e *encoder) mapv(tag string, in reflect.Value) { - e.mappingv(tag, func() { - keys := keyList(in.MapKeys()) - sort.Sort(keys) - for _, k := range keys { - e.marshal("", k) - e.marshal("", in.MapIndex(k)) - } - }) -} - -func (e *encoder) itemsv(tag string, in reflect.Value) { - e.mappingv(tag, func() { - slice := in.Convert(reflect.TypeOf([]MapItem{})).Interface().([]MapItem) - for _, item := range slice { - e.marshal("", reflect.ValueOf(item.Key)) - e.marshal("", reflect.ValueOf(item.Value)) - } - }) -} - -func (e *encoder) structv(tag string, in reflect.Value) { - sinfo, err := getStructInfo(in.Type()) - if err != nil { - panic(err) - } - e.mappingv(tag, func() { - for _, info := range sinfo.FieldsList { - var value reflect.Value - if info.Inline == nil { - value = in.Field(info.Num) - } else { - value = in.FieldByIndex(info.Inline) - } - if info.OmitEmpty && isZero(value) { - continue - } - e.marshal("", reflect.ValueOf(info.Key)) - e.flow = info.Flow - e.marshal("", value) - } - if sinfo.InlineMap >= 0 { - m := in.Field(sinfo.InlineMap) - if m.Len() > 0 { - e.flow = false - keys := keyList(m.MapKeys()) - sort.Sort(keys) - for _, k := range keys { - if _, found := sinfo.FieldsMap[k.String()]; found { - panic(fmt.Sprintf("Can't have key %q in inlined map; conflicts with struct field", k.String())) - } - e.marshal("", k) - e.flow = false - e.marshal("", m.MapIndex(k)) - } - } - } - }) -} - -func (e *encoder) mappingv(tag string, f func()) { - implicit := tag == "" - style := yaml_BLOCK_MAPPING_STYLE - if e.flow { - e.flow = false - style = yaml_FLOW_MAPPING_STYLE - } - yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style) - e.emit() - f() - yaml_mapping_end_event_initialize(&e.event) - e.emit() -} - -func (e *encoder) slicev(tag string, in reflect.Value) { - implicit := tag == "" - style := yaml_BLOCK_SEQUENCE_STYLE - if e.flow { - e.flow = false - style = yaml_FLOW_SEQUENCE_STYLE - } - e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)) - e.emit() - n := in.Len() - for i := 0; i < n; i++ { - e.marshal("", in.Index(i)) - } - e.must(yaml_sequence_end_event_initialize(&e.event)) - e.emit() -} - -// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1. -// -// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported -// in YAML 1.2 and by this package, but these should be marshalled quoted for -// the time being for compatibility with other parsers. -func isBase60Float(s string) (result bool) { - // Fast path. - if s == "" { - return false - } - c := s[0] - if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 { - return false - } - // Do the full match. - return base60float.MatchString(s) -} - -// From http://yaml.org/type/float.html, except the regular expression there -// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix. -var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`) - -func (e *encoder) stringv(tag string, in reflect.Value) { - var style yaml_scalar_style_t - s := in.String() - canUsePlain := true - switch { - case !utf8.ValidString(s): - if tag == yaml_BINARY_TAG { - failf("explicitly tagged !!binary data must be base64-encoded") - } - if tag != "" { - failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag)) - } - // It can't be encoded directly as YAML so use a binary tag - // and encode it as base64. - tag = yaml_BINARY_TAG - s = encodeBase64(s) - case tag == "": - // Check to see if it would resolve to a specific - // tag when encoded unquoted. If it doesn't, - // there's no need to quote it. - rtag, _ := resolve("", s) - canUsePlain = rtag == yaml_STR_TAG && !isBase60Float(s) - } - // Note: it's possible for user code to emit invalid YAML - // if they explicitly specify a tag and a string containing - // text that's incompatible with that tag. - switch { - case strings.Contains(s, "\n"): - style = yaml_LITERAL_SCALAR_STYLE - case canUsePlain: - style = yaml_PLAIN_SCALAR_STYLE - default: - style = yaml_DOUBLE_QUOTED_SCALAR_STYLE - } - e.emitScalar(s, "", tag, style) -} - -func (e *encoder) boolv(tag string, in reflect.Value) { - var s string - if in.Bool() { - s = "true" - } else { - s = "false" - } - e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) -} - -func (e *encoder) intv(tag string, in reflect.Value) { - s := strconv.FormatInt(in.Int(), 10) - e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) -} - -func (e *encoder) uintv(tag string, in reflect.Value) { - s := strconv.FormatUint(in.Uint(), 10) - e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) -} - -func (e *encoder) timev(tag string, in reflect.Value) { - t := in.Interface().(time.Time) - s := t.Format(time.RFC3339Nano) - e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) -} - -func (e *encoder) floatv(tag string, in reflect.Value) { - // Issue #352: When formatting, use the precision of the underlying value - precision := 64 - if in.Kind() == reflect.Float32 { - precision = 32 - } - - s := strconv.FormatFloat(in.Float(), 'g', -1, precision) - switch s { - case "+Inf": - s = ".inf" - case "-Inf": - s = "-.inf" - case "NaN": - s = ".nan" - } - e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE) -} - -func (e *encoder) nilv() { - e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE) -} - -func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t) { - implicit := tag == "" - e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style)) - e.emit() -} diff --git a/vendor/gopkg.in/yaml.v2/go.mod b/vendor/gopkg.in/yaml.v2/go.mod deleted file mode 100644 index 1934e87..0000000 --- a/vendor/gopkg.in/yaml.v2/go.mod +++ /dev/null @@ -1,5 +0,0 @@ -module "gopkg.in/yaml.v2" - -require ( - "gopkg.in/check.v1" v0.0.0-20161208181325-20d25e280405 -) diff --git a/vendor/gopkg.in/yaml.v2/parserc.go b/vendor/gopkg.in/yaml.v2/parserc.go deleted file mode 100644 index 81d05df..0000000 --- a/vendor/gopkg.in/yaml.v2/parserc.go +++ /dev/null @@ -1,1095 +0,0 @@ -package yaml - -import ( - "bytes" -) - -// The parser implements the following grammar: -// -// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END -// implicit_document ::= block_node DOCUMENT-END* -// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* -// block_node_or_indentless_sequence ::= -// ALIAS -// | properties (block_content | indentless_block_sequence)? -// | block_content -// | indentless_block_sequence -// block_node ::= ALIAS -// | properties block_content? -// | block_content -// flow_node ::= ALIAS -// | properties flow_content? -// | flow_content -// properties ::= TAG ANCHOR? | ANCHOR TAG? -// block_content ::= block_collection | flow_collection | SCALAR -// flow_content ::= flow_collection | SCALAR -// block_collection ::= block_sequence | block_mapping -// flow_collection ::= flow_sequence | flow_mapping -// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END -// indentless_sequence ::= (BLOCK-ENTRY block_node?)+ -// block_mapping ::= BLOCK-MAPPING_START -// ((KEY block_node_or_indentless_sequence?)? -// (VALUE block_node_or_indentless_sequence?)?)* -// BLOCK-END -// flow_sequence ::= FLOW-SEQUENCE-START -// (flow_sequence_entry FLOW-ENTRY)* -// flow_sequence_entry? -// FLOW-SEQUENCE-END -// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? -// flow_mapping ::= FLOW-MAPPING-START -// (flow_mapping_entry FLOW-ENTRY)* -// flow_mapping_entry? -// FLOW-MAPPING-END -// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? - -// Peek the next token in the token queue. -func peek_token(parser *yaml_parser_t) *yaml_token_t { - if parser.token_available || yaml_parser_fetch_more_tokens(parser) { - return &parser.tokens[parser.tokens_head] - } - return nil -} - -// Remove the next token from the queue (must be called after peek_token). -func skip_token(parser *yaml_parser_t) { - parser.token_available = false - parser.tokens_parsed++ - parser.stream_end_produced = parser.tokens[parser.tokens_head].typ == yaml_STREAM_END_TOKEN - parser.tokens_head++ -} - -// Get the next event. -func yaml_parser_parse(parser *yaml_parser_t, event *yaml_event_t) bool { - // Erase the event object. - *event = yaml_event_t{} - - // No events after the end of the stream or error. - if parser.stream_end_produced || parser.error != yaml_NO_ERROR || parser.state == yaml_PARSE_END_STATE { - return true - } - - // Generate the next event. - return yaml_parser_state_machine(parser, event) -} - -// Set parser error. -func yaml_parser_set_parser_error(parser *yaml_parser_t, problem string, problem_mark yaml_mark_t) bool { - parser.error = yaml_PARSER_ERROR - parser.problem = problem - parser.problem_mark = problem_mark - return false -} - -func yaml_parser_set_parser_error_context(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string, problem_mark yaml_mark_t) bool { - parser.error = yaml_PARSER_ERROR - parser.context = context - parser.context_mark = context_mark - parser.problem = problem - parser.problem_mark = problem_mark - return false -} - -// State dispatcher. -func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool { - //trace("yaml_parser_state_machine", "state:", parser.state.String()) - - switch parser.state { - case yaml_PARSE_STREAM_START_STATE: - return yaml_parser_parse_stream_start(parser, event) - - case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE: - return yaml_parser_parse_document_start(parser, event, true) - - case yaml_PARSE_DOCUMENT_START_STATE: - return yaml_parser_parse_document_start(parser, event, false) - - case yaml_PARSE_DOCUMENT_CONTENT_STATE: - return yaml_parser_parse_document_content(parser, event) - - case yaml_PARSE_DOCUMENT_END_STATE: - return yaml_parser_parse_document_end(parser, event) - - case yaml_PARSE_BLOCK_NODE_STATE: - return yaml_parser_parse_node(parser, event, true, false) - - case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE: - return yaml_parser_parse_node(parser, event, true, true) - - case yaml_PARSE_FLOW_NODE_STATE: - return yaml_parser_parse_node(parser, event, false, false) - - case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE: - return yaml_parser_parse_block_sequence_entry(parser, event, true) - - case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE: - return yaml_parser_parse_block_sequence_entry(parser, event, false) - - case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE: - return yaml_parser_parse_indentless_sequence_entry(parser, event) - - case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE: - return yaml_parser_parse_block_mapping_key(parser, event, true) - - case yaml_PARSE_BLOCK_MAPPING_KEY_STATE: - return yaml_parser_parse_block_mapping_key(parser, event, false) - - case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE: - return yaml_parser_parse_block_mapping_value(parser, event) - - case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE: - return yaml_parser_parse_flow_sequence_entry(parser, event, true) - - case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE: - return yaml_parser_parse_flow_sequence_entry(parser, event, false) - - case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE: - return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event) - - case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE: - return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event) - - case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE: - return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event) - - case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE: - return yaml_parser_parse_flow_mapping_key(parser, event, true) - - case yaml_PARSE_FLOW_MAPPING_KEY_STATE: - return yaml_parser_parse_flow_mapping_key(parser, event, false) - - case yaml_PARSE_FLOW_MAPPING_VALUE_STATE: - return yaml_parser_parse_flow_mapping_value(parser, event, false) - - case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE: - return yaml_parser_parse_flow_mapping_value(parser, event, true) - - default: - panic("invalid parser state") - } -} - -// Parse the production: -// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END -// ************ -func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) bool { - token := peek_token(parser) - if token == nil { - return false - } - if token.typ != yaml_STREAM_START_TOKEN { - return yaml_parser_set_parser_error(parser, "did not find expected ", token.start_mark) - } - parser.state = yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE - *event = yaml_event_t{ - typ: yaml_STREAM_START_EVENT, - start_mark: token.start_mark, - end_mark: token.end_mark, - encoding: token.encoding, - } - skip_token(parser) - return true -} - -// Parse the productions: -// implicit_document ::= block_node DOCUMENT-END* -// * -// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* -// ************************* -func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t, implicit bool) bool { - - token := peek_token(parser) - if token == nil { - return false - } - - // Parse extra document end indicators. - if !implicit { - for token.typ == yaml_DOCUMENT_END_TOKEN { - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - } - } - - if implicit && token.typ != yaml_VERSION_DIRECTIVE_TOKEN && - token.typ != yaml_TAG_DIRECTIVE_TOKEN && - token.typ != yaml_DOCUMENT_START_TOKEN && - token.typ != yaml_STREAM_END_TOKEN { - // Parse an implicit document. - if !yaml_parser_process_directives(parser, nil, nil) { - return false - } - parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE) - parser.state = yaml_PARSE_BLOCK_NODE_STATE - - *event = yaml_event_t{ - typ: yaml_DOCUMENT_START_EVENT, - start_mark: token.start_mark, - end_mark: token.end_mark, - } - - } else if token.typ != yaml_STREAM_END_TOKEN { - // Parse an explicit document. - var version_directive *yaml_version_directive_t - var tag_directives []yaml_tag_directive_t - start_mark := token.start_mark - if !yaml_parser_process_directives(parser, &version_directive, &tag_directives) { - return false - } - token = peek_token(parser) - if token == nil { - return false - } - if token.typ != yaml_DOCUMENT_START_TOKEN { - yaml_parser_set_parser_error(parser, - "did not find expected ", token.start_mark) - return false - } - parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE) - parser.state = yaml_PARSE_DOCUMENT_CONTENT_STATE - end_mark := token.end_mark - - *event = yaml_event_t{ - typ: yaml_DOCUMENT_START_EVENT, - start_mark: start_mark, - end_mark: end_mark, - version_directive: version_directive, - tag_directives: tag_directives, - implicit: false, - } - skip_token(parser) - - } else { - // Parse the stream end. - parser.state = yaml_PARSE_END_STATE - *event = yaml_event_t{ - typ: yaml_STREAM_END_EVENT, - start_mark: token.start_mark, - end_mark: token.end_mark, - } - skip_token(parser) - } - - return true -} - -// Parse the productions: -// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* -// *********** -// -func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event_t) bool { - token := peek_token(parser) - if token == nil { - return false - } - if token.typ == yaml_VERSION_DIRECTIVE_TOKEN || - token.typ == yaml_TAG_DIRECTIVE_TOKEN || - token.typ == yaml_DOCUMENT_START_TOKEN || - token.typ == yaml_DOCUMENT_END_TOKEN || - token.typ == yaml_STREAM_END_TOKEN { - parser.state = parser.states[len(parser.states)-1] - parser.states = parser.states[:len(parser.states)-1] - return yaml_parser_process_empty_scalar(parser, event, - token.start_mark) - } - return yaml_parser_parse_node(parser, event, true, false) -} - -// Parse the productions: -// implicit_document ::= block_node DOCUMENT-END* -// ************* -// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* -// -func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool { - token := peek_token(parser) - if token == nil { - return false - } - - start_mark := token.start_mark - end_mark := token.start_mark - - implicit := true - if token.typ == yaml_DOCUMENT_END_TOKEN { - end_mark = token.end_mark - skip_token(parser) - implicit = false - } - - parser.tag_directives = parser.tag_directives[:0] - - parser.state = yaml_PARSE_DOCUMENT_START_STATE - *event = yaml_event_t{ - typ: yaml_DOCUMENT_END_EVENT, - start_mark: start_mark, - end_mark: end_mark, - implicit: implicit, - } - return true -} - -// Parse the productions: -// block_node_or_indentless_sequence ::= -// ALIAS -// ***** -// | properties (block_content | indentless_block_sequence)? -// ********** * -// | block_content | indentless_block_sequence -// * -// block_node ::= ALIAS -// ***** -// | properties block_content? -// ********** * -// | block_content -// * -// flow_node ::= ALIAS -// ***** -// | properties flow_content? -// ********** * -// | flow_content -// * -// properties ::= TAG ANCHOR? | ANCHOR TAG? -// ************************* -// block_content ::= block_collection | flow_collection | SCALAR -// ****** -// flow_content ::= flow_collection | SCALAR -// ****** -func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, indentless_sequence bool) bool { - //defer trace("yaml_parser_parse_node", "block:", block, "indentless_sequence:", indentless_sequence)() - - token := peek_token(parser) - if token == nil { - return false - } - - if token.typ == yaml_ALIAS_TOKEN { - parser.state = parser.states[len(parser.states)-1] - parser.states = parser.states[:len(parser.states)-1] - *event = yaml_event_t{ - typ: yaml_ALIAS_EVENT, - start_mark: token.start_mark, - end_mark: token.end_mark, - anchor: token.value, - } - skip_token(parser) - return true - } - - start_mark := token.start_mark - end_mark := token.start_mark - - var tag_token bool - var tag_handle, tag_suffix, anchor []byte - var tag_mark yaml_mark_t - if token.typ == yaml_ANCHOR_TOKEN { - anchor = token.value - start_mark = token.start_mark - end_mark = token.end_mark - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - if token.typ == yaml_TAG_TOKEN { - tag_token = true - tag_handle = token.value - tag_suffix = token.suffix - tag_mark = token.start_mark - end_mark = token.end_mark - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - } - } else if token.typ == yaml_TAG_TOKEN { - tag_token = true - tag_handle = token.value - tag_suffix = token.suffix - start_mark = token.start_mark - tag_mark = token.start_mark - end_mark = token.end_mark - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - if token.typ == yaml_ANCHOR_TOKEN { - anchor = token.value - end_mark = token.end_mark - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - } - } - - var tag []byte - if tag_token { - if len(tag_handle) == 0 { - tag = tag_suffix - tag_suffix = nil - } else { - for i := range parser.tag_directives { - if bytes.Equal(parser.tag_directives[i].handle, tag_handle) { - tag = append([]byte(nil), parser.tag_directives[i].prefix...) - tag = append(tag, tag_suffix...) - break - } - } - if len(tag) == 0 { - yaml_parser_set_parser_error_context(parser, - "while parsing a node", start_mark, - "found undefined tag handle", tag_mark) - return false - } - } - } - - implicit := len(tag) == 0 - if indentless_sequence && token.typ == yaml_BLOCK_ENTRY_TOKEN { - end_mark = token.end_mark - parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE - *event = yaml_event_t{ - typ: yaml_SEQUENCE_START_EVENT, - start_mark: start_mark, - end_mark: end_mark, - anchor: anchor, - tag: tag, - implicit: implicit, - style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE), - } - return true - } - if token.typ == yaml_SCALAR_TOKEN { - var plain_implicit, quoted_implicit bool - end_mark = token.end_mark - if (len(tag) == 0 && token.style == yaml_PLAIN_SCALAR_STYLE) || (len(tag) == 1 && tag[0] == '!') { - plain_implicit = true - } else if len(tag) == 0 { - quoted_implicit = true - } - parser.state = parser.states[len(parser.states)-1] - parser.states = parser.states[:len(parser.states)-1] - - *event = yaml_event_t{ - typ: yaml_SCALAR_EVENT, - start_mark: start_mark, - end_mark: end_mark, - anchor: anchor, - tag: tag, - value: token.value, - implicit: plain_implicit, - quoted_implicit: quoted_implicit, - style: yaml_style_t(token.style), - } - skip_token(parser) - return true - } - if token.typ == yaml_FLOW_SEQUENCE_START_TOKEN { - // [Go] Some of the events below can be merged as they differ only on style. - end_mark = token.end_mark - parser.state = yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE - *event = yaml_event_t{ - typ: yaml_SEQUENCE_START_EVENT, - start_mark: start_mark, - end_mark: end_mark, - anchor: anchor, - tag: tag, - implicit: implicit, - style: yaml_style_t(yaml_FLOW_SEQUENCE_STYLE), - } - return true - } - if token.typ == yaml_FLOW_MAPPING_START_TOKEN { - end_mark = token.end_mark - parser.state = yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE - *event = yaml_event_t{ - typ: yaml_MAPPING_START_EVENT, - start_mark: start_mark, - end_mark: end_mark, - anchor: anchor, - tag: tag, - implicit: implicit, - style: yaml_style_t(yaml_FLOW_MAPPING_STYLE), - } - return true - } - if block && token.typ == yaml_BLOCK_SEQUENCE_START_TOKEN { - end_mark = token.end_mark - parser.state = yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE - *event = yaml_event_t{ - typ: yaml_SEQUENCE_START_EVENT, - start_mark: start_mark, - end_mark: end_mark, - anchor: anchor, - tag: tag, - implicit: implicit, - style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE), - } - return true - } - if block && token.typ == yaml_BLOCK_MAPPING_START_TOKEN { - end_mark = token.end_mark - parser.state = yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE - *event = yaml_event_t{ - typ: yaml_MAPPING_START_EVENT, - start_mark: start_mark, - end_mark: end_mark, - anchor: anchor, - tag: tag, - implicit: implicit, - style: yaml_style_t(yaml_BLOCK_MAPPING_STYLE), - } - return true - } - if len(anchor) > 0 || len(tag) > 0 { - parser.state = parser.states[len(parser.states)-1] - parser.states = parser.states[:len(parser.states)-1] - - *event = yaml_event_t{ - typ: yaml_SCALAR_EVENT, - start_mark: start_mark, - end_mark: end_mark, - anchor: anchor, - tag: tag, - implicit: implicit, - quoted_implicit: false, - style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE), - } - return true - } - - context := "while parsing a flow node" - if block { - context = "while parsing a block node" - } - yaml_parser_set_parser_error_context(parser, context, start_mark, - "did not find expected node content", token.start_mark) - return false -} - -// Parse the productions: -// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END -// ******************** *********** * ********* -// -func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { - if first { - token := peek_token(parser) - parser.marks = append(parser.marks, token.start_mark) - skip_token(parser) - } - - token := peek_token(parser) - if token == nil { - return false - } - - if token.typ == yaml_BLOCK_ENTRY_TOKEN { - mark := token.end_mark - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - if token.typ != yaml_BLOCK_ENTRY_TOKEN && token.typ != yaml_BLOCK_END_TOKEN { - parser.states = append(parser.states, yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE) - return yaml_parser_parse_node(parser, event, true, false) - } else { - parser.state = yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE - return yaml_parser_process_empty_scalar(parser, event, mark) - } - } - if token.typ == yaml_BLOCK_END_TOKEN { - parser.state = parser.states[len(parser.states)-1] - parser.states = parser.states[:len(parser.states)-1] - parser.marks = parser.marks[:len(parser.marks)-1] - - *event = yaml_event_t{ - typ: yaml_SEQUENCE_END_EVENT, - start_mark: token.start_mark, - end_mark: token.end_mark, - } - - skip_token(parser) - return true - } - - context_mark := parser.marks[len(parser.marks)-1] - parser.marks = parser.marks[:len(parser.marks)-1] - return yaml_parser_set_parser_error_context(parser, - "while parsing a block collection", context_mark, - "did not find expected '-' indicator", token.start_mark) -} - -// Parse the productions: -// indentless_sequence ::= (BLOCK-ENTRY block_node?)+ -// *********** * -func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *yaml_event_t) bool { - token := peek_token(parser) - if token == nil { - return false - } - - if token.typ == yaml_BLOCK_ENTRY_TOKEN { - mark := token.end_mark - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - if token.typ != yaml_BLOCK_ENTRY_TOKEN && - token.typ != yaml_KEY_TOKEN && - token.typ != yaml_VALUE_TOKEN && - token.typ != yaml_BLOCK_END_TOKEN { - parser.states = append(parser.states, yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE) - return yaml_parser_parse_node(parser, event, true, false) - } - parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE - return yaml_parser_process_empty_scalar(parser, event, mark) - } - parser.state = parser.states[len(parser.states)-1] - parser.states = parser.states[:len(parser.states)-1] - - *event = yaml_event_t{ - typ: yaml_SEQUENCE_END_EVENT, - start_mark: token.start_mark, - end_mark: token.start_mark, // [Go] Shouldn't this be token.end_mark? - } - return true -} - -// Parse the productions: -// block_mapping ::= BLOCK-MAPPING_START -// ******************* -// ((KEY block_node_or_indentless_sequence?)? -// *** * -// (VALUE block_node_or_indentless_sequence?)?)* -// -// BLOCK-END -// ********* -// -func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { - if first { - token := peek_token(parser) - parser.marks = append(parser.marks, token.start_mark) - skip_token(parser) - } - - token := peek_token(parser) - if token == nil { - return false - } - - if token.typ == yaml_KEY_TOKEN { - mark := token.end_mark - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - if token.typ != yaml_KEY_TOKEN && - token.typ != yaml_VALUE_TOKEN && - token.typ != yaml_BLOCK_END_TOKEN { - parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_VALUE_STATE) - return yaml_parser_parse_node(parser, event, true, true) - } else { - parser.state = yaml_PARSE_BLOCK_MAPPING_VALUE_STATE - return yaml_parser_process_empty_scalar(parser, event, mark) - } - } else if token.typ == yaml_BLOCK_END_TOKEN { - parser.state = parser.states[len(parser.states)-1] - parser.states = parser.states[:len(parser.states)-1] - parser.marks = parser.marks[:len(parser.marks)-1] - *event = yaml_event_t{ - typ: yaml_MAPPING_END_EVENT, - start_mark: token.start_mark, - end_mark: token.end_mark, - } - skip_token(parser) - return true - } - - context_mark := parser.marks[len(parser.marks)-1] - parser.marks = parser.marks[:len(parser.marks)-1] - return yaml_parser_set_parser_error_context(parser, - "while parsing a block mapping", context_mark, - "did not find expected key", token.start_mark) -} - -// Parse the productions: -// block_mapping ::= BLOCK-MAPPING_START -// -// ((KEY block_node_or_indentless_sequence?)? -// -// (VALUE block_node_or_indentless_sequence?)?)* -// ***** * -// BLOCK-END -// -// -func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool { - token := peek_token(parser) - if token == nil { - return false - } - if token.typ == yaml_VALUE_TOKEN { - mark := token.end_mark - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - if token.typ != yaml_KEY_TOKEN && - token.typ != yaml_VALUE_TOKEN && - token.typ != yaml_BLOCK_END_TOKEN { - parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_KEY_STATE) - return yaml_parser_parse_node(parser, event, true, true) - } - parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE - return yaml_parser_process_empty_scalar(parser, event, mark) - } - parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE - return yaml_parser_process_empty_scalar(parser, event, token.start_mark) -} - -// Parse the productions: -// flow_sequence ::= FLOW-SEQUENCE-START -// ******************* -// (flow_sequence_entry FLOW-ENTRY)* -// * ********** -// flow_sequence_entry? -// * -// FLOW-SEQUENCE-END -// ***************** -// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? -// * -// -func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { - if first { - token := peek_token(parser) - parser.marks = append(parser.marks, token.start_mark) - skip_token(parser) - } - token := peek_token(parser) - if token == nil { - return false - } - if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN { - if !first { - if token.typ == yaml_FLOW_ENTRY_TOKEN { - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - } else { - context_mark := parser.marks[len(parser.marks)-1] - parser.marks = parser.marks[:len(parser.marks)-1] - return yaml_parser_set_parser_error_context(parser, - "while parsing a flow sequence", context_mark, - "did not find expected ',' or ']'", token.start_mark) - } - } - - if token.typ == yaml_KEY_TOKEN { - parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE - *event = yaml_event_t{ - typ: yaml_MAPPING_START_EVENT, - start_mark: token.start_mark, - end_mark: token.end_mark, - implicit: true, - style: yaml_style_t(yaml_FLOW_MAPPING_STYLE), - } - skip_token(parser) - return true - } else if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN { - parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE) - return yaml_parser_parse_node(parser, event, false, false) - } - } - - parser.state = parser.states[len(parser.states)-1] - parser.states = parser.states[:len(parser.states)-1] - parser.marks = parser.marks[:len(parser.marks)-1] - - *event = yaml_event_t{ - typ: yaml_SEQUENCE_END_EVENT, - start_mark: token.start_mark, - end_mark: token.end_mark, - } - - skip_token(parser) - return true -} - -// -// Parse the productions: -// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? -// *** * -// -func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, event *yaml_event_t) bool { - token := peek_token(parser) - if token == nil { - return false - } - if token.typ != yaml_VALUE_TOKEN && - token.typ != yaml_FLOW_ENTRY_TOKEN && - token.typ != yaml_FLOW_SEQUENCE_END_TOKEN { - parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE) - return yaml_parser_parse_node(parser, event, false, false) - } - mark := token.end_mark - skip_token(parser) - parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE - return yaml_parser_process_empty_scalar(parser, event, mark) -} - -// Parse the productions: -// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? -// ***** * -// -func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool { - token := peek_token(parser) - if token == nil { - return false - } - if token.typ == yaml_VALUE_TOKEN { - skip_token(parser) - token := peek_token(parser) - if token == nil { - return false - } - if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_SEQUENCE_END_TOKEN { - parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE) - return yaml_parser_parse_node(parser, event, false, false) - } - } - parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE - return yaml_parser_process_empty_scalar(parser, event, token.start_mark) -} - -// Parse the productions: -// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? -// * -// -func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, event *yaml_event_t) bool { - token := peek_token(parser) - if token == nil { - return false - } - parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE - *event = yaml_event_t{ - typ: yaml_MAPPING_END_EVENT, - start_mark: token.start_mark, - end_mark: token.start_mark, // [Go] Shouldn't this be end_mark? - } - return true -} - -// Parse the productions: -// flow_mapping ::= FLOW-MAPPING-START -// ****************** -// (flow_mapping_entry FLOW-ENTRY)* -// * ********** -// flow_mapping_entry? -// ****************** -// FLOW-MAPPING-END -// **************** -// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? -// * *** * -// -func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool { - if first { - token := peek_token(parser) - parser.marks = append(parser.marks, token.start_mark) - skip_token(parser) - } - - token := peek_token(parser) - if token == nil { - return false - } - - if token.typ != yaml_FLOW_MAPPING_END_TOKEN { - if !first { - if token.typ == yaml_FLOW_ENTRY_TOKEN { - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - } else { - context_mark := parser.marks[len(parser.marks)-1] - parser.marks = parser.marks[:len(parser.marks)-1] - return yaml_parser_set_parser_error_context(parser, - "while parsing a flow mapping", context_mark, - "did not find expected ',' or '}'", token.start_mark) - } - } - - if token.typ == yaml_KEY_TOKEN { - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - if token.typ != yaml_VALUE_TOKEN && - token.typ != yaml_FLOW_ENTRY_TOKEN && - token.typ != yaml_FLOW_MAPPING_END_TOKEN { - parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_VALUE_STATE) - return yaml_parser_parse_node(parser, event, false, false) - } else { - parser.state = yaml_PARSE_FLOW_MAPPING_VALUE_STATE - return yaml_parser_process_empty_scalar(parser, event, token.start_mark) - } - } else if token.typ != yaml_FLOW_MAPPING_END_TOKEN { - parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE) - return yaml_parser_parse_node(parser, event, false, false) - } - } - - parser.state = parser.states[len(parser.states)-1] - parser.states = parser.states[:len(parser.states)-1] - parser.marks = parser.marks[:len(parser.marks)-1] - *event = yaml_event_t{ - typ: yaml_MAPPING_END_EVENT, - start_mark: token.start_mark, - end_mark: token.end_mark, - } - skip_token(parser) - return true -} - -// Parse the productions: -// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? -// * ***** * -// -func yaml_parser_parse_flow_mapping_value(parser *yaml_parser_t, event *yaml_event_t, empty bool) bool { - token := peek_token(parser) - if token == nil { - return false - } - if empty { - parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE - return yaml_parser_process_empty_scalar(parser, event, token.start_mark) - } - if token.typ == yaml_VALUE_TOKEN { - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_MAPPING_END_TOKEN { - parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_KEY_STATE) - return yaml_parser_parse_node(parser, event, false, false) - } - } - parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE - return yaml_parser_process_empty_scalar(parser, event, token.start_mark) -} - -// Generate an empty scalar event. -func yaml_parser_process_empty_scalar(parser *yaml_parser_t, event *yaml_event_t, mark yaml_mark_t) bool { - *event = yaml_event_t{ - typ: yaml_SCALAR_EVENT, - start_mark: mark, - end_mark: mark, - value: nil, // Empty - implicit: true, - style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE), - } - return true -} - -var default_tag_directives = []yaml_tag_directive_t{ - {[]byte("!"), []byte("!")}, - {[]byte("!!"), []byte("tag:yaml.org,2002:")}, -} - -// Parse directives. -func yaml_parser_process_directives(parser *yaml_parser_t, - version_directive_ref **yaml_version_directive_t, - tag_directives_ref *[]yaml_tag_directive_t) bool { - - var version_directive *yaml_version_directive_t - var tag_directives []yaml_tag_directive_t - - token := peek_token(parser) - if token == nil { - return false - } - - for token.typ == yaml_VERSION_DIRECTIVE_TOKEN || token.typ == yaml_TAG_DIRECTIVE_TOKEN { - if token.typ == yaml_VERSION_DIRECTIVE_TOKEN { - if version_directive != nil { - yaml_parser_set_parser_error(parser, - "found duplicate %YAML directive", token.start_mark) - return false - } - if token.major != 1 || token.minor != 1 { - yaml_parser_set_parser_error(parser, - "found incompatible YAML document", token.start_mark) - return false - } - version_directive = &yaml_version_directive_t{ - major: token.major, - minor: token.minor, - } - } else if token.typ == yaml_TAG_DIRECTIVE_TOKEN { - value := yaml_tag_directive_t{ - handle: token.value, - prefix: token.prefix, - } - if !yaml_parser_append_tag_directive(parser, value, false, token.start_mark) { - return false - } - tag_directives = append(tag_directives, value) - } - - skip_token(parser) - token = peek_token(parser) - if token == nil { - return false - } - } - - for i := range default_tag_directives { - if !yaml_parser_append_tag_directive(parser, default_tag_directives[i], true, token.start_mark) { - return false - } - } - - if version_directive_ref != nil { - *version_directive_ref = version_directive - } - if tag_directives_ref != nil { - *tag_directives_ref = tag_directives - } - return true -} - -// Append a tag directive to the directives stack. -func yaml_parser_append_tag_directive(parser *yaml_parser_t, value yaml_tag_directive_t, allow_duplicates bool, mark yaml_mark_t) bool { - for i := range parser.tag_directives { - if bytes.Equal(value.handle, parser.tag_directives[i].handle) { - if allow_duplicates { - return true - } - return yaml_parser_set_parser_error(parser, "found duplicate %TAG directive", mark) - } - } - - // [Go] I suspect the copy is unnecessary. This was likely done - // because there was no way to track ownership of the data. - value_copy := yaml_tag_directive_t{ - handle: make([]byte, len(value.handle)), - prefix: make([]byte, len(value.prefix)), - } - copy(value_copy.handle, value.handle) - copy(value_copy.prefix, value.prefix) - parser.tag_directives = append(parser.tag_directives, value_copy) - return true -} diff --git a/vendor/gopkg.in/yaml.v2/readerc.go b/vendor/gopkg.in/yaml.v2/readerc.go deleted file mode 100644 index 7c1f5fa..0000000 --- a/vendor/gopkg.in/yaml.v2/readerc.go +++ /dev/null @@ -1,412 +0,0 @@ -package yaml - -import ( - "io" -) - -// Set the reader error and return 0. -func yaml_parser_set_reader_error(parser *yaml_parser_t, problem string, offset int, value int) bool { - parser.error = yaml_READER_ERROR - parser.problem = problem - parser.problem_offset = offset - parser.problem_value = value - return false -} - -// Byte order marks. -const ( - bom_UTF8 = "\xef\xbb\xbf" - bom_UTF16LE = "\xff\xfe" - bom_UTF16BE = "\xfe\xff" -) - -// Determine the input stream encoding by checking the BOM symbol. If no BOM is -// found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure. -func yaml_parser_determine_encoding(parser *yaml_parser_t) bool { - // Ensure that we had enough bytes in the raw buffer. - for !parser.eof && len(parser.raw_buffer)-parser.raw_buffer_pos < 3 { - if !yaml_parser_update_raw_buffer(parser) { - return false - } - } - - // Determine the encoding. - buf := parser.raw_buffer - pos := parser.raw_buffer_pos - avail := len(buf) - pos - if avail >= 2 && buf[pos] == bom_UTF16LE[0] && buf[pos+1] == bom_UTF16LE[1] { - parser.encoding = yaml_UTF16LE_ENCODING - parser.raw_buffer_pos += 2 - parser.offset += 2 - } else if avail >= 2 && buf[pos] == bom_UTF16BE[0] && buf[pos+1] == bom_UTF16BE[1] { - parser.encoding = yaml_UTF16BE_ENCODING - parser.raw_buffer_pos += 2 - parser.offset += 2 - } else if avail >= 3 && buf[pos] == bom_UTF8[0] && buf[pos+1] == bom_UTF8[1] && buf[pos+2] == bom_UTF8[2] { - parser.encoding = yaml_UTF8_ENCODING - parser.raw_buffer_pos += 3 - parser.offset += 3 - } else { - parser.encoding = yaml_UTF8_ENCODING - } - return true -} - -// Update the raw buffer. -func yaml_parser_update_raw_buffer(parser *yaml_parser_t) bool { - size_read := 0 - - // Return if the raw buffer is full. - if parser.raw_buffer_pos == 0 && len(parser.raw_buffer) == cap(parser.raw_buffer) { - return true - } - - // Return on EOF. - if parser.eof { - return true - } - - // Move the remaining bytes in the raw buffer to the beginning. - if parser.raw_buffer_pos > 0 && parser.raw_buffer_pos < len(parser.raw_buffer) { - copy(parser.raw_buffer, parser.raw_buffer[parser.raw_buffer_pos:]) - } - parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)-parser.raw_buffer_pos] - parser.raw_buffer_pos = 0 - - // Call the read handler to fill the buffer. - size_read, err := parser.read_handler(parser, parser.raw_buffer[len(parser.raw_buffer):cap(parser.raw_buffer)]) - parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)+size_read] - if err == io.EOF { - parser.eof = true - } else if err != nil { - return yaml_parser_set_reader_error(parser, "input error: "+err.Error(), parser.offset, -1) - } - return true -} - -// Ensure that the buffer contains at least `length` characters. -// Return true on success, false on failure. -// -// The length is supposed to be significantly less that the buffer size. -func yaml_parser_update_buffer(parser *yaml_parser_t, length int) bool { - if parser.read_handler == nil { - panic("read handler must be set") - } - - // [Go] This function was changed to guarantee the requested length size at EOF. - // The fact we need to do this is pretty awful, but the description above implies - // for that to be the case, and there are tests - - // If the EOF flag is set and the raw buffer is empty, do nothing. - if parser.eof && parser.raw_buffer_pos == len(parser.raw_buffer) { - // [Go] ACTUALLY! Read the documentation of this function above. - // This is just broken. To return true, we need to have the - // given length in the buffer. Not doing that means every single - // check that calls this function to make sure the buffer has a - // given length is Go) panicking; or C) accessing invalid memory. - //return true - } - - // Return if the buffer contains enough characters. - if parser.unread >= length { - return true - } - - // Determine the input encoding if it is not known yet. - if parser.encoding == yaml_ANY_ENCODING { - if !yaml_parser_determine_encoding(parser) { - return false - } - } - - // Move the unread characters to the beginning of the buffer. - buffer_len := len(parser.buffer) - if parser.buffer_pos > 0 && parser.buffer_pos < buffer_len { - copy(parser.buffer, parser.buffer[parser.buffer_pos:]) - buffer_len -= parser.buffer_pos - parser.buffer_pos = 0 - } else if parser.buffer_pos == buffer_len { - buffer_len = 0 - parser.buffer_pos = 0 - } - - // Open the whole buffer for writing, and cut it before returning. - parser.buffer = parser.buffer[:cap(parser.buffer)] - - // Fill the buffer until it has enough characters. - first := true - for parser.unread < length { - - // Fill the raw buffer if necessary. - if !first || parser.raw_buffer_pos == len(parser.raw_buffer) { - if !yaml_parser_update_raw_buffer(parser) { - parser.buffer = parser.buffer[:buffer_len] - return false - } - } - first = false - - // Decode the raw buffer. - inner: - for parser.raw_buffer_pos != len(parser.raw_buffer) { - var value rune - var width int - - raw_unread := len(parser.raw_buffer) - parser.raw_buffer_pos - - // Decode the next character. - switch parser.encoding { - case yaml_UTF8_ENCODING: - // Decode a UTF-8 character. Check RFC 3629 - // (http://www.ietf.org/rfc/rfc3629.txt) for more details. - // - // The following table (taken from the RFC) is used for - // decoding. - // - // Char. number range | UTF-8 octet sequence - // (hexadecimal) | (binary) - // --------------------+------------------------------------ - // 0000 0000-0000 007F | 0xxxxxxx - // 0000 0080-0000 07FF | 110xxxxx 10xxxxxx - // 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx - // 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx - // - // Additionally, the characters in the range 0xD800-0xDFFF - // are prohibited as they are reserved for use with UTF-16 - // surrogate pairs. - - // Determine the length of the UTF-8 sequence. - octet := parser.raw_buffer[parser.raw_buffer_pos] - switch { - case octet&0x80 == 0x00: - width = 1 - case octet&0xE0 == 0xC0: - width = 2 - case octet&0xF0 == 0xE0: - width = 3 - case octet&0xF8 == 0xF0: - width = 4 - default: - // The leading octet is invalid. - return yaml_parser_set_reader_error(parser, - "invalid leading UTF-8 octet", - parser.offset, int(octet)) - } - - // Check if the raw buffer contains an incomplete character. - if width > raw_unread { - if parser.eof { - return yaml_parser_set_reader_error(parser, - "incomplete UTF-8 octet sequence", - parser.offset, -1) - } - break inner - } - - // Decode the leading octet. - switch { - case octet&0x80 == 0x00: - value = rune(octet & 0x7F) - case octet&0xE0 == 0xC0: - value = rune(octet & 0x1F) - case octet&0xF0 == 0xE0: - value = rune(octet & 0x0F) - case octet&0xF8 == 0xF0: - value = rune(octet & 0x07) - default: - value = 0 - } - - // Check and decode the trailing octets. - for k := 1; k < width; k++ { - octet = parser.raw_buffer[parser.raw_buffer_pos+k] - - // Check if the octet is valid. - if (octet & 0xC0) != 0x80 { - return yaml_parser_set_reader_error(parser, - "invalid trailing UTF-8 octet", - parser.offset+k, int(octet)) - } - - // Decode the octet. - value = (value << 6) + rune(octet&0x3F) - } - - // Check the length of the sequence against the value. - switch { - case width == 1: - case width == 2 && value >= 0x80: - case width == 3 && value >= 0x800: - case width == 4 && value >= 0x10000: - default: - return yaml_parser_set_reader_error(parser, - "invalid length of a UTF-8 sequence", - parser.offset, -1) - } - - // Check the range of the value. - if value >= 0xD800 && value <= 0xDFFF || value > 0x10FFFF { - return yaml_parser_set_reader_error(parser, - "invalid Unicode character", - parser.offset, int(value)) - } - - case yaml_UTF16LE_ENCODING, yaml_UTF16BE_ENCODING: - var low, high int - if parser.encoding == yaml_UTF16LE_ENCODING { - low, high = 0, 1 - } else { - low, high = 1, 0 - } - - // The UTF-16 encoding is not as simple as one might - // naively think. Check RFC 2781 - // (http://www.ietf.org/rfc/rfc2781.txt). - // - // Normally, two subsequent bytes describe a Unicode - // character. However a special technique (called a - // surrogate pair) is used for specifying character - // values larger than 0xFFFF. - // - // A surrogate pair consists of two pseudo-characters: - // high surrogate area (0xD800-0xDBFF) - // low surrogate area (0xDC00-0xDFFF) - // - // The following formulas are used for decoding - // and encoding characters using surrogate pairs: - // - // U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF) - // U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF) - // W1 = 110110yyyyyyyyyy - // W2 = 110111xxxxxxxxxx - // - // where U is the character value, W1 is the high surrogate - // area, W2 is the low surrogate area. - - // Check for incomplete UTF-16 character. - if raw_unread < 2 { - if parser.eof { - return yaml_parser_set_reader_error(parser, - "incomplete UTF-16 character", - parser.offset, -1) - } - break inner - } - - // Get the character. - value = rune(parser.raw_buffer[parser.raw_buffer_pos+low]) + - (rune(parser.raw_buffer[parser.raw_buffer_pos+high]) << 8) - - // Check for unexpected low surrogate area. - if value&0xFC00 == 0xDC00 { - return yaml_parser_set_reader_error(parser, - "unexpected low surrogate area", - parser.offset, int(value)) - } - - // Check for a high surrogate area. - if value&0xFC00 == 0xD800 { - width = 4 - - // Check for incomplete surrogate pair. - if raw_unread < 4 { - if parser.eof { - return yaml_parser_set_reader_error(parser, - "incomplete UTF-16 surrogate pair", - parser.offset, -1) - } - break inner - } - - // Get the next character. - value2 := rune(parser.raw_buffer[parser.raw_buffer_pos+low+2]) + - (rune(parser.raw_buffer[parser.raw_buffer_pos+high+2]) << 8) - - // Check for a low surrogate area. - if value2&0xFC00 != 0xDC00 { - return yaml_parser_set_reader_error(parser, - "expected low surrogate area", - parser.offset+2, int(value2)) - } - - // Generate the value of the surrogate pair. - value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF) - } else { - width = 2 - } - - default: - panic("impossible") - } - - // Check if the character is in the allowed range: - // #x9 | #xA | #xD | [#x20-#x7E] (8 bit) - // | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit) - // | [#x10000-#x10FFFF] (32 bit) - switch { - case value == 0x09: - case value == 0x0A: - case value == 0x0D: - case value >= 0x20 && value <= 0x7E: - case value == 0x85: - case value >= 0xA0 && value <= 0xD7FF: - case value >= 0xE000 && value <= 0xFFFD: - case value >= 0x10000 && value <= 0x10FFFF: - default: - return yaml_parser_set_reader_error(parser, - "control characters are not allowed", - parser.offset, int(value)) - } - - // Move the raw pointers. - parser.raw_buffer_pos += width - parser.offset += width - - // Finally put the character into the buffer. - if value <= 0x7F { - // 0000 0000-0000 007F . 0xxxxxxx - parser.buffer[buffer_len+0] = byte(value) - buffer_len += 1 - } else if value <= 0x7FF { - // 0000 0080-0000 07FF . 110xxxxx 10xxxxxx - parser.buffer[buffer_len+0] = byte(0xC0 + (value >> 6)) - parser.buffer[buffer_len+1] = byte(0x80 + (value & 0x3F)) - buffer_len += 2 - } else if value <= 0xFFFF { - // 0000 0800-0000 FFFF . 1110xxxx 10xxxxxx 10xxxxxx - parser.buffer[buffer_len+0] = byte(0xE0 + (value >> 12)) - parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 6) & 0x3F)) - parser.buffer[buffer_len+2] = byte(0x80 + (value & 0x3F)) - buffer_len += 3 - } else { - // 0001 0000-0010 FFFF . 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx - parser.buffer[buffer_len+0] = byte(0xF0 + (value >> 18)) - parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 12) & 0x3F)) - parser.buffer[buffer_len+2] = byte(0x80 + ((value >> 6) & 0x3F)) - parser.buffer[buffer_len+3] = byte(0x80 + (value & 0x3F)) - buffer_len += 4 - } - - parser.unread++ - } - - // On EOF, put NUL into the buffer and return. - if parser.eof { - parser.buffer[buffer_len] = 0 - buffer_len++ - parser.unread++ - break - } - } - // [Go] Read the documentation of this function above. To return true, - // we need to have the given length in the buffer. Not doing that means - // every single check that calls this function to make sure the buffer - // has a given length is Go) panicking; or C) accessing invalid memory. - // This happens here due to the EOF above breaking early. - for buffer_len < length { - parser.buffer[buffer_len] = 0 - buffer_len++ - } - parser.buffer = parser.buffer[:buffer_len] - return true -} diff --git a/vendor/gopkg.in/yaml.v2/resolve.go b/vendor/gopkg.in/yaml.v2/resolve.go deleted file mode 100644 index 6c151db..0000000 --- a/vendor/gopkg.in/yaml.v2/resolve.go +++ /dev/null @@ -1,258 +0,0 @@ -package yaml - -import ( - "encoding/base64" - "math" - "regexp" - "strconv" - "strings" - "time" -) - -type resolveMapItem struct { - value interface{} - tag string -} - -var resolveTable = make([]byte, 256) -var resolveMap = make(map[string]resolveMapItem) - -func init() { - t := resolveTable - t[int('+')] = 'S' // Sign - t[int('-')] = 'S' - for _, c := range "0123456789" { - t[int(c)] = 'D' // Digit - } - for _, c := range "yYnNtTfFoO~" { - t[int(c)] = 'M' // In map - } - t[int('.')] = '.' // Float (potentially in map) - - var resolveMapList = []struct { - v interface{} - tag string - l []string - }{ - {true, yaml_BOOL_TAG, []string{"y", "Y", "yes", "Yes", "YES"}}, - {true, yaml_BOOL_TAG, []string{"true", "True", "TRUE"}}, - {true, yaml_BOOL_TAG, []string{"on", "On", "ON"}}, - {false, yaml_BOOL_TAG, []string{"n", "N", "no", "No", "NO"}}, - {false, yaml_BOOL_TAG, []string{"false", "False", "FALSE"}}, - {false, yaml_BOOL_TAG, []string{"off", "Off", "OFF"}}, - {nil, yaml_NULL_TAG, []string{"", "~", "null", "Null", "NULL"}}, - {math.NaN(), yaml_FLOAT_TAG, []string{".nan", ".NaN", ".NAN"}}, - {math.Inf(+1), yaml_FLOAT_TAG, []string{".inf", ".Inf", ".INF"}}, - {math.Inf(+1), yaml_FLOAT_TAG, []string{"+.inf", "+.Inf", "+.INF"}}, - {math.Inf(-1), yaml_FLOAT_TAG, []string{"-.inf", "-.Inf", "-.INF"}}, - {"<<", yaml_MERGE_TAG, []string{"<<"}}, - } - - m := resolveMap - for _, item := range resolveMapList { - for _, s := range item.l { - m[s] = resolveMapItem{item.v, item.tag} - } - } -} - -const longTagPrefix = "tag:yaml.org,2002:" - -func shortTag(tag string) string { - // TODO This can easily be made faster and produce less garbage. - if strings.HasPrefix(tag, longTagPrefix) { - return "!!" + tag[len(longTagPrefix):] - } - return tag -} - -func longTag(tag string) string { - if strings.HasPrefix(tag, "!!") { - return longTagPrefix + tag[2:] - } - return tag -} - -func resolvableTag(tag string) bool { - switch tag { - case "", yaml_STR_TAG, yaml_BOOL_TAG, yaml_INT_TAG, yaml_FLOAT_TAG, yaml_NULL_TAG, yaml_TIMESTAMP_TAG: - return true - } - return false -} - -var yamlStyleFloat = regexp.MustCompile(`^[-+]?[0-9]*\.?[0-9]+([eE][-+][0-9]+)?$`) - -func resolve(tag string, in string) (rtag string, out interface{}) { - if !resolvableTag(tag) { - return tag, in - } - - defer func() { - switch tag { - case "", rtag, yaml_STR_TAG, yaml_BINARY_TAG: - return - case yaml_FLOAT_TAG: - if rtag == yaml_INT_TAG { - switch v := out.(type) { - case int64: - rtag = yaml_FLOAT_TAG - out = float64(v) - return - case int: - rtag = yaml_FLOAT_TAG - out = float64(v) - return - } - } - } - failf("cannot decode %s `%s` as a %s", shortTag(rtag), in, shortTag(tag)) - }() - - // Any data is accepted as a !!str or !!binary. - // Otherwise, the prefix is enough of a hint about what it might be. - hint := byte('N') - if in != "" { - hint = resolveTable[in[0]] - } - if hint != 0 && tag != yaml_STR_TAG && tag != yaml_BINARY_TAG { - // Handle things we can lookup in a map. - if item, ok := resolveMap[in]; ok { - return item.tag, item.value - } - - // Base 60 floats are a bad idea, were dropped in YAML 1.2, and - // are purposefully unsupported here. They're still quoted on - // the way out for compatibility with other parser, though. - - switch hint { - case 'M': - // We've already checked the map above. - - case '.': - // Not in the map, so maybe a normal float. - floatv, err := strconv.ParseFloat(in, 64) - if err == nil { - return yaml_FLOAT_TAG, floatv - } - - case 'D', 'S': - // Int, float, or timestamp. - // Only try values as a timestamp if the value is unquoted or there's an explicit - // !!timestamp tag. - if tag == "" || tag == yaml_TIMESTAMP_TAG { - t, ok := parseTimestamp(in) - if ok { - return yaml_TIMESTAMP_TAG, t - } - } - - plain := strings.Replace(in, "_", "", -1) - intv, err := strconv.ParseInt(plain, 0, 64) - if err == nil { - if intv == int64(int(intv)) { - return yaml_INT_TAG, int(intv) - } else { - return yaml_INT_TAG, intv - } - } - uintv, err := strconv.ParseUint(plain, 0, 64) - if err == nil { - return yaml_INT_TAG, uintv - } - if yamlStyleFloat.MatchString(plain) { - floatv, err := strconv.ParseFloat(plain, 64) - if err == nil { - return yaml_FLOAT_TAG, floatv - } - } - if strings.HasPrefix(plain, "0b") { - intv, err := strconv.ParseInt(plain[2:], 2, 64) - if err == nil { - if intv == int64(int(intv)) { - return yaml_INT_TAG, int(intv) - } else { - return yaml_INT_TAG, intv - } - } - uintv, err := strconv.ParseUint(plain[2:], 2, 64) - if err == nil { - return yaml_INT_TAG, uintv - } - } else if strings.HasPrefix(plain, "-0b") { - intv, err := strconv.ParseInt("-" + plain[3:], 2, 64) - if err == nil { - if true || intv == int64(int(intv)) { - return yaml_INT_TAG, int(intv) - } else { - return yaml_INT_TAG, intv - } - } - } - default: - panic("resolveTable item not yet handled: " + string(rune(hint)) + " (with " + in + ")") - } - } - return yaml_STR_TAG, in -} - -// encodeBase64 encodes s as base64 that is broken up into multiple lines -// as appropriate for the resulting length. -func encodeBase64(s string) string { - const lineLen = 70 - encLen := base64.StdEncoding.EncodedLen(len(s)) - lines := encLen/lineLen + 1 - buf := make([]byte, encLen*2+lines) - in := buf[0:encLen] - out := buf[encLen:] - base64.StdEncoding.Encode(in, []byte(s)) - k := 0 - for i := 0; i < len(in); i += lineLen { - j := i + lineLen - if j > len(in) { - j = len(in) - } - k += copy(out[k:], in[i:j]) - if lines > 1 { - out[k] = '\n' - k++ - } - } - return string(out[:k]) -} - -// This is a subset of the formats allowed by the regular expression -// defined at http://yaml.org/type/timestamp.html. -var allowedTimestampFormats = []string{ - "2006-1-2T15:4:5.999999999Z07:00", // RCF3339Nano with short date fields. - "2006-1-2t15:4:5.999999999Z07:00", // RFC3339Nano with short date fields and lower-case "t". - "2006-1-2 15:4:5.999999999", // space separated with no time zone - "2006-1-2", // date only - // Notable exception: time.Parse cannot handle: "2001-12-14 21:59:43.10 -5" - // from the set of examples. -} - -// parseTimestamp parses s as a timestamp string and -// returns the timestamp and reports whether it succeeded. -// Timestamp formats are defined at http://yaml.org/type/timestamp.html -func parseTimestamp(s string) (time.Time, bool) { - // TODO write code to check all the formats supported by - // http://yaml.org/type/timestamp.html instead of using time.Parse. - - // Quick check: all date formats start with YYYY-. - i := 0 - for ; i < len(s); i++ { - if c := s[i]; c < '0' || c > '9' { - break - } - } - if i != 4 || i == len(s) || s[i] != '-' { - return time.Time{}, false - } - for _, format := range allowedTimestampFormats { - if t, err := time.Parse(format, s); err == nil { - return t, true - } - } - return time.Time{}, false -} diff --git a/vendor/gopkg.in/yaml.v2/scannerc.go b/vendor/gopkg.in/yaml.v2/scannerc.go deleted file mode 100644 index 077fd1d..0000000 --- a/vendor/gopkg.in/yaml.v2/scannerc.go +++ /dev/null @@ -1,2696 +0,0 @@ -package yaml - -import ( - "bytes" - "fmt" -) - -// Introduction -// ************ -// -// The following notes assume that you are familiar with the YAML specification -// (http://yaml.org/spec/1.2/spec.html). We mostly follow it, although in -// some cases we are less restrictive that it requires. -// -// The process of transforming a YAML stream into a sequence of events is -// divided on two steps: Scanning and Parsing. -// -// The Scanner transforms the input stream into a sequence of tokens, while the -// parser transform the sequence of tokens produced by the Scanner into a -// sequence of parsing events. -// -// The Scanner is rather clever and complicated. The Parser, on the contrary, -// is a straightforward implementation of a recursive-descendant parser (or, -// LL(1) parser, as it is usually called). -// -// Actually there are two issues of Scanning that might be called "clever", the -// rest is quite straightforward. The issues are "block collection start" and -// "simple keys". Both issues are explained below in details. -// -// Here the Scanning step is explained and implemented. We start with the list -// of all the tokens produced by the Scanner together with short descriptions. -// -// Now, tokens: -// -// STREAM-START(encoding) # The stream start. -// STREAM-END # The stream end. -// VERSION-DIRECTIVE(major,minor) # The '%YAML' directive. -// TAG-DIRECTIVE(handle,prefix) # The '%TAG' directive. -// DOCUMENT-START # '---' -// DOCUMENT-END # '...' -// BLOCK-SEQUENCE-START # Indentation increase denoting a block -// BLOCK-MAPPING-START # sequence or a block mapping. -// BLOCK-END # Indentation decrease. -// FLOW-SEQUENCE-START # '[' -// FLOW-SEQUENCE-END # ']' -// BLOCK-SEQUENCE-START # '{' -// BLOCK-SEQUENCE-END # '}' -// BLOCK-ENTRY # '-' -// FLOW-ENTRY # ',' -// KEY # '?' or nothing (simple keys). -// VALUE # ':' -// ALIAS(anchor) # '*anchor' -// ANCHOR(anchor) # '&anchor' -// TAG(handle,suffix) # '!handle!suffix' -// SCALAR(value,style) # A scalar. -// -// The following two tokens are "virtual" tokens denoting the beginning and the -// end of the stream: -// -// STREAM-START(encoding) -// STREAM-END -// -// We pass the information about the input stream encoding with the -// STREAM-START token. -// -// The next two tokens are responsible for tags: -// -// VERSION-DIRECTIVE(major,minor) -// TAG-DIRECTIVE(handle,prefix) -// -// Example: -// -// %YAML 1.1 -// %TAG ! !foo -// %TAG !yaml! tag:yaml.org,2002: -// --- -// -// The correspoding sequence of tokens: -// -// STREAM-START(utf-8) -// VERSION-DIRECTIVE(1,1) -// TAG-DIRECTIVE("!","!foo") -// TAG-DIRECTIVE("!yaml","tag:yaml.org,2002:") -// DOCUMENT-START -// STREAM-END -// -// Note that the VERSION-DIRECTIVE and TAG-DIRECTIVE tokens occupy a whole -// line. -// -// The document start and end indicators are represented by: -// -// DOCUMENT-START -// DOCUMENT-END -// -// Note that if a YAML stream contains an implicit document (without '---' -// and '...' indicators), no DOCUMENT-START and DOCUMENT-END tokens will be -// produced. -// -// In the following examples, we present whole documents together with the -// produced tokens. -// -// 1. An implicit document: -// -// 'a scalar' -// -// Tokens: -// -// STREAM-START(utf-8) -// SCALAR("a scalar",single-quoted) -// STREAM-END -// -// 2. An explicit document: -// -// --- -// 'a scalar' -// ... -// -// Tokens: -// -// STREAM-START(utf-8) -// DOCUMENT-START -// SCALAR("a scalar",single-quoted) -// DOCUMENT-END -// STREAM-END -// -// 3. Several documents in a stream: -// -// 'a scalar' -// --- -// 'another scalar' -// --- -// 'yet another scalar' -// -// Tokens: -// -// STREAM-START(utf-8) -// SCALAR("a scalar",single-quoted) -// DOCUMENT-START -// SCALAR("another scalar",single-quoted) -// DOCUMENT-START -// SCALAR("yet another scalar",single-quoted) -// STREAM-END -// -// We have already introduced the SCALAR token above. The following tokens are -// used to describe aliases, anchors, tag, and scalars: -// -// ALIAS(anchor) -// ANCHOR(anchor) -// TAG(handle,suffix) -// SCALAR(value,style) -// -// The following series of examples illustrate the usage of these tokens: -// -// 1. A recursive sequence: -// -// &A [ *A ] -// -// Tokens: -// -// STREAM-START(utf-8) -// ANCHOR("A") -// FLOW-SEQUENCE-START -// ALIAS("A") -// FLOW-SEQUENCE-END -// STREAM-END -// -// 2. A tagged scalar: -// -// !!float "3.14" # A good approximation. -// -// Tokens: -// -// STREAM-START(utf-8) -// TAG("!!","float") -// SCALAR("3.14",double-quoted) -// STREAM-END -// -// 3. Various scalar styles: -// -// --- # Implicit empty plain scalars do not produce tokens. -// --- a plain scalar -// --- 'a single-quoted scalar' -// --- "a double-quoted scalar" -// --- |- -// a literal scalar -// --- >- -// a folded -// scalar -// -// Tokens: -// -// STREAM-START(utf-8) -// DOCUMENT-START -// DOCUMENT-START -// SCALAR("a plain scalar",plain) -// DOCUMENT-START -// SCALAR("a single-quoted scalar",single-quoted) -// DOCUMENT-START -// SCALAR("a double-quoted scalar",double-quoted) -// DOCUMENT-START -// SCALAR("a literal scalar",literal) -// DOCUMENT-START -// SCALAR("a folded scalar",folded) -// STREAM-END -// -// Now it's time to review collection-related tokens. We will start with -// flow collections: -// -// FLOW-SEQUENCE-START -// FLOW-SEQUENCE-END -// FLOW-MAPPING-START -// FLOW-MAPPING-END -// FLOW-ENTRY -// KEY -// VALUE -// -// The tokens FLOW-SEQUENCE-START, FLOW-SEQUENCE-END, FLOW-MAPPING-START, and -// FLOW-MAPPING-END represent the indicators '[', ']', '{', and '}' -// correspondingly. FLOW-ENTRY represent the ',' indicator. Finally the -// indicators '?' and ':', which are used for denoting mapping keys and values, -// are represented by the KEY and VALUE tokens. -// -// The following examples show flow collections: -// -// 1. A flow sequence: -// -// [item 1, item 2, item 3] -// -// Tokens: -// -// STREAM-START(utf-8) -// FLOW-SEQUENCE-START -// SCALAR("item 1",plain) -// FLOW-ENTRY -// SCALAR("item 2",plain) -// FLOW-ENTRY -// SCALAR("item 3",plain) -// FLOW-SEQUENCE-END -// STREAM-END -// -// 2. A flow mapping: -// -// { -// a simple key: a value, # Note that the KEY token is produced. -// ? a complex key: another value, -// } -// -// Tokens: -// -// STREAM-START(utf-8) -// FLOW-MAPPING-START -// KEY -// SCALAR("a simple key",plain) -// VALUE -// SCALAR("a value",plain) -// FLOW-ENTRY -// KEY -// SCALAR("a complex key",plain) -// VALUE -// SCALAR("another value",plain) -// FLOW-ENTRY -// FLOW-MAPPING-END -// STREAM-END -// -// A simple key is a key which is not denoted by the '?' indicator. Note that -// the Scanner still produce the KEY token whenever it encounters a simple key. -// -// For scanning block collections, the following tokens are used (note that we -// repeat KEY and VALUE here): -// -// BLOCK-SEQUENCE-START -// BLOCK-MAPPING-START -// BLOCK-END -// BLOCK-ENTRY -// KEY -// VALUE -// -// The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation -// increase that precedes a block collection (cf. the INDENT token in Python). -// The token BLOCK-END denote indentation decrease that ends a block collection -// (cf. the DEDENT token in Python). However YAML has some syntax pecularities -// that makes detections of these tokens more complex. -// -// The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators -// '-', '?', and ':' correspondingly. -// -// The following examples show how the tokens BLOCK-SEQUENCE-START, -// BLOCK-MAPPING-START, and BLOCK-END are emitted by the Scanner: -// -// 1. Block sequences: -// -// - item 1 -// - item 2 -// - -// - item 3.1 -// - item 3.2 -// - -// key 1: value 1 -// key 2: value 2 -// -// Tokens: -// -// STREAM-START(utf-8) -// BLOCK-SEQUENCE-START -// BLOCK-ENTRY -// SCALAR("item 1",plain) -// BLOCK-ENTRY -// SCALAR("item 2",plain) -// BLOCK-ENTRY -// BLOCK-SEQUENCE-START -// BLOCK-ENTRY -// SCALAR("item 3.1",plain) -// BLOCK-ENTRY -// SCALAR("item 3.2",plain) -// BLOCK-END -// BLOCK-ENTRY -// BLOCK-MAPPING-START -// KEY -// SCALAR("key 1",plain) -// VALUE -// SCALAR("value 1",plain) -// KEY -// SCALAR("key 2",plain) -// VALUE -// SCALAR("value 2",plain) -// BLOCK-END -// BLOCK-END -// STREAM-END -// -// 2. Block mappings: -// -// a simple key: a value # The KEY token is produced here. -// ? a complex key -// : another value -// a mapping: -// key 1: value 1 -// key 2: value 2 -// a sequence: -// - item 1 -// - item 2 -// -// Tokens: -// -// STREAM-START(utf-8) -// BLOCK-MAPPING-START -// KEY -// SCALAR("a simple key",plain) -// VALUE -// SCALAR("a value",plain) -// KEY -// SCALAR("a complex key",plain) -// VALUE -// SCALAR("another value",plain) -// KEY -// SCALAR("a mapping",plain) -// BLOCK-MAPPING-START -// KEY -// SCALAR("key 1",plain) -// VALUE -// SCALAR("value 1",plain) -// KEY -// SCALAR("key 2",plain) -// VALUE -// SCALAR("value 2",plain) -// BLOCK-END -// KEY -// SCALAR("a sequence",plain) -// VALUE -// BLOCK-SEQUENCE-START -// BLOCK-ENTRY -// SCALAR("item 1",plain) -// BLOCK-ENTRY -// SCALAR("item 2",plain) -// BLOCK-END -// BLOCK-END -// STREAM-END -// -// YAML does not always require to start a new block collection from a new -// line. If the current line contains only '-', '?', and ':' indicators, a new -// block collection may start at the current line. The following examples -// illustrate this case: -// -// 1. Collections in a sequence: -// -// - - item 1 -// - item 2 -// - key 1: value 1 -// key 2: value 2 -// - ? complex key -// : complex value -// -// Tokens: -// -// STREAM-START(utf-8) -// BLOCK-SEQUENCE-START -// BLOCK-ENTRY -// BLOCK-SEQUENCE-START -// BLOCK-ENTRY -// SCALAR("item 1",plain) -// BLOCK-ENTRY -// SCALAR("item 2",plain) -// BLOCK-END -// BLOCK-ENTRY -// BLOCK-MAPPING-START -// KEY -// SCALAR("key 1",plain) -// VALUE -// SCALAR("value 1",plain) -// KEY -// SCALAR("key 2",plain) -// VALUE -// SCALAR("value 2",plain) -// BLOCK-END -// BLOCK-ENTRY -// BLOCK-MAPPING-START -// KEY -// SCALAR("complex key") -// VALUE -// SCALAR("complex value") -// BLOCK-END -// BLOCK-END -// STREAM-END -// -// 2. Collections in a mapping: -// -// ? a sequence -// : - item 1 -// - item 2 -// ? a mapping -// : key 1: value 1 -// key 2: value 2 -// -// Tokens: -// -// STREAM-START(utf-8) -// BLOCK-MAPPING-START -// KEY -// SCALAR("a sequence",plain) -// VALUE -// BLOCK-SEQUENCE-START -// BLOCK-ENTRY -// SCALAR("item 1",plain) -// BLOCK-ENTRY -// SCALAR("item 2",plain) -// BLOCK-END -// KEY -// SCALAR("a mapping",plain) -// VALUE -// BLOCK-MAPPING-START -// KEY -// SCALAR("key 1",plain) -// VALUE -// SCALAR("value 1",plain) -// KEY -// SCALAR("key 2",plain) -// VALUE -// SCALAR("value 2",plain) -// BLOCK-END -// BLOCK-END -// STREAM-END -// -// YAML also permits non-indented sequences if they are included into a block -// mapping. In this case, the token BLOCK-SEQUENCE-START is not produced: -// -// key: -// - item 1 # BLOCK-SEQUENCE-START is NOT produced here. -// - item 2 -// -// Tokens: -// -// STREAM-START(utf-8) -// BLOCK-MAPPING-START -// KEY -// SCALAR("key",plain) -// VALUE -// BLOCK-ENTRY -// SCALAR("item 1",plain) -// BLOCK-ENTRY -// SCALAR("item 2",plain) -// BLOCK-END -// - -// Ensure that the buffer contains the required number of characters. -// Return true on success, false on failure (reader error or memory error). -func cache(parser *yaml_parser_t, length int) bool { - // [Go] This was inlined: !cache(A, B) -> unread < B && !update(A, B) - return parser.unread >= length || yaml_parser_update_buffer(parser, length) -} - -// Advance the buffer pointer. -func skip(parser *yaml_parser_t) { - parser.mark.index++ - parser.mark.column++ - parser.unread-- - parser.buffer_pos += width(parser.buffer[parser.buffer_pos]) -} - -func skip_line(parser *yaml_parser_t) { - if is_crlf(parser.buffer, parser.buffer_pos) { - parser.mark.index += 2 - parser.mark.column = 0 - parser.mark.line++ - parser.unread -= 2 - parser.buffer_pos += 2 - } else if is_break(parser.buffer, parser.buffer_pos) { - parser.mark.index++ - parser.mark.column = 0 - parser.mark.line++ - parser.unread-- - parser.buffer_pos += width(parser.buffer[parser.buffer_pos]) - } -} - -// Copy a character to a string buffer and advance pointers. -func read(parser *yaml_parser_t, s []byte) []byte { - w := width(parser.buffer[parser.buffer_pos]) - if w == 0 { - panic("invalid character sequence") - } - if len(s) == 0 { - s = make([]byte, 0, 32) - } - if w == 1 && len(s)+w <= cap(s) { - s = s[:len(s)+1] - s[len(s)-1] = parser.buffer[parser.buffer_pos] - parser.buffer_pos++ - } else { - s = append(s, parser.buffer[parser.buffer_pos:parser.buffer_pos+w]...) - parser.buffer_pos += w - } - parser.mark.index++ - parser.mark.column++ - parser.unread-- - return s -} - -// Copy a line break character to a string buffer and advance pointers. -func read_line(parser *yaml_parser_t, s []byte) []byte { - buf := parser.buffer - pos := parser.buffer_pos - switch { - case buf[pos] == '\r' && buf[pos+1] == '\n': - // CR LF . LF - s = append(s, '\n') - parser.buffer_pos += 2 - parser.mark.index++ - parser.unread-- - case buf[pos] == '\r' || buf[pos] == '\n': - // CR|LF . LF - s = append(s, '\n') - parser.buffer_pos += 1 - case buf[pos] == '\xC2' && buf[pos+1] == '\x85': - // NEL . LF - s = append(s, '\n') - parser.buffer_pos += 2 - case buf[pos] == '\xE2' && buf[pos+1] == '\x80' && (buf[pos+2] == '\xA8' || buf[pos+2] == '\xA9'): - // LS|PS . LS|PS - s = append(s, buf[parser.buffer_pos:pos+3]...) - parser.buffer_pos += 3 - default: - return s - } - parser.mark.index++ - parser.mark.column = 0 - parser.mark.line++ - parser.unread-- - return s -} - -// Get the next token. -func yaml_parser_scan(parser *yaml_parser_t, token *yaml_token_t) bool { - // Erase the token object. - *token = yaml_token_t{} // [Go] Is this necessary? - - // No tokens after STREAM-END or error. - if parser.stream_end_produced || parser.error != yaml_NO_ERROR { - return true - } - - // Ensure that the tokens queue contains enough tokens. - if !parser.token_available { - if !yaml_parser_fetch_more_tokens(parser) { - return false - } - } - - // Fetch the next token from the queue. - *token = parser.tokens[parser.tokens_head] - parser.tokens_head++ - parser.tokens_parsed++ - parser.token_available = false - - if token.typ == yaml_STREAM_END_TOKEN { - parser.stream_end_produced = true - } - return true -} - -// Set the scanner error and return false. -func yaml_parser_set_scanner_error(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string) bool { - parser.error = yaml_SCANNER_ERROR - parser.context = context - parser.context_mark = context_mark - parser.problem = problem - parser.problem_mark = parser.mark - return false -} - -func yaml_parser_set_scanner_tag_error(parser *yaml_parser_t, directive bool, context_mark yaml_mark_t, problem string) bool { - context := "while parsing a tag" - if directive { - context = "while parsing a %TAG directive" - } - return yaml_parser_set_scanner_error(parser, context, context_mark, problem) -} - -func trace(args ...interface{}) func() { - pargs := append([]interface{}{"+++"}, args...) - fmt.Println(pargs...) - pargs = append([]interface{}{"---"}, args...) - return func() { fmt.Println(pargs...) } -} - -// Ensure that the tokens queue contains at least one token which can be -// returned to the Parser. -func yaml_parser_fetch_more_tokens(parser *yaml_parser_t) bool { - // While we need more tokens to fetch, do it. - for { - // Check if we really need to fetch more tokens. - need_more_tokens := false - - if parser.tokens_head == len(parser.tokens) { - // Queue is empty. - need_more_tokens = true - } else { - // Check if any potential simple key may occupy the head position. - if !yaml_parser_stale_simple_keys(parser) { - return false - } - - for i := range parser.simple_keys { - simple_key := &parser.simple_keys[i] - if simple_key.possible && simple_key.token_number == parser.tokens_parsed { - need_more_tokens = true - break - } - } - } - - // We are finished. - if !need_more_tokens { - break - } - // Fetch the next token. - if !yaml_parser_fetch_next_token(parser) { - return false - } - } - - parser.token_available = true - return true -} - -// The dispatcher for token fetchers. -func yaml_parser_fetch_next_token(parser *yaml_parser_t) bool { - // Ensure that the buffer is initialized. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - - // Check if we just started scanning. Fetch STREAM-START then. - if !parser.stream_start_produced { - return yaml_parser_fetch_stream_start(parser) - } - - // Eat whitespaces and comments until we reach the next token. - if !yaml_parser_scan_to_next_token(parser) { - return false - } - - // Remove obsolete potential simple keys. - if !yaml_parser_stale_simple_keys(parser) { - return false - } - - // Check the indentation level against the current column. - if !yaml_parser_unroll_indent(parser, parser.mark.column) { - return false - } - - // Ensure that the buffer contains at least 4 characters. 4 is the length - // of the longest indicators ('--- ' and '... '). - if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) { - return false - } - - // Is it the end of the stream? - if is_z(parser.buffer, parser.buffer_pos) { - return yaml_parser_fetch_stream_end(parser) - } - - // Is it a directive? - if parser.mark.column == 0 && parser.buffer[parser.buffer_pos] == '%' { - return yaml_parser_fetch_directive(parser) - } - - buf := parser.buffer - pos := parser.buffer_pos - - // Is it the document start indicator? - if parser.mark.column == 0 && buf[pos] == '-' && buf[pos+1] == '-' && buf[pos+2] == '-' && is_blankz(buf, pos+3) { - return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_START_TOKEN) - } - - // Is it the document end indicator? - if parser.mark.column == 0 && buf[pos] == '.' && buf[pos+1] == '.' && buf[pos+2] == '.' && is_blankz(buf, pos+3) { - return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_END_TOKEN) - } - - // Is it the flow sequence start indicator? - if buf[pos] == '[' { - return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_SEQUENCE_START_TOKEN) - } - - // Is it the flow mapping start indicator? - if parser.buffer[parser.buffer_pos] == '{' { - return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_MAPPING_START_TOKEN) - } - - // Is it the flow sequence end indicator? - if parser.buffer[parser.buffer_pos] == ']' { - return yaml_parser_fetch_flow_collection_end(parser, - yaml_FLOW_SEQUENCE_END_TOKEN) - } - - // Is it the flow mapping end indicator? - if parser.buffer[parser.buffer_pos] == '}' { - return yaml_parser_fetch_flow_collection_end(parser, - yaml_FLOW_MAPPING_END_TOKEN) - } - - // Is it the flow entry indicator? - if parser.buffer[parser.buffer_pos] == ',' { - return yaml_parser_fetch_flow_entry(parser) - } - - // Is it the block entry indicator? - if parser.buffer[parser.buffer_pos] == '-' && is_blankz(parser.buffer, parser.buffer_pos+1) { - return yaml_parser_fetch_block_entry(parser) - } - - // Is it the key indicator? - if parser.buffer[parser.buffer_pos] == '?' && (parser.flow_level > 0 || is_blankz(parser.buffer, parser.buffer_pos+1)) { - return yaml_parser_fetch_key(parser) - } - - // Is it the value indicator? - if parser.buffer[parser.buffer_pos] == ':' && (parser.flow_level > 0 || is_blankz(parser.buffer, parser.buffer_pos+1)) { - return yaml_parser_fetch_value(parser) - } - - // Is it an alias? - if parser.buffer[parser.buffer_pos] == '*' { - return yaml_parser_fetch_anchor(parser, yaml_ALIAS_TOKEN) - } - - // Is it an anchor? - if parser.buffer[parser.buffer_pos] == '&' { - return yaml_parser_fetch_anchor(parser, yaml_ANCHOR_TOKEN) - } - - // Is it a tag? - if parser.buffer[parser.buffer_pos] == '!' { - return yaml_parser_fetch_tag(parser) - } - - // Is it a literal scalar? - if parser.buffer[parser.buffer_pos] == '|' && parser.flow_level == 0 { - return yaml_parser_fetch_block_scalar(parser, true) - } - - // Is it a folded scalar? - if parser.buffer[parser.buffer_pos] == '>' && parser.flow_level == 0 { - return yaml_parser_fetch_block_scalar(parser, false) - } - - // Is it a single-quoted scalar? - if parser.buffer[parser.buffer_pos] == '\'' { - return yaml_parser_fetch_flow_scalar(parser, true) - } - - // Is it a double-quoted scalar? - if parser.buffer[parser.buffer_pos] == '"' { - return yaml_parser_fetch_flow_scalar(parser, false) - } - - // Is it a plain scalar? - // - // A plain scalar may start with any non-blank characters except - // - // '-', '?', ':', ',', '[', ']', '{', '}', - // '#', '&', '*', '!', '|', '>', '\'', '\"', - // '%', '@', '`'. - // - // In the block context (and, for the '-' indicator, in the flow context - // too), it may also start with the characters - // - // '-', '?', ':' - // - // if it is followed by a non-space character. - // - // The last rule is more restrictive than the specification requires. - // [Go] Make this logic more reasonable. - //switch parser.buffer[parser.buffer_pos] { - //case '-', '?', ':', ',', '?', '-', ',', ':', ']', '[', '}', '{', '&', '#', '!', '*', '>', '|', '"', '\'', '@', '%', '-', '`': - //} - if !(is_blankz(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == '-' || - parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == ':' || - parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '[' || - parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '{' || - parser.buffer[parser.buffer_pos] == '}' || parser.buffer[parser.buffer_pos] == '#' || - parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '*' || - parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '|' || - parser.buffer[parser.buffer_pos] == '>' || parser.buffer[parser.buffer_pos] == '\'' || - parser.buffer[parser.buffer_pos] == '"' || parser.buffer[parser.buffer_pos] == '%' || - parser.buffer[parser.buffer_pos] == '@' || parser.buffer[parser.buffer_pos] == '`') || - (parser.buffer[parser.buffer_pos] == '-' && !is_blank(parser.buffer, parser.buffer_pos+1)) || - (parser.flow_level == 0 && - (parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == ':') && - !is_blankz(parser.buffer, parser.buffer_pos+1)) { - return yaml_parser_fetch_plain_scalar(parser) - } - - // If we don't determine the token type so far, it is an error. - return yaml_parser_set_scanner_error(parser, - "while scanning for the next token", parser.mark, - "found character that cannot start any token") -} - -// Check the list of potential simple keys and remove the positions that -// cannot contain simple keys anymore. -func yaml_parser_stale_simple_keys(parser *yaml_parser_t) bool { - // Check for a potential simple key for each flow level. - for i := range parser.simple_keys { - simple_key := &parser.simple_keys[i] - - // The specification requires that a simple key - // - // - is limited to a single line, - // - is shorter than 1024 characters. - if simple_key.possible && (simple_key.mark.line < parser.mark.line || simple_key.mark.index+1024 < parser.mark.index) { - - // Check if the potential simple key to be removed is required. - if simple_key.required { - return yaml_parser_set_scanner_error(parser, - "while scanning a simple key", simple_key.mark, - "could not find expected ':'") - } - simple_key.possible = false - } - } - return true -} - -// Check if a simple key may start at the current position and add it if -// needed. -func yaml_parser_save_simple_key(parser *yaml_parser_t) bool { - // A simple key is required at the current position if the scanner is in - // the block context and the current column coincides with the indentation - // level. - - required := parser.flow_level == 0 && parser.indent == parser.mark.column - - // - // If the current position may start a simple key, save it. - // - if parser.simple_key_allowed { - simple_key := yaml_simple_key_t{ - possible: true, - required: required, - token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head), - } - simple_key.mark = parser.mark - - if !yaml_parser_remove_simple_key(parser) { - return false - } - parser.simple_keys[len(parser.simple_keys)-1] = simple_key - } - return true -} - -// Remove a potential simple key at the current flow level. -func yaml_parser_remove_simple_key(parser *yaml_parser_t) bool { - i := len(parser.simple_keys) - 1 - if parser.simple_keys[i].possible { - // If the key is required, it is an error. - if parser.simple_keys[i].required { - return yaml_parser_set_scanner_error(parser, - "while scanning a simple key", parser.simple_keys[i].mark, - "could not find expected ':'") - } - } - // Remove the key from the stack. - parser.simple_keys[i].possible = false - return true -} - -// Increase the flow level and resize the simple key list if needed. -func yaml_parser_increase_flow_level(parser *yaml_parser_t) bool { - // Reset the simple key on the next level. - parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{}) - - // Increase the flow level. - parser.flow_level++ - return true -} - -// Decrease the flow level. -func yaml_parser_decrease_flow_level(parser *yaml_parser_t) bool { - if parser.flow_level > 0 { - parser.flow_level-- - parser.simple_keys = parser.simple_keys[:len(parser.simple_keys)-1] - } - return true -} - -// Push the current indentation level to the stack and set the new level -// the current column is greater than the indentation level. In this case, -// append or insert the specified token into the token queue. -func yaml_parser_roll_indent(parser *yaml_parser_t, column, number int, typ yaml_token_type_t, mark yaml_mark_t) bool { - // In the flow context, do nothing. - if parser.flow_level > 0 { - return true - } - - if parser.indent < column { - // Push the current indentation level to the stack and set the new - // indentation level. - parser.indents = append(parser.indents, parser.indent) - parser.indent = column - - // Create a token and insert it into the queue. - token := yaml_token_t{ - typ: typ, - start_mark: mark, - end_mark: mark, - } - if number > -1 { - number -= parser.tokens_parsed - } - yaml_insert_token(parser, number, &token) - } - return true -} - -// Pop indentation levels from the indents stack until the current level -// becomes less or equal to the column. For each indentation level, append -// the BLOCK-END token. -func yaml_parser_unroll_indent(parser *yaml_parser_t, column int) bool { - // In the flow context, do nothing. - if parser.flow_level > 0 { - return true - } - - // Loop through the indentation levels in the stack. - for parser.indent > column { - // Create a token and append it to the queue. - token := yaml_token_t{ - typ: yaml_BLOCK_END_TOKEN, - start_mark: parser.mark, - end_mark: parser.mark, - } - yaml_insert_token(parser, -1, &token) - - // Pop the indentation level. - parser.indent = parser.indents[len(parser.indents)-1] - parser.indents = parser.indents[:len(parser.indents)-1] - } - return true -} - -// Initialize the scanner and produce the STREAM-START token. -func yaml_parser_fetch_stream_start(parser *yaml_parser_t) bool { - - // Set the initial indentation. - parser.indent = -1 - - // Initialize the simple key stack. - parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{}) - - // A simple key is allowed at the beginning of the stream. - parser.simple_key_allowed = true - - // We have started. - parser.stream_start_produced = true - - // Create the STREAM-START token and append it to the queue. - token := yaml_token_t{ - typ: yaml_STREAM_START_TOKEN, - start_mark: parser.mark, - end_mark: parser.mark, - encoding: parser.encoding, - } - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the STREAM-END token and shut down the scanner. -func yaml_parser_fetch_stream_end(parser *yaml_parser_t) bool { - - // Force new line. - if parser.mark.column != 0 { - parser.mark.column = 0 - parser.mark.line++ - } - - // Reset the indentation level. - if !yaml_parser_unroll_indent(parser, -1) { - return false - } - - // Reset simple keys. - if !yaml_parser_remove_simple_key(parser) { - return false - } - - parser.simple_key_allowed = false - - // Create the STREAM-END token and append it to the queue. - token := yaml_token_t{ - typ: yaml_STREAM_END_TOKEN, - start_mark: parser.mark, - end_mark: parser.mark, - } - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token. -func yaml_parser_fetch_directive(parser *yaml_parser_t) bool { - // Reset the indentation level. - if !yaml_parser_unroll_indent(parser, -1) { - return false - } - - // Reset simple keys. - if !yaml_parser_remove_simple_key(parser) { - return false - } - - parser.simple_key_allowed = false - - // Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. - token := yaml_token_t{} - if !yaml_parser_scan_directive(parser, &token) { - return false - } - // Append the token to the queue. - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the DOCUMENT-START or DOCUMENT-END token. -func yaml_parser_fetch_document_indicator(parser *yaml_parser_t, typ yaml_token_type_t) bool { - // Reset the indentation level. - if !yaml_parser_unroll_indent(parser, -1) { - return false - } - - // Reset simple keys. - if !yaml_parser_remove_simple_key(parser) { - return false - } - - parser.simple_key_allowed = false - - // Consume the token. - start_mark := parser.mark - - skip(parser) - skip(parser) - skip(parser) - - end_mark := parser.mark - - // Create the DOCUMENT-START or DOCUMENT-END token. - token := yaml_token_t{ - typ: typ, - start_mark: start_mark, - end_mark: end_mark, - } - // Append the token to the queue. - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token. -func yaml_parser_fetch_flow_collection_start(parser *yaml_parser_t, typ yaml_token_type_t) bool { - // The indicators '[' and '{' may start a simple key. - if !yaml_parser_save_simple_key(parser) { - return false - } - - // Increase the flow level. - if !yaml_parser_increase_flow_level(parser) { - return false - } - - // A simple key may follow the indicators '[' and '{'. - parser.simple_key_allowed = true - - // Consume the token. - start_mark := parser.mark - skip(parser) - end_mark := parser.mark - - // Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token. - token := yaml_token_t{ - typ: typ, - start_mark: start_mark, - end_mark: end_mark, - } - // Append the token to the queue. - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the FLOW-SEQUENCE-END or FLOW-MAPPING-END token. -func yaml_parser_fetch_flow_collection_end(parser *yaml_parser_t, typ yaml_token_type_t) bool { - // Reset any potential simple key on the current flow level. - if !yaml_parser_remove_simple_key(parser) { - return false - } - - // Decrease the flow level. - if !yaml_parser_decrease_flow_level(parser) { - return false - } - - // No simple keys after the indicators ']' and '}'. - parser.simple_key_allowed = false - - // Consume the token. - - start_mark := parser.mark - skip(parser) - end_mark := parser.mark - - // Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token. - token := yaml_token_t{ - typ: typ, - start_mark: start_mark, - end_mark: end_mark, - } - // Append the token to the queue. - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the FLOW-ENTRY token. -func yaml_parser_fetch_flow_entry(parser *yaml_parser_t) bool { - // Reset any potential simple keys on the current flow level. - if !yaml_parser_remove_simple_key(parser) { - return false - } - - // Simple keys are allowed after ','. - parser.simple_key_allowed = true - - // Consume the token. - start_mark := parser.mark - skip(parser) - end_mark := parser.mark - - // Create the FLOW-ENTRY token and append it to the queue. - token := yaml_token_t{ - typ: yaml_FLOW_ENTRY_TOKEN, - start_mark: start_mark, - end_mark: end_mark, - } - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the BLOCK-ENTRY token. -func yaml_parser_fetch_block_entry(parser *yaml_parser_t) bool { - // Check if the scanner is in the block context. - if parser.flow_level == 0 { - // Check if we are allowed to start a new entry. - if !parser.simple_key_allowed { - return yaml_parser_set_scanner_error(parser, "", parser.mark, - "block sequence entries are not allowed in this context") - } - // Add the BLOCK-SEQUENCE-START token if needed. - if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_SEQUENCE_START_TOKEN, parser.mark) { - return false - } - } else { - // It is an error for the '-' indicator to occur in the flow context, - // but we let the Parser detect and report about it because the Parser - // is able to point to the context. - } - - // Reset any potential simple keys on the current flow level. - if !yaml_parser_remove_simple_key(parser) { - return false - } - - // Simple keys are allowed after '-'. - parser.simple_key_allowed = true - - // Consume the token. - start_mark := parser.mark - skip(parser) - end_mark := parser.mark - - // Create the BLOCK-ENTRY token and append it to the queue. - token := yaml_token_t{ - typ: yaml_BLOCK_ENTRY_TOKEN, - start_mark: start_mark, - end_mark: end_mark, - } - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the KEY token. -func yaml_parser_fetch_key(parser *yaml_parser_t) bool { - - // In the block context, additional checks are required. - if parser.flow_level == 0 { - // Check if we are allowed to start a new key (not nessesary simple). - if !parser.simple_key_allowed { - return yaml_parser_set_scanner_error(parser, "", parser.mark, - "mapping keys are not allowed in this context") - } - // Add the BLOCK-MAPPING-START token if needed. - if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) { - return false - } - } - - // Reset any potential simple keys on the current flow level. - if !yaml_parser_remove_simple_key(parser) { - return false - } - - // Simple keys are allowed after '?' in the block context. - parser.simple_key_allowed = parser.flow_level == 0 - - // Consume the token. - start_mark := parser.mark - skip(parser) - end_mark := parser.mark - - // Create the KEY token and append it to the queue. - token := yaml_token_t{ - typ: yaml_KEY_TOKEN, - start_mark: start_mark, - end_mark: end_mark, - } - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the VALUE token. -func yaml_parser_fetch_value(parser *yaml_parser_t) bool { - - simple_key := &parser.simple_keys[len(parser.simple_keys)-1] - - // Have we found a simple key? - if simple_key.possible { - // Create the KEY token and insert it into the queue. - token := yaml_token_t{ - typ: yaml_KEY_TOKEN, - start_mark: simple_key.mark, - end_mark: simple_key.mark, - } - yaml_insert_token(parser, simple_key.token_number-parser.tokens_parsed, &token) - - // In the block context, we may need to add the BLOCK-MAPPING-START token. - if !yaml_parser_roll_indent(parser, simple_key.mark.column, - simple_key.token_number, - yaml_BLOCK_MAPPING_START_TOKEN, simple_key.mark) { - return false - } - - // Remove the simple key. - simple_key.possible = false - - // A simple key cannot follow another simple key. - parser.simple_key_allowed = false - - } else { - // The ':' indicator follows a complex key. - - // In the block context, extra checks are required. - if parser.flow_level == 0 { - - // Check if we are allowed to start a complex value. - if !parser.simple_key_allowed { - return yaml_parser_set_scanner_error(parser, "", parser.mark, - "mapping values are not allowed in this context") - } - - // Add the BLOCK-MAPPING-START token if needed. - if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) { - return false - } - } - - // Simple keys after ':' are allowed in the block context. - parser.simple_key_allowed = parser.flow_level == 0 - } - - // Consume the token. - start_mark := parser.mark - skip(parser) - end_mark := parser.mark - - // Create the VALUE token and append it to the queue. - token := yaml_token_t{ - typ: yaml_VALUE_TOKEN, - start_mark: start_mark, - end_mark: end_mark, - } - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the ALIAS or ANCHOR token. -func yaml_parser_fetch_anchor(parser *yaml_parser_t, typ yaml_token_type_t) bool { - // An anchor or an alias could be a simple key. - if !yaml_parser_save_simple_key(parser) { - return false - } - - // A simple key cannot follow an anchor or an alias. - parser.simple_key_allowed = false - - // Create the ALIAS or ANCHOR token and append it to the queue. - var token yaml_token_t - if !yaml_parser_scan_anchor(parser, &token, typ) { - return false - } - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the TAG token. -func yaml_parser_fetch_tag(parser *yaml_parser_t) bool { - // A tag could be a simple key. - if !yaml_parser_save_simple_key(parser) { - return false - } - - // A simple key cannot follow a tag. - parser.simple_key_allowed = false - - // Create the TAG token and append it to the queue. - var token yaml_token_t - if !yaml_parser_scan_tag(parser, &token) { - return false - } - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the SCALAR(...,literal) or SCALAR(...,folded) tokens. -func yaml_parser_fetch_block_scalar(parser *yaml_parser_t, literal bool) bool { - // Remove any potential simple keys. - if !yaml_parser_remove_simple_key(parser) { - return false - } - - // A simple key may follow a block scalar. - parser.simple_key_allowed = true - - // Create the SCALAR token and append it to the queue. - var token yaml_token_t - if !yaml_parser_scan_block_scalar(parser, &token, literal) { - return false - } - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the SCALAR(...,single-quoted) or SCALAR(...,double-quoted) tokens. -func yaml_parser_fetch_flow_scalar(parser *yaml_parser_t, single bool) bool { - // A plain scalar could be a simple key. - if !yaml_parser_save_simple_key(parser) { - return false - } - - // A simple key cannot follow a flow scalar. - parser.simple_key_allowed = false - - // Create the SCALAR token and append it to the queue. - var token yaml_token_t - if !yaml_parser_scan_flow_scalar(parser, &token, single) { - return false - } - yaml_insert_token(parser, -1, &token) - return true -} - -// Produce the SCALAR(...,plain) token. -func yaml_parser_fetch_plain_scalar(parser *yaml_parser_t) bool { - // A plain scalar could be a simple key. - if !yaml_parser_save_simple_key(parser) { - return false - } - - // A simple key cannot follow a flow scalar. - parser.simple_key_allowed = false - - // Create the SCALAR token and append it to the queue. - var token yaml_token_t - if !yaml_parser_scan_plain_scalar(parser, &token) { - return false - } - yaml_insert_token(parser, -1, &token) - return true -} - -// Eat whitespaces and comments until the next token is found. -func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool { - - // Until the next token is not found. - for { - // Allow the BOM mark to start a line. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - if parser.mark.column == 0 && is_bom(parser.buffer, parser.buffer_pos) { - skip(parser) - } - - // Eat whitespaces. - // Tabs are allowed: - // - in the flow context - // - in the block context, but not at the beginning of the line or - // after '-', '?', or ':' (complex value). - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - - for parser.buffer[parser.buffer_pos] == ' ' || ((parser.flow_level > 0 || !parser.simple_key_allowed) && parser.buffer[parser.buffer_pos] == '\t') { - skip(parser) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - - // Eat a comment until a line break. - if parser.buffer[parser.buffer_pos] == '#' { - for !is_breakz(parser.buffer, parser.buffer_pos) { - skip(parser) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - } - - // If it is a line break, eat it. - if is_break(parser.buffer, parser.buffer_pos) { - if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { - return false - } - skip_line(parser) - - // In the block context, a new line may start a simple key. - if parser.flow_level == 0 { - parser.simple_key_allowed = true - } - } else { - break // We have found a token. - } - } - - return true -} - -// Scan a YAML-DIRECTIVE or TAG-DIRECTIVE token. -// -// Scope: -// %YAML 1.1 # a comment \n -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -// %TAG !yaml! tag:yaml.org,2002: \n -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -// -func yaml_parser_scan_directive(parser *yaml_parser_t, token *yaml_token_t) bool { - // Eat '%'. - start_mark := parser.mark - skip(parser) - - // Scan the directive name. - var name []byte - if !yaml_parser_scan_directive_name(parser, start_mark, &name) { - return false - } - - // Is it a YAML directive? - if bytes.Equal(name, []byte("YAML")) { - // Scan the VERSION directive value. - var major, minor int8 - if !yaml_parser_scan_version_directive_value(parser, start_mark, &major, &minor) { - return false - } - end_mark := parser.mark - - // Create a VERSION-DIRECTIVE token. - *token = yaml_token_t{ - typ: yaml_VERSION_DIRECTIVE_TOKEN, - start_mark: start_mark, - end_mark: end_mark, - major: major, - minor: minor, - } - - // Is it a TAG directive? - } else if bytes.Equal(name, []byte("TAG")) { - // Scan the TAG directive value. - var handle, prefix []byte - if !yaml_parser_scan_tag_directive_value(parser, start_mark, &handle, &prefix) { - return false - } - end_mark := parser.mark - - // Create a TAG-DIRECTIVE token. - *token = yaml_token_t{ - typ: yaml_TAG_DIRECTIVE_TOKEN, - start_mark: start_mark, - end_mark: end_mark, - value: handle, - prefix: prefix, - } - - // Unknown directive. - } else { - yaml_parser_set_scanner_error(parser, "while scanning a directive", - start_mark, "found unknown directive name") - return false - } - - // Eat the rest of the line including any comments. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - - for is_blank(parser.buffer, parser.buffer_pos) { - skip(parser) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - - if parser.buffer[parser.buffer_pos] == '#' { - for !is_breakz(parser.buffer, parser.buffer_pos) { - skip(parser) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - } - - // Check if we are at the end of the line. - if !is_breakz(parser.buffer, parser.buffer_pos) { - yaml_parser_set_scanner_error(parser, "while scanning a directive", - start_mark, "did not find expected comment or line break") - return false - } - - // Eat a line break. - if is_break(parser.buffer, parser.buffer_pos) { - if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { - return false - } - skip_line(parser) - } - - return true -} - -// Scan the directive name. -// -// Scope: -// %YAML 1.1 # a comment \n -// ^^^^ -// %TAG !yaml! tag:yaml.org,2002: \n -// ^^^ -// -func yaml_parser_scan_directive_name(parser *yaml_parser_t, start_mark yaml_mark_t, name *[]byte) bool { - // Consume the directive name. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - - var s []byte - for is_alpha(parser.buffer, parser.buffer_pos) { - s = read(parser, s) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - - // Check if the name is empty. - if len(s) == 0 { - yaml_parser_set_scanner_error(parser, "while scanning a directive", - start_mark, "could not find expected directive name") - return false - } - - // Check for an blank character after the name. - if !is_blankz(parser.buffer, parser.buffer_pos) { - yaml_parser_set_scanner_error(parser, "while scanning a directive", - start_mark, "found unexpected non-alphabetical character") - return false - } - *name = s - return true -} - -// Scan the value of VERSION-DIRECTIVE. -// -// Scope: -// %YAML 1.1 # a comment \n -// ^^^^^^ -func yaml_parser_scan_version_directive_value(parser *yaml_parser_t, start_mark yaml_mark_t, major, minor *int8) bool { - // Eat whitespaces. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - for is_blank(parser.buffer, parser.buffer_pos) { - skip(parser) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - - // Consume the major version number. - if !yaml_parser_scan_version_directive_number(parser, start_mark, major) { - return false - } - - // Eat '.'. - if parser.buffer[parser.buffer_pos] != '.' { - return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", - start_mark, "did not find expected digit or '.' character") - } - - skip(parser) - - // Consume the minor version number. - if !yaml_parser_scan_version_directive_number(parser, start_mark, minor) { - return false - } - return true -} - -const max_number_length = 2 - -// Scan the version number of VERSION-DIRECTIVE. -// -// Scope: -// %YAML 1.1 # a comment \n -// ^ -// %YAML 1.1 # a comment \n -// ^ -func yaml_parser_scan_version_directive_number(parser *yaml_parser_t, start_mark yaml_mark_t, number *int8) bool { - - // Repeat while the next character is digit. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - var value, length int8 - for is_digit(parser.buffer, parser.buffer_pos) { - // Check if the number is too long. - length++ - if length > max_number_length { - return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", - start_mark, "found extremely long version number") - } - value = value*10 + int8(as_digit(parser.buffer, parser.buffer_pos)) - skip(parser) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - - // Check if the number was present. - if length == 0 { - return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive", - start_mark, "did not find expected version number") - } - *number = value - return true -} - -// Scan the value of a TAG-DIRECTIVE token. -// -// Scope: -// %TAG !yaml! tag:yaml.org,2002: \n -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -// -func yaml_parser_scan_tag_directive_value(parser *yaml_parser_t, start_mark yaml_mark_t, handle, prefix *[]byte) bool { - var handle_value, prefix_value []byte - - // Eat whitespaces. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - - for is_blank(parser.buffer, parser.buffer_pos) { - skip(parser) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - - // Scan a handle. - if !yaml_parser_scan_tag_handle(parser, true, start_mark, &handle_value) { - return false - } - - // Expect a whitespace. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - if !is_blank(parser.buffer, parser.buffer_pos) { - yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", - start_mark, "did not find expected whitespace") - return false - } - - // Eat whitespaces. - for is_blank(parser.buffer, parser.buffer_pos) { - skip(parser) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - - // Scan a prefix. - if !yaml_parser_scan_tag_uri(parser, true, nil, start_mark, &prefix_value) { - return false - } - - // Expect a whitespace or line break. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - if !is_blankz(parser.buffer, parser.buffer_pos) { - yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive", - start_mark, "did not find expected whitespace or line break") - return false - } - - *handle = handle_value - *prefix = prefix_value - return true -} - -func yaml_parser_scan_anchor(parser *yaml_parser_t, token *yaml_token_t, typ yaml_token_type_t) bool { - var s []byte - - // Eat the indicator character. - start_mark := parser.mark - skip(parser) - - // Consume the value. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - - for is_alpha(parser.buffer, parser.buffer_pos) { - s = read(parser, s) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - - end_mark := parser.mark - - /* - * Check if length of the anchor is greater than 0 and it is followed by - * a whitespace character or one of the indicators: - * - * '?', ':', ',', ']', '}', '%', '@', '`'. - */ - - if len(s) == 0 || - !(is_blankz(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == '?' || - parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == ',' || - parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '}' || - parser.buffer[parser.buffer_pos] == '%' || parser.buffer[parser.buffer_pos] == '@' || - parser.buffer[parser.buffer_pos] == '`') { - context := "while scanning an alias" - if typ == yaml_ANCHOR_TOKEN { - context = "while scanning an anchor" - } - yaml_parser_set_scanner_error(parser, context, start_mark, - "did not find expected alphabetic or numeric character") - return false - } - - // Create a token. - *token = yaml_token_t{ - typ: typ, - start_mark: start_mark, - end_mark: end_mark, - value: s, - } - - return true -} - -/* - * Scan a TAG token. - */ - -func yaml_parser_scan_tag(parser *yaml_parser_t, token *yaml_token_t) bool { - var handle, suffix []byte - - start_mark := parser.mark - - // Check if the tag is in the canonical form. - if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { - return false - } - - if parser.buffer[parser.buffer_pos+1] == '<' { - // Keep the handle as '' - - // Eat '!<' - skip(parser) - skip(parser) - - // Consume the tag value. - if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) { - return false - } - - // Check for '>' and eat it. - if parser.buffer[parser.buffer_pos] != '>' { - yaml_parser_set_scanner_error(parser, "while scanning a tag", - start_mark, "did not find the expected '>'") - return false - } - - skip(parser) - } else { - // The tag has either the '!suffix' or the '!handle!suffix' form. - - // First, try to scan a handle. - if !yaml_parser_scan_tag_handle(parser, false, start_mark, &handle) { - return false - } - - // Check if it is, indeed, handle. - if handle[0] == '!' && len(handle) > 1 && handle[len(handle)-1] == '!' { - // Scan the suffix now. - if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) { - return false - } - } else { - // It wasn't a handle after all. Scan the rest of the tag. - if !yaml_parser_scan_tag_uri(parser, false, handle, start_mark, &suffix) { - return false - } - - // Set the handle to '!'. - handle = []byte{'!'} - - // A special case: the '!' tag. Set the handle to '' and the - // suffix to '!'. - if len(suffix) == 0 { - handle, suffix = suffix, handle - } - } - } - - // Check the character which ends the tag. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - if !is_blankz(parser.buffer, parser.buffer_pos) { - yaml_parser_set_scanner_error(parser, "while scanning a tag", - start_mark, "did not find expected whitespace or line break") - return false - } - - end_mark := parser.mark - - // Create a token. - *token = yaml_token_t{ - typ: yaml_TAG_TOKEN, - start_mark: start_mark, - end_mark: end_mark, - value: handle, - suffix: suffix, - } - return true -} - -// Scan a tag handle. -func yaml_parser_scan_tag_handle(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, handle *[]byte) bool { - // Check the initial '!' character. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - if parser.buffer[parser.buffer_pos] != '!' { - yaml_parser_set_scanner_tag_error(parser, directive, - start_mark, "did not find expected '!'") - return false - } - - var s []byte - - // Copy the '!' character. - s = read(parser, s) - - // Copy all subsequent alphabetical and numerical characters. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - for is_alpha(parser.buffer, parser.buffer_pos) { - s = read(parser, s) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - - // Check if the trailing character is '!' and copy it. - if parser.buffer[parser.buffer_pos] == '!' { - s = read(parser, s) - } else { - // It's either the '!' tag or not really a tag handle. If it's a %TAG - // directive, it's an error. If it's a tag token, it must be a part of URI. - if directive && string(s) != "!" { - yaml_parser_set_scanner_tag_error(parser, directive, - start_mark, "did not find expected '!'") - return false - } - } - - *handle = s - return true -} - -// Scan a tag. -func yaml_parser_scan_tag_uri(parser *yaml_parser_t, directive bool, head []byte, start_mark yaml_mark_t, uri *[]byte) bool { - //size_t length = head ? strlen((char *)head) : 0 - var s []byte - hasTag := len(head) > 0 - - // Copy the head if needed. - // - // Note that we don't copy the leading '!' character. - if len(head) > 1 { - s = append(s, head[1:]...) - } - - // Scan the tag. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - - // The set of characters that may appear in URI is as follows: - // - // '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&', - // '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']', - // '%'. - // [Go] Convert this into more reasonable logic. - for is_alpha(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == ';' || - parser.buffer[parser.buffer_pos] == '/' || parser.buffer[parser.buffer_pos] == '?' || - parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == '@' || - parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '=' || - parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '$' || - parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '.' || - parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '~' || - parser.buffer[parser.buffer_pos] == '*' || parser.buffer[parser.buffer_pos] == '\'' || - parser.buffer[parser.buffer_pos] == '(' || parser.buffer[parser.buffer_pos] == ')' || - parser.buffer[parser.buffer_pos] == '[' || parser.buffer[parser.buffer_pos] == ']' || - parser.buffer[parser.buffer_pos] == '%' { - // Check if it is a URI-escape sequence. - if parser.buffer[parser.buffer_pos] == '%' { - if !yaml_parser_scan_uri_escapes(parser, directive, start_mark, &s) { - return false - } - } else { - s = read(parser, s) - } - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - hasTag = true - } - - if !hasTag { - yaml_parser_set_scanner_tag_error(parser, directive, - start_mark, "did not find expected tag URI") - return false - } - *uri = s - return true -} - -// Decode an URI-escape sequence corresponding to a single UTF-8 character. -func yaml_parser_scan_uri_escapes(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, s *[]byte) bool { - - // Decode the required number of characters. - w := 1024 - for w > 0 { - // Check for a URI-escaped octet. - if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) { - return false - } - - if !(parser.buffer[parser.buffer_pos] == '%' && - is_hex(parser.buffer, parser.buffer_pos+1) && - is_hex(parser.buffer, parser.buffer_pos+2)) { - return yaml_parser_set_scanner_tag_error(parser, directive, - start_mark, "did not find URI escaped octet") - } - - // Get the octet. - octet := byte((as_hex(parser.buffer, parser.buffer_pos+1) << 4) + as_hex(parser.buffer, parser.buffer_pos+2)) - - // If it is the leading octet, determine the length of the UTF-8 sequence. - if w == 1024 { - w = width(octet) - if w == 0 { - return yaml_parser_set_scanner_tag_error(parser, directive, - start_mark, "found an incorrect leading UTF-8 octet") - } - } else { - // Check if the trailing octet is correct. - if octet&0xC0 != 0x80 { - return yaml_parser_set_scanner_tag_error(parser, directive, - start_mark, "found an incorrect trailing UTF-8 octet") - } - } - - // Copy the octet and move the pointers. - *s = append(*s, octet) - skip(parser) - skip(parser) - skip(parser) - w-- - } - return true -} - -// Scan a block scalar. -func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, literal bool) bool { - // Eat the indicator '|' or '>'. - start_mark := parser.mark - skip(parser) - - // Scan the additional block scalar indicators. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - - // Check for a chomping indicator. - var chomping, increment int - if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' { - // Set the chomping method and eat the indicator. - if parser.buffer[parser.buffer_pos] == '+' { - chomping = +1 - } else { - chomping = -1 - } - skip(parser) - - // Check for an indentation indicator. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - if is_digit(parser.buffer, parser.buffer_pos) { - // Check that the indentation is greater than 0. - if parser.buffer[parser.buffer_pos] == '0' { - yaml_parser_set_scanner_error(parser, "while scanning a block scalar", - start_mark, "found an indentation indicator equal to 0") - return false - } - - // Get the indentation level and eat the indicator. - increment = as_digit(parser.buffer, parser.buffer_pos) - skip(parser) - } - - } else if is_digit(parser.buffer, parser.buffer_pos) { - // Do the same as above, but in the opposite order. - - if parser.buffer[parser.buffer_pos] == '0' { - yaml_parser_set_scanner_error(parser, "while scanning a block scalar", - start_mark, "found an indentation indicator equal to 0") - return false - } - increment = as_digit(parser.buffer, parser.buffer_pos) - skip(parser) - - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' { - if parser.buffer[parser.buffer_pos] == '+' { - chomping = +1 - } else { - chomping = -1 - } - skip(parser) - } - } - - // Eat whitespaces and comments to the end of the line. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - for is_blank(parser.buffer, parser.buffer_pos) { - skip(parser) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - if parser.buffer[parser.buffer_pos] == '#' { - for !is_breakz(parser.buffer, parser.buffer_pos) { - skip(parser) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - } - - // Check if we are at the end of the line. - if !is_breakz(parser.buffer, parser.buffer_pos) { - yaml_parser_set_scanner_error(parser, "while scanning a block scalar", - start_mark, "did not find expected comment or line break") - return false - } - - // Eat a line break. - if is_break(parser.buffer, parser.buffer_pos) { - if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { - return false - } - skip_line(parser) - } - - end_mark := parser.mark - - // Set the indentation level if it was specified. - var indent int - if increment > 0 { - if parser.indent >= 0 { - indent = parser.indent + increment - } else { - indent = increment - } - } - - // Scan the leading line breaks and determine the indentation level if needed. - var s, leading_break, trailing_breaks []byte - if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) { - return false - } - - // Scan the block scalar content. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - var leading_blank, trailing_blank bool - for parser.mark.column == indent && !is_z(parser.buffer, parser.buffer_pos) { - // We are at the beginning of a non-empty line. - - // Is it a trailing whitespace? - trailing_blank = is_blank(parser.buffer, parser.buffer_pos) - - // Check if we need to fold the leading line break. - if !literal && !leading_blank && !trailing_blank && len(leading_break) > 0 && leading_break[0] == '\n' { - // Do we need to join the lines by space? - if len(trailing_breaks) == 0 { - s = append(s, ' ') - } - } else { - s = append(s, leading_break...) - } - leading_break = leading_break[:0] - - // Append the remaining line breaks. - s = append(s, trailing_breaks...) - trailing_breaks = trailing_breaks[:0] - - // Is it a leading whitespace? - leading_blank = is_blank(parser.buffer, parser.buffer_pos) - - // Consume the current line. - for !is_breakz(parser.buffer, parser.buffer_pos) { - s = read(parser, s) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - - // Consume the line break. - if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { - return false - } - - leading_break = read_line(parser, leading_break) - - // Eat the following indentation spaces and line breaks. - if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) { - return false - } - } - - // Chomp the tail. - if chomping != -1 { - s = append(s, leading_break...) - } - if chomping == 1 { - s = append(s, trailing_breaks...) - } - - // Create a token. - *token = yaml_token_t{ - typ: yaml_SCALAR_TOKEN, - start_mark: start_mark, - end_mark: end_mark, - value: s, - style: yaml_LITERAL_SCALAR_STYLE, - } - if !literal { - token.style = yaml_FOLDED_SCALAR_STYLE - } - return true -} - -// Scan indentation spaces and line breaks for a block scalar. Determine the -// indentation level if needed. -func yaml_parser_scan_block_scalar_breaks(parser *yaml_parser_t, indent *int, breaks *[]byte, start_mark yaml_mark_t, end_mark *yaml_mark_t) bool { - *end_mark = parser.mark - - // Eat the indentation spaces and line breaks. - max_indent := 0 - for { - // Eat the indentation spaces. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - for (*indent == 0 || parser.mark.column < *indent) && is_space(parser.buffer, parser.buffer_pos) { - skip(parser) - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - if parser.mark.column > max_indent { - max_indent = parser.mark.column - } - - // Check for a tab character messing the indentation. - if (*indent == 0 || parser.mark.column < *indent) && is_tab(parser.buffer, parser.buffer_pos) { - return yaml_parser_set_scanner_error(parser, "while scanning a block scalar", - start_mark, "found a tab character where an indentation space is expected") - } - - // Have we found a non-empty line? - if !is_break(parser.buffer, parser.buffer_pos) { - break - } - - // Consume the line break. - if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { - return false - } - // [Go] Should really be returning breaks instead. - *breaks = read_line(parser, *breaks) - *end_mark = parser.mark - } - - // Determine the indentation level if needed. - if *indent == 0 { - *indent = max_indent - if *indent < parser.indent+1 { - *indent = parser.indent + 1 - } - if *indent < 1 { - *indent = 1 - } - } - return true -} - -// Scan a quoted scalar. -func yaml_parser_scan_flow_scalar(parser *yaml_parser_t, token *yaml_token_t, single bool) bool { - // Eat the left quote. - start_mark := parser.mark - skip(parser) - - // Consume the content of the quoted scalar. - var s, leading_break, trailing_breaks, whitespaces []byte - for { - // Check that there are no document indicators at the beginning of the line. - if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) { - return false - } - - if parser.mark.column == 0 && - ((parser.buffer[parser.buffer_pos+0] == '-' && - parser.buffer[parser.buffer_pos+1] == '-' && - parser.buffer[parser.buffer_pos+2] == '-') || - (parser.buffer[parser.buffer_pos+0] == '.' && - parser.buffer[parser.buffer_pos+1] == '.' && - parser.buffer[parser.buffer_pos+2] == '.')) && - is_blankz(parser.buffer, parser.buffer_pos+3) { - yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", - start_mark, "found unexpected document indicator") - return false - } - - // Check for EOF. - if is_z(parser.buffer, parser.buffer_pos) { - yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar", - start_mark, "found unexpected end of stream") - return false - } - - // Consume non-blank characters. - leading_blanks := false - for !is_blankz(parser.buffer, parser.buffer_pos) { - if single && parser.buffer[parser.buffer_pos] == '\'' && parser.buffer[parser.buffer_pos+1] == '\'' { - // Is is an escaped single quote. - s = append(s, '\'') - skip(parser) - skip(parser) - - } else if single && parser.buffer[parser.buffer_pos] == '\'' { - // It is a right single quote. - break - } else if !single && parser.buffer[parser.buffer_pos] == '"' { - // It is a right double quote. - break - - } else if !single && parser.buffer[parser.buffer_pos] == '\\' && is_break(parser.buffer, parser.buffer_pos+1) { - // It is an escaped line break. - if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) { - return false - } - skip(parser) - skip_line(parser) - leading_blanks = true - break - - } else if !single && parser.buffer[parser.buffer_pos] == '\\' { - // It is an escape sequence. - code_length := 0 - - // Check the escape character. - switch parser.buffer[parser.buffer_pos+1] { - case '0': - s = append(s, 0) - case 'a': - s = append(s, '\x07') - case 'b': - s = append(s, '\x08') - case 't', '\t': - s = append(s, '\x09') - case 'n': - s = append(s, '\x0A') - case 'v': - s = append(s, '\x0B') - case 'f': - s = append(s, '\x0C') - case 'r': - s = append(s, '\x0D') - case 'e': - s = append(s, '\x1B') - case ' ': - s = append(s, '\x20') - case '"': - s = append(s, '"') - case '\'': - s = append(s, '\'') - case '\\': - s = append(s, '\\') - case 'N': // NEL (#x85) - s = append(s, '\xC2') - s = append(s, '\x85') - case '_': // #xA0 - s = append(s, '\xC2') - s = append(s, '\xA0') - case 'L': // LS (#x2028) - s = append(s, '\xE2') - s = append(s, '\x80') - s = append(s, '\xA8') - case 'P': // PS (#x2029) - s = append(s, '\xE2') - s = append(s, '\x80') - s = append(s, '\xA9') - case 'x': - code_length = 2 - case 'u': - code_length = 4 - case 'U': - code_length = 8 - default: - yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", - start_mark, "found unknown escape character") - return false - } - - skip(parser) - skip(parser) - - // Consume an arbitrary escape code. - if code_length > 0 { - var value int - - // Scan the character value. - if parser.unread < code_length && !yaml_parser_update_buffer(parser, code_length) { - return false - } - for k := 0; k < code_length; k++ { - if !is_hex(parser.buffer, parser.buffer_pos+k) { - yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", - start_mark, "did not find expected hexdecimal number") - return false - } - value = (value << 4) + as_hex(parser.buffer, parser.buffer_pos+k) - } - - // Check the value and write the character. - if (value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF { - yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar", - start_mark, "found invalid Unicode character escape code") - return false - } - if value <= 0x7F { - s = append(s, byte(value)) - } else if value <= 0x7FF { - s = append(s, byte(0xC0+(value>>6))) - s = append(s, byte(0x80+(value&0x3F))) - } else if value <= 0xFFFF { - s = append(s, byte(0xE0+(value>>12))) - s = append(s, byte(0x80+((value>>6)&0x3F))) - s = append(s, byte(0x80+(value&0x3F))) - } else { - s = append(s, byte(0xF0+(value>>18))) - s = append(s, byte(0x80+((value>>12)&0x3F))) - s = append(s, byte(0x80+((value>>6)&0x3F))) - s = append(s, byte(0x80+(value&0x3F))) - } - - // Advance the pointer. - for k := 0; k < code_length; k++ { - skip(parser) - } - } - } else { - // It is a non-escaped non-blank character. - s = read(parser, s) - } - if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { - return false - } - } - - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - - // Check if we are at the end of the scalar. - if single { - if parser.buffer[parser.buffer_pos] == '\'' { - break - } - } else { - if parser.buffer[parser.buffer_pos] == '"' { - break - } - } - - // Consume blank characters. - for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) { - if is_blank(parser.buffer, parser.buffer_pos) { - // Consume a space or a tab character. - if !leading_blanks { - whitespaces = read(parser, whitespaces) - } else { - skip(parser) - } - } else { - if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { - return false - } - - // Check if it is a first line break. - if !leading_blanks { - whitespaces = whitespaces[:0] - leading_break = read_line(parser, leading_break) - leading_blanks = true - } else { - trailing_breaks = read_line(parser, trailing_breaks) - } - } - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - - // Join the whitespaces or fold line breaks. - if leading_blanks { - // Do we need to fold line breaks? - if len(leading_break) > 0 && leading_break[0] == '\n' { - if len(trailing_breaks) == 0 { - s = append(s, ' ') - } else { - s = append(s, trailing_breaks...) - } - } else { - s = append(s, leading_break...) - s = append(s, trailing_breaks...) - } - trailing_breaks = trailing_breaks[:0] - leading_break = leading_break[:0] - } else { - s = append(s, whitespaces...) - whitespaces = whitespaces[:0] - } - } - - // Eat the right quote. - skip(parser) - end_mark := parser.mark - - // Create a token. - *token = yaml_token_t{ - typ: yaml_SCALAR_TOKEN, - start_mark: start_mark, - end_mark: end_mark, - value: s, - style: yaml_SINGLE_QUOTED_SCALAR_STYLE, - } - if !single { - token.style = yaml_DOUBLE_QUOTED_SCALAR_STYLE - } - return true -} - -// Scan a plain scalar. -func yaml_parser_scan_plain_scalar(parser *yaml_parser_t, token *yaml_token_t) bool { - - var s, leading_break, trailing_breaks, whitespaces []byte - var leading_blanks bool - var indent = parser.indent + 1 - - start_mark := parser.mark - end_mark := parser.mark - - // Consume the content of the plain scalar. - for { - // Check for a document indicator. - if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) { - return false - } - if parser.mark.column == 0 && - ((parser.buffer[parser.buffer_pos+0] == '-' && - parser.buffer[parser.buffer_pos+1] == '-' && - parser.buffer[parser.buffer_pos+2] == '-') || - (parser.buffer[parser.buffer_pos+0] == '.' && - parser.buffer[parser.buffer_pos+1] == '.' && - parser.buffer[parser.buffer_pos+2] == '.')) && - is_blankz(parser.buffer, parser.buffer_pos+3) { - break - } - - // Check for a comment. - if parser.buffer[parser.buffer_pos] == '#' { - break - } - - // Consume non-blank characters. - for !is_blankz(parser.buffer, parser.buffer_pos) { - - // Check for indicators that may end a plain scalar. - if (parser.buffer[parser.buffer_pos] == ':' && is_blankz(parser.buffer, parser.buffer_pos+1)) || - (parser.flow_level > 0 && - (parser.buffer[parser.buffer_pos] == ',' || - parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == '[' || - parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '{' || - parser.buffer[parser.buffer_pos] == '}')) { - break - } - - // Check if we need to join whitespaces and breaks. - if leading_blanks || len(whitespaces) > 0 { - if leading_blanks { - // Do we need to fold line breaks? - if leading_break[0] == '\n' { - if len(trailing_breaks) == 0 { - s = append(s, ' ') - } else { - s = append(s, trailing_breaks...) - } - } else { - s = append(s, leading_break...) - s = append(s, trailing_breaks...) - } - trailing_breaks = trailing_breaks[:0] - leading_break = leading_break[:0] - leading_blanks = false - } else { - s = append(s, whitespaces...) - whitespaces = whitespaces[:0] - } - } - - // Copy the character. - s = read(parser, s) - - end_mark = parser.mark - if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { - return false - } - } - - // Is it the end? - if !(is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos)) { - break - } - - // Consume blank characters. - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - - for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) { - if is_blank(parser.buffer, parser.buffer_pos) { - - // Check for tab characters that abuse indentation. - if leading_blanks && parser.mark.column < indent && is_tab(parser.buffer, parser.buffer_pos) { - yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", - start_mark, "found a tab character that violates indentation") - return false - } - - // Consume a space or a tab character. - if !leading_blanks { - whitespaces = read(parser, whitespaces) - } else { - skip(parser) - } - } else { - if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) { - return false - } - - // Check if it is a first line break. - if !leading_blanks { - whitespaces = whitespaces[:0] - leading_break = read_line(parser, leading_break) - leading_blanks = true - } else { - trailing_breaks = read_line(parser, trailing_breaks) - } - } - if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) { - return false - } - } - - // Check indentation level. - if parser.flow_level == 0 && parser.mark.column < indent { - break - } - } - - // Create a token. - *token = yaml_token_t{ - typ: yaml_SCALAR_TOKEN, - start_mark: start_mark, - end_mark: end_mark, - value: s, - style: yaml_PLAIN_SCALAR_STYLE, - } - - // Note that we change the 'simple_key_allowed' flag. - if leading_blanks { - parser.simple_key_allowed = true - } - return true -} diff --git a/vendor/gopkg.in/yaml.v2/sorter.go b/vendor/gopkg.in/yaml.v2/sorter.go deleted file mode 100644 index 4c45e66..0000000 --- a/vendor/gopkg.in/yaml.v2/sorter.go +++ /dev/null @@ -1,113 +0,0 @@ -package yaml - -import ( - "reflect" - "unicode" -) - -type keyList []reflect.Value - -func (l keyList) Len() int { return len(l) } -func (l keyList) Swap(i, j int) { l[i], l[j] = l[j], l[i] } -func (l keyList) Less(i, j int) bool { - a := l[i] - b := l[j] - ak := a.Kind() - bk := b.Kind() - for (ak == reflect.Interface || ak == reflect.Ptr) && !a.IsNil() { - a = a.Elem() - ak = a.Kind() - } - for (bk == reflect.Interface || bk == reflect.Ptr) && !b.IsNil() { - b = b.Elem() - bk = b.Kind() - } - af, aok := keyFloat(a) - bf, bok := keyFloat(b) - if aok && bok { - if af != bf { - return af < bf - } - if ak != bk { - return ak < bk - } - return numLess(a, b) - } - if ak != reflect.String || bk != reflect.String { - return ak < bk - } - ar, br := []rune(a.String()), []rune(b.String()) - for i := 0; i < len(ar) && i < len(br); i++ { - if ar[i] == br[i] { - continue - } - al := unicode.IsLetter(ar[i]) - bl := unicode.IsLetter(br[i]) - if al && bl { - return ar[i] < br[i] - } - if al || bl { - return bl - } - var ai, bi int - var an, bn int64 - if ar[i] == '0' || br[i] == '0' { - for j := i-1; j >= 0 && unicode.IsDigit(ar[j]); j-- { - if ar[j] != '0' { - an = 1 - bn = 1 - break - } - } - } - for ai = i; ai < len(ar) && unicode.IsDigit(ar[ai]); ai++ { - an = an*10 + int64(ar[ai]-'0') - } - for bi = i; bi < len(br) && unicode.IsDigit(br[bi]); bi++ { - bn = bn*10 + int64(br[bi]-'0') - } - if an != bn { - return an < bn - } - if ai != bi { - return ai < bi - } - return ar[i] < br[i] - } - return len(ar) < len(br) -} - -// keyFloat returns a float value for v if it is a number/bool -// and whether it is a number/bool or not. -func keyFloat(v reflect.Value) (f float64, ok bool) { - switch v.Kind() { - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - return float64(v.Int()), true - case reflect.Float32, reflect.Float64: - return v.Float(), true - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: - return float64(v.Uint()), true - case reflect.Bool: - if v.Bool() { - return 1, true - } - return 0, true - } - return 0, false -} - -// numLess returns whether a < b. -// a and b must necessarily have the same kind. -func numLess(a, b reflect.Value) bool { - switch a.Kind() { - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - return a.Int() < b.Int() - case reflect.Float32, reflect.Float64: - return a.Float() < b.Float() - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: - return a.Uint() < b.Uint() - case reflect.Bool: - return !a.Bool() && b.Bool() - } - panic("not a number") -} diff --git a/vendor/gopkg.in/yaml.v2/writerc.go b/vendor/gopkg.in/yaml.v2/writerc.go deleted file mode 100644 index a2dde60..0000000 --- a/vendor/gopkg.in/yaml.v2/writerc.go +++ /dev/null @@ -1,26 +0,0 @@ -package yaml - -// Set the writer error and return false. -func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool { - emitter.error = yaml_WRITER_ERROR - emitter.problem = problem - return false -} - -// Flush the output buffer. -func yaml_emitter_flush(emitter *yaml_emitter_t) bool { - if emitter.write_handler == nil { - panic("write handler not set") - } - - // Check if the buffer is empty. - if emitter.buffer_pos == 0 { - return true - } - - if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil { - return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error()) - } - emitter.buffer_pos = 0 - return true -} diff --git a/vendor/gopkg.in/yaml.v2/yaml.go b/vendor/gopkg.in/yaml.v2/yaml.go deleted file mode 100644 index de85aa4..0000000 --- a/vendor/gopkg.in/yaml.v2/yaml.go +++ /dev/null @@ -1,466 +0,0 @@ -// Package yaml implements YAML support for the Go language. -// -// Source code and other details for the project are available at GitHub: -// -// https://github.com/go-yaml/yaml -// -package yaml - -import ( - "errors" - "fmt" - "io" - "reflect" - "strings" - "sync" -) - -// MapSlice encodes and decodes as a YAML map. -// The order of keys is preserved when encoding and decoding. -type MapSlice []MapItem - -// MapItem is an item in a MapSlice. -type MapItem struct { - Key, Value interface{} -} - -// The Unmarshaler interface may be implemented by types to customize their -// behavior when being unmarshaled from a YAML document. The UnmarshalYAML -// method receives a function that may be called to unmarshal the original -// YAML value into a field or variable. It is safe to call the unmarshal -// function parameter more than once if necessary. -type Unmarshaler interface { - UnmarshalYAML(unmarshal func(interface{}) error) error -} - -// The Marshaler interface may be implemented by types to customize their -// behavior when being marshaled into a YAML document. The returned value -// is marshaled in place of the original value implementing Marshaler. -// -// If an error is returned by MarshalYAML, the marshaling procedure stops -// and returns with the provided error. -type Marshaler interface { - MarshalYAML() (interface{}, error) -} - -// Unmarshal decodes the first document found within the in byte slice -// and assigns decoded values into the out value. -// -// Maps and pointers (to a struct, string, int, etc) are accepted as out -// values. If an internal pointer within a struct is not initialized, -// the yaml package will initialize it if necessary for unmarshalling -// the provided data. The out parameter must not be nil. -// -// The type of the decoded values should be compatible with the respective -// values in out. If one or more values cannot be decoded due to a type -// mismatches, decoding continues partially until the end of the YAML -// content, and a *yaml.TypeError is returned with details for all -// missed values. -// -// Struct fields are only unmarshalled if they are exported (have an -// upper case first letter), and are unmarshalled using the field name -// lowercased as the default key. Custom keys may be defined via the -// "yaml" name in the field tag: the content preceding the first comma -// is used as the key, and the following comma-separated options are -// used to tweak the marshalling process (see Marshal). -// Conflicting names result in a runtime error. -// -// For example: -// -// type T struct { -// F int `yaml:"a,omitempty"` -// B int -// } -// var t T -// yaml.Unmarshal([]byte("a: 1\nb: 2"), &t) -// -// See the documentation of Marshal for the format of tags and a list of -// supported tag options. -// -func Unmarshal(in []byte, out interface{}) (err error) { - return unmarshal(in, out, false) -} - -// UnmarshalStrict is like Unmarshal except that any fields that are found -// in the data that do not have corresponding struct members, or mapping -// keys that are duplicates, will result in -// an error. -func UnmarshalStrict(in []byte, out interface{}) (err error) { - return unmarshal(in, out, true) -} - -// A Decorder reads and decodes YAML values from an input stream. -type Decoder struct { - strict bool - parser *parser -} - -// NewDecoder returns a new decoder that reads from r. -// -// The decoder introduces its own buffering and may read -// data from r beyond the YAML values requested. -func NewDecoder(r io.Reader) *Decoder { - return &Decoder{ - parser: newParserFromReader(r), - } -} - -// SetStrict sets whether strict decoding behaviour is enabled when -// decoding items in the data (see UnmarshalStrict). By default, decoding is not strict. -func (dec *Decoder) SetStrict(strict bool) { - dec.strict = strict -} - -// Decode reads the next YAML-encoded value from its input -// and stores it in the value pointed to by v. -// -// See the documentation for Unmarshal for details about the -// conversion of YAML into a Go value. -func (dec *Decoder) Decode(v interface{}) (err error) { - d := newDecoder(dec.strict) - defer handleErr(&err) - node := dec.parser.parse() - if node == nil { - return io.EOF - } - out := reflect.ValueOf(v) - if out.Kind() == reflect.Ptr && !out.IsNil() { - out = out.Elem() - } - d.unmarshal(node, out) - if len(d.terrors) > 0 { - return &TypeError{d.terrors} - } - return nil -} - -func unmarshal(in []byte, out interface{}, strict bool) (err error) { - defer handleErr(&err) - d := newDecoder(strict) - p := newParser(in) - defer p.destroy() - node := p.parse() - if node != nil { - v := reflect.ValueOf(out) - if v.Kind() == reflect.Ptr && !v.IsNil() { - v = v.Elem() - } - d.unmarshal(node, v) - } - if len(d.terrors) > 0 { - return &TypeError{d.terrors} - } - return nil -} - -// Marshal serializes the value provided into a YAML document. The structure -// of the generated document will reflect the structure of the value itself. -// Maps and pointers (to struct, string, int, etc) are accepted as the in value. -// -// Struct fields are only marshalled if they are exported (have an upper case -// first letter), and are marshalled using the field name lowercased as the -// default key. Custom keys may be defined via the "yaml" name in the field -// tag: the content preceding the first comma is used as the key, and the -// following comma-separated options are used to tweak the marshalling process. -// Conflicting names result in a runtime error. -// -// The field tag format accepted is: -// -// `(...) yaml:"[][,[,]]" (...)` -// -// The following flags are currently supported: -// -// omitempty Only include the field if it's not set to the zero -// value for the type or to empty slices or maps. -// Zero valued structs will be omitted if all their public -// fields are zero, unless they implement an IsZero -// method (see the IsZeroer interface type), in which -// case the field will be included if that method returns true. -// -// flow Marshal using a flow style (useful for structs, -// sequences and maps). -// -// inline Inline the field, which must be a struct or a map, -// causing all of its fields or keys to be processed as if -// they were part of the outer struct. For maps, keys must -// not conflict with the yaml keys of other struct fields. -// -// In addition, if the key is "-", the field is ignored. -// -// For example: -// -// type T struct { -// F int `yaml:"a,omitempty"` -// B int -// } -// yaml.Marshal(&T{B: 2}) // Returns "b: 2\n" -// yaml.Marshal(&T{F: 1}} // Returns "a: 1\nb: 0\n" -// -func Marshal(in interface{}) (out []byte, err error) { - defer handleErr(&err) - e := newEncoder() - defer e.destroy() - e.marshalDoc("", reflect.ValueOf(in)) - e.finish() - out = e.out - return -} - -// An Encoder writes YAML values to an output stream. -type Encoder struct { - encoder *encoder -} - -// NewEncoder returns a new encoder that writes to w. -// The Encoder should be closed after use to flush all data -// to w. -func NewEncoder(w io.Writer) *Encoder { - return &Encoder{ - encoder: newEncoderWithWriter(w), - } -} - -// Encode writes the YAML encoding of v to the stream. -// If multiple items are encoded to the stream, the -// second and subsequent document will be preceded -// with a "---" document separator, but the first will not. -// -// See the documentation for Marshal for details about the conversion of Go -// values to YAML. -func (e *Encoder) Encode(v interface{}) (err error) { - defer handleErr(&err) - e.encoder.marshalDoc("", reflect.ValueOf(v)) - return nil -} - -// Close closes the encoder by writing any remaining data. -// It does not write a stream terminating string "...". -func (e *Encoder) Close() (err error) { - defer handleErr(&err) - e.encoder.finish() - return nil -} - -func handleErr(err *error) { - if v := recover(); v != nil { - if e, ok := v.(yamlError); ok { - *err = e.err - } else { - panic(v) - } - } -} - -type yamlError struct { - err error -} - -func fail(err error) { - panic(yamlError{err}) -} - -func failf(format string, args ...interface{}) { - panic(yamlError{fmt.Errorf("yaml: "+format, args...)}) -} - -// A TypeError is returned by Unmarshal when one or more fields in -// the YAML document cannot be properly decoded into the requested -// types. When this error is returned, the value is still -// unmarshaled partially. -type TypeError struct { - Errors []string -} - -func (e *TypeError) Error() string { - return fmt.Sprintf("yaml: unmarshal errors:\n %s", strings.Join(e.Errors, "\n ")) -} - -// -------------------------------------------------------------------------- -// Maintain a mapping of keys to structure field indexes - -// The code in this section was copied from mgo/bson. - -// structInfo holds details for the serialization of fields of -// a given struct. -type structInfo struct { - FieldsMap map[string]fieldInfo - FieldsList []fieldInfo - - // InlineMap is the number of the field in the struct that - // contains an ,inline map, or -1 if there's none. - InlineMap int -} - -type fieldInfo struct { - Key string - Num int - OmitEmpty bool - Flow bool - // Id holds the unique field identifier, so we can cheaply - // check for field duplicates without maintaining an extra map. - Id int - - // Inline holds the field index if the field is part of an inlined struct. - Inline []int -} - -var structMap = make(map[reflect.Type]*structInfo) -var fieldMapMutex sync.RWMutex - -func getStructInfo(st reflect.Type) (*structInfo, error) { - fieldMapMutex.RLock() - sinfo, found := structMap[st] - fieldMapMutex.RUnlock() - if found { - return sinfo, nil - } - - n := st.NumField() - fieldsMap := make(map[string]fieldInfo) - fieldsList := make([]fieldInfo, 0, n) - inlineMap := -1 - for i := 0; i != n; i++ { - field := st.Field(i) - if field.PkgPath != "" && !field.Anonymous { - continue // Private field - } - - info := fieldInfo{Num: i} - - tag := field.Tag.Get("yaml") - if tag == "" && strings.Index(string(field.Tag), ":") < 0 { - tag = string(field.Tag) - } - if tag == "-" { - continue - } - - inline := false - fields := strings.Split(tag, ",") - if len(fields) > 1 { - for _, flag := range fields[1:] { - switch flag { - case "omitempty": - info.OmitEmpty = true - case "flow": - info.Flow = true - case "inline": - inline = true - default: - return nil, errors.New(fmt.Sprintf("Unsupported flag %q in tag %q of type %s", flag, tag, st)) - } - } - tag = fields[0] - } - - if inline { - switch field.Type.Kind() { - case reflect.Map: - if inlineMap >= 0 { - return nil, errors.New("Multiple ,inline maps in struct " + st.String()) - } - if field.Type.Key() != reflect.TypeOf("") { - return nil, errors.New("Option ,inline needs a map with string keys in struct " + st.String()) - } - inlineMap = info.Num - case reflect.Struct: - sinfo, err := getStructInfo(field.Type) - if err != nil { - return nil, err - } - for _, finfo := range sinfo.FieldsList { - if _, found := fieldsMap[finfo.Key]; found { - msg := "Duplicated key '" + finfo.Key + "' in struct " + st.String() - return nil, errors.New(msg) - } - if finfo.Inline == nil { - finfo.Inline = []int{i, finfo.Num} - } else { - finfo.Inline = append([]int{i}, finfo.Inline...) - } - finfo.Id = len(fieldsList) - fieldsMap[finfo.Key] = finfo - fieldsList = append(fieldsList, finfo) - } - default: - //return nil, errors.New("Option ,inline needs a struct value or map field") - return nil, errors.New("Option ,inline needs a struct value field") - } - continue - } - - if tag != "" { - info.Key = tag - } else { - info.Key = strings.ToLower(field.Name) - } - - if _, found = fieldsMap[info.Key]; found { - msg := "Duplicated key '" + info.Key + "' in struct " + st.String() - return nil, errors.New(msg) - } - - info.Id = len(fieldsList) - fieldsList = append(fieldsList, info) - fieldsMap[info.Key] = info - } - - sinfo = &structInfo{ - FieldsMap: fieldsMap, - FieldsList: fieldsList, - InlineMap: inlineMap, - } - - fieldMapMutex.Lock() - structMap[st] = sinfo - fieldMapMutex.Unlock() - return sinfo, nil -} - -// IsZeroer is used to check whether an object is zero to -// determine whether it should be omitted when marshaling -// with the omitempty flag. One notable implementation -// is time.Time. -type IsZeroer interface { - IsZero() bool -} - -func isZero(v reflect.Value) bool { - kind := v.Kind() - if z, ok := v.Interface().(IsZeroer); ok { - if (kind == reflect.Ptr || kind == reflect.Interface) && v.IsNil() { - return true - } - return z.IsZero() - } - switch kind { - case reflect.String: - return len(v.String()) == 0 - case reflect.Interface, reflect.Ptr: - return v.IsNil() - case reflect.Slice: - return v.Len() == 0 - case reflect.Map: - return v.Len() == 0 - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - return v.Int() == 0 - case reflect.Float32, reflect.Float64: - return v.Float() == 0 - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: - return v.Uint() == 0 - case reflect.Bool: - return !v.Bool() - case reflect.Struct: - vt := v.Type() - for i := v.NumField() - 1; i >= 0; i-- { - if vt.Field(i).PkgPath != "" { - continue // Private field - } - if !isZero(v.Field(i)) { - return false - } - } - return true - } - return false -} diff --git a/vendor/gopkg.in/yaml.v2/yamlh.go b/vendor/gopkg.in/yaml.v2/yamlh.go deleted file mode 100644 index e25cee5..0000000 --- a/vendor/gopkg.in/yaml.v2/yamlh.go +++ /dev/null @@ -1,738 +0,0 @@ -package yaml - -import ( - "fmt" - "io" -) - -// The version directive data. -type yaml_version_directive_t struct { - major int8 // The major version number. - minor int8 // The minor version number. -} - -// The tag directive data. -type yaml_tag_directive_t struct { - handle []byte // The tag handle. - prefix []byte // The tag prefix. -} - -type yaml_encoding_t int - -// The stream encoding. -const ( - // Let the parser choose the encoding. - yaml_ANY_ENCODING yaml_encoding_t = iota - - yaml_UTF8_ENCODING // The default UTF-8 encoding. - yaml_UTF16LE_ENCODING // The UTF-16-LE encoding with BOM. - yaml_UTF16BE_ENCODING // The UTF-16-BE encoding with BOM. -) - -type yaml_break_t int - -// Line break types. -const ( - // Let the parser choose the break type. - yaml_ANY_BREAK yaml_break_t = iota - - yaml_CR_BREAK // Use CR for line breaks (Mac style). - yaml_LN_BREAK // Use LN for line breaks (Unix style). - yaml_CRLN_BREAK // Use CR LN for line breaks (DOS style). -) - -type yaml_error_type_t int - -// Many bad things could happen with the parser and emitter. -const ( - // No error is produced. - yaml_NO_ERROR yaml_error_type_t = iota - - yaml_MEMORY_ERROR // Cannot allocate or reallocate a block of memory. - yaml_READER_ERROR // Cannot read or decode the input stream. - yaml_SCANNER_ERROR // Cannot scan the input stream. - yaml_PARSER_ERROR // Cannot parse the input stream. - yaml_COMPOSER_ERROR // Cannot compose a YAML document. - yaml_WRITER_ERROR // Cannot write to the output stream. - yaml_EMITTER_ERROR // Cannot emit a YAML stream. -) - -// The pointer position. -type yaml_mark_t struct { - index int // The position index. - line int // The position line. - column int // The position column. -} - -// Node Styles - -type yaml_style_t int8 - -type yaml_scalar_style_t yaml_style_t - -// Scalar styles. -const ( - // Let the emitter choose the style. - yaml_ANY_SCALAR_STYLE yaml_scalar_style_t = iota - - yaml_PLAIN_SCALAR_STYLE // The plain scalar style. - yaml_SINGLE_QUOTED_SCALAR_STYLE // The single-quoted scalar style. - yaml_DOUBLE_QUOTED_SCALAR_STYLE // The double-quoted scalar style. - yaml_LITERAL_SCALAR_STYLE // The literal scalar style. - yaml_FOLDED_SCALAR_STYLE // The folded scalar style. -) - -type yaml_sequence_style_t yaml_style_t - -// Sequence styles. -const ( - // Let the emitter choose the style. - yaml_ANY_SEQUENCE_STYLE yaml_sequence_style_t = iota - - yaml_BLOCK_SEQUENCE_STYLE // The block sequence style. - yaml_FLOW_SEQUENCE_STYLE // The flow sequence style. -) - -type yaml_mapping_style_t yaml_style_t - -// Mapping styles. -const ( - // Let the emitter choose the style. - yaml_ANY_MAPPING_STYLE yaml_mapping_style_t = iota - - yaml_BLOCK_MAPPING_STYLE // The block mapping style. - yaml_FLOW_MAPPING_STYLE // The flow mapping style. -) - -// Tokens - -type yaml_token_type_t int - -// Token types. -const ( - // An empty token. - yaml_NO_TOKEN yaml_token_type_t = iota - - yaml_STREAM_START_TOKEN // A STREAM-START token. - yaml_STREAM_END_TOKEN // A STREAM-END token. - - yaml_VERSION_DIRECTIVE_TOKEN // A VERSION-DIRECTIVE token. - yaml_TAG_DIRECTIVE_TOKEN // A TAG-DIRECTIVE token. - yaml_DOCUMENT_START_TOKEN // A DOCUMENT-START token. - yaml_DOCUMENT_END_TOKEN // A DOCUMENT-END token. - - yaml_BLOCK_SEQUENCE_START_TOKEN // A BLOCK-SEQUENCE-START token. - yaml_BLOCK_MAPPING_START_TOKEN // A BLOCK-SEQUENCE-END token. - yaml_BLOCK_END_TOKEN // A BLOCK-END token. - - yaml_FLOW_SEQUENCE_START_TOKEN // A FLOW-SEQUENCE-START token. - yaml_FLOW_SEQUENCE_END_TOKEN // A FLOW-SEQUENCE-END token. - yaml_FLOW_MAPPING_START_TOKEN // A FLOW-MAPPING-START token. - yaml_FLOW_MAPPING_END_TOKEN // A FLOW-MAPPING-END token. - - yaml_BLOCK_ENTRY_TOKEN // A BLOCK-ENTRY token. - yaml_FLOW_ENTRY_TOKEN // A FLOW-ENTRY token. - yaml_KEY_TOKEN // A KEY token. - yaml_VALUE_TOKEN // A VALUE token. - - yaml_ALIAS_TOKEN // An ALIAS token. - yaml_ANCHOR_TOKEN // An ANCHOR token. - yaml_TAG_TOKEN // A TAG token. - yaml_SCALAR_TOKEN // A SCALAR token. -) - -func (tt yaml_token_type_t) String() string { - switch tt { - case yaml_NO_TOKEN: - return "yaml_NO_TOKEN" - case yaml_STREAM_START_TOKEN: - return "yaml_STREAM_START_TOKEN" - case yaml_STREAM_END_TOKEN: - return "yaml_STREAM_END_TOKEN" - case yaml_VERSION_DIRECTIVE_TOKEN: - return "yaml_VERSION_DIRECTIVE_TOKEN" - case yaml_TAG_DIRECTIVE_TOKEN: - return "yaml_TAG_DIRECTIVE_TOKEN" - case yaml_DOCUMENT_START_TOKEN: - return "yaml_DOCUMENT_START_TOKEN" - case yaml_DOCUMENT_END_TOKEN: - return "yaml_DOCUMENT_END_TOKEN" - case yaml_BLOCK_SEQUENCE_START_TOKEN: - return "yaml_BLOCK_SEQUENCE_START_TOKEN" - case yaml_BLOCK_MAPPING_START_TOKEN: - return "yaml_BLOCK_MAPPING_START_TOKEN" - case yaml_BLOCK_END_TOKEN: - return "yaml_BLOCK_END_TOKEN" - case yaml_FLOW_SEQUENCE_START_TOKEN: - return "yaml_FLOW_SEQUENCE_START_TOKEN" - case yaml_FLOW_SEQUENCE_END_TOKEN: - return "yaml_FLOW_SEQUENCE_END_TOKEN" - case yaml_FLOW_MAPPING_START_TOKEN: - return "yaml_FLOW_MAPPING_START_TOKEN" - case yaml_FLOW_MAPPING_END_TOKEN: - return "yaml_FLOW_MAPPING_END_TOKEN" - case yaml_BLOCK_ENTRY_TOKEN: - return "yaml_BLOCK_ENTRY_TOKEN" - case yaml_FLOW_ENTRY_TOKEN: - return "yaml_FLOW_ENTRY_TOKEN" - case yaml_KEY_TOKEN: - return "yaml_KEY_TOKEN" - case yaml_VALUE_TOKEN: - return "yaml_VALUE_TOKEN" - case yaml_ALIAS_TOKEN: - return "yaml_ALIAS_TOKEN" - case yaml_ANCHOR_TOKEN: - return "yaml_ANCHOR_TOKEN" - case yaml_TAG_TOKEN: - return "yaml_TAG_TOKEN" - case yaml_SCALAR_TOKEN: - return "yaml_SCALAR_TOKEN" - } - return "" -} - -// The token structure. -type yaml_token_t struct { - // The token type. - typ yaml_token_type_t - - // The start/end of the token. - start_mark, end_mark yaml_mark_t - - // The stream encoding (for yaml_STREAM_START_TOKEN). - encoding yaml_encoding_t - - // The alias/anchor/scalar value or tag/tag directive handle - // (for yaml_ALIAS_TOKEN, yaml_ANCHOR_TOKEN, yaml_SCALAR_TOKEN, yaml_TAG_TOKEN, yaml_TAG_DIRECTIVE_TOKEN). - value []byte - - // The tag suffix (for yaml_TAG_TOKEN). - suffix []byte - - // The tag directive prefix (for yaml_TAG_DIRECTIVE_TOKEN). - prefix []byte - - // The scalar style (for yaml_SCALAR_TOKEN). - style yaml_scalar_style_t - - // The version directive major/minor (for yaml_VERSION_DIRECTIVE_TOKEN). - major, minor int8 -} - -// Events - -type yaml_event_type_t int8 - -// Event types. -const ( - // An empty event. - yaml_NO_EVENT yaml_event_type_t = iota - - yaml_STREAM_START_EVENT // A STREAM-START event. - yaml_STREAM_END_EVENT // A STREAM-END event. - yaml_DOCUMENT_START_EVENT // A DOCUMENT-START event. - yaml_DOCUMENT_END_EVENT // A DOCUMENT-END event. - yaml_ALIAS_EVENT // An ALIAS event. - yaml_SCALAR_EVENT // A SCALAR event. - yaml_SEQUENCE_START_EVENT // A SEQUENCE-START event. - yaml_SEQUENCE_END_EVENT // A SEQUENCE-END event. - yaml_MAPPING_START_EVENT // A MAPPING-START event. - yaml_MAPPING_END_EVENT // A MAPPING-END event. -) - -var eventStrings = []string{ - yaml_NO_EVENT: "none", - yaml_STREAM_START_EVENT: "stream start", - yaml_STREAM_END_EVENT: "stream end", - yaml_DOCUMENT_START_EVENT: "document start", - yaml_DOCUMENT_END_EVENT: "document end", - yaml_ALIAS_EVENT: "alias", - yaml_SCALAR_EVENT: "scalar", - yaml_SEQUENCE_START_EVENT: "sequence start", - yaml_SEQUENCE_END_EVENT: "sequence end", - yaml_MAPPING_START_EVENT: "mapping start", - yaml_MAPPING_END_EVENT: "mapping end", -} - -func (e yaml_event_type_t) String() string { - if e < 0 || int(e) >= len(eventStrings) { - return fmt.Sprintf("unknown event %d", e) - } - return eventStrings[e] -} - -// The event structure. -type yaml_event_t struct { - - // The event type. - typ yaml_event_type_t - - // The start and end of the event. - start_mark, end_mark yaml_mark_t - - // The document encoding (for yaml_STREAM_START_EVENT). - encoding yaml_encoding_t - - // The version directive (for yaml_DOCUMENT_START_EVENT). - version_directive *yaml_version_directive_t - - // The list of tag directives (for yaml_DOCUMENT_START_EVENT). - tag_directives []yaml_tag_directive_t - - // The anchor (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_ALIAS_EVENT). - anchor []byte - - // The tag (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT). - tag []byte - - // The scalar value (for yaml_SCALAR_EVENT). - value []byte - - // Is the document start/end indicator implicit, or the tag optional? - // (for yaml_DOCUMENT_START_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_SCALAR_EVENT). - implicit bool - - // Is the tag optional for any non-plain style? (for yaml_SCALAR_EVENT). - quoted_implicit bool - - // The style (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT). - style yaml_style_t -} - -func (e *yaml_event_t) scalar_style() yaml_scalar_style_t { return yaml_scalar_style_t(e.style) } -func (e *yaml_event_t) sequence_style() yaml_sequence_style_t { return yaml_sequence_style_t(e.style) } -func (e *yaml_event_t) mapping_style() yaml_mapping_style_t { return yaml_mapping_style_t(e.style) } - -// Nodes - -const ( - yaml_NULL_TAG = "tag:yaml.org,2002:null" // The tag !!null with the only possible value: null. - yaml_BOOL_TAG = "tag:yaml.org,2002:bool" // The tag !!bool with the values: true and false. - yaml_STR_TAG = "tag:yaml.org,2002:str" // The tag !!str for string values. - yaml_INT_TAG = "tag:yaml.org,2002:int" // The tag !!int for integer values. - yaml_FLOAT_TAG = "tag:yaml.org,2002:float" // The tag !!float for float values. - yaml_TIMESTAMP_TAG = "tag:yaml.org,2002:timestamp" // The tag !!timestamp for date and time values. - - yaml_SEQ_TAG = "tag:yaml.org,2002:seq" // The tag !!seq is used to denote sequences. - yaml_MAP_TAG = "tag:yaml.org,2002:map" // The tag !!map is used to denote mapping. - - // Not in original libyaml. - yaml_BINARY_TAG = "tag:yaml.org,2002:binary" - yaml_MERGE_TAG = "tag:yaml.org,2002:merge" - - yaml_DEFAULT_SCALAR_TAG = yaml_STR_TAG // The default scalar tag is !!str. - yaml_DEFAULT_SEQUENCE_TAG = yaml_SEQ_TAG // The default sequence tag is !!seq. - yaml_DEFAULT_MAPPING_TAG = yaml_MAP_TAG // The default mapping tag is !!map. -) - -type yaml_node_type_t int - -// Node types. -const ( - // An empty node. - yaml_NO_NODE yaml_node_type_t = iota - - yaml_SCALAR_NODE // A scalar node. - yaml_SEQUENCE_NODE // A sequence node. - yaml_MAPPING_NODE // A mapping node. -) - -// An element of a sequence node. -type yaml_node_item_t int - -// An element of a mapping node. -type yaml_node_pair_t struct { - key int // The key of the element. - value int // The value of the element. -} - -// The node structure. -type yaml_node_t struct { - typ yaml_node_type_t // The node type. - tag []byte // The node tag. - - // The node data. - - // The scalar parameters (for yaml_SCALAR_NODE). - scalar struct { - value []byte // The scalar value. - length int // The length of the scalar value. - style yaml_scalar_style_t // The scalar style. - } - - // The sequence parameters (for YAML_SEQUENCE_NODE). - sequence struct { - items_data []yaml_node_item_t // The stack of sequence items. - style yaml_sequence_style_t // The sequence style. - } - - // The mapping parameters (for yaml_MAPPING_NODE). - mapping struct { - pairs_data []yaml_node_pair_t // The stack of mapping pairs (key, value). - pairs_start *yaml_node_pair_t // The beginning of the stack. - pairs_end *yaml_node_pair_t // The end of the stack. - pairs_top *yaml_node_pair_t // The top of the stack. - style yaml_mapping_style_t // The mapping style. - } - - start_mark yaml_mark_t // The beginning of the node. - end_mark yaml_mark_t // The end of the node. - -} - -// The document structure. -type yaml_document_t struct { - - // The document nodes. - nodes []yaml_node_t - - // The version directive. - version_directive *yaml_version_directive_t - - // The list of tag directives. - tag_directives_data []yaml_tag_directive_t - tag_directives_start int // The beginning of the tag directives list. - tag_directives_end int // The end of the tag directives list. - - start_implicit int // Is the document start indicator implicit? - end_implicit int // Is the document end indicator implicit? - - // The start/end of the document. - start_mark, end_mark yaml_mark_t -} - -// The prototype of a read handler. -// -// The read handler is called when the parser needs to read more bytes from the -// source. The handler should write not more than size bytes to the buffer. -// The number of written bytes should be set to the size_read variable. -// -// [in,out] data A pointer to an application data specified by -// yaml_parser_set_input(). -// [out] buffer The buffer to write the data from the source. -// [in] size The size of the buffer. -// [out] size_read The actual number of bytes read from the source. -// -// On success, the handler should return 1. If the handler failed, -// the returned value should be 0. On EOF, the handler should set the -// size_read to 0 and return 1. -type yaml_read_handler_t func(parser *yaml_parser_t, buffer []byte) (n int, err error) - -// This structure holds information about a potential simple key. -type yaml_simple_key_t struct { - possible bool // Is a simple key possible? - required bool // Is a simple key required? - token_number int // The number of the token. - mark yaml_mark_t // The position mark. -} - -// The states of the parser. -type yaml_parser_state_t int - -const ( - yaml_PARSE_STREAM_START_STATE yaml_parser_state_t = iota - - yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE // Expect the beginning of an implicit document. - yaml_PARSE_DOCUMENT_START_STATE // Expect DOCUMENT-START. - yaml_PARSE_DOCUMENT_CONTENT_STATE // Expect the content of a document. - yaml_PARSE_DOCUMENT_END_STATE // Expect DOCUMENT-END. - yaml_PARSE_BLOCK_NODE_STATE // Expect a block node. - yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE // Expect a block node or indentless sequence. - yaml_PARSE_FLOW_NODE_STATE // Expect a flow node. - yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a block sequence. - yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE // Expect an entry of a block sequence. - yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE // Expect an entry of an indentless sequence. - yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping. - yaml_PARSE_BLOCK_MAPPING_KEY_STATE // Expect a block mapping key. - yaml_PARSE_BLOCK_MAPPING_VALUE_STATE // Expect a block mapping value. - yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a flow sequence. - yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE // Expect an entry of a flow sequence. - yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE // Expect a key of an ordered mapping. - yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE // Expect a value of an ordered mapping. - yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE // Expect the and of an ordered mapping entry. - yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping. - yaml_PARSE_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping. - yaml_PARSE_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping. - yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE // Expect an empty value of a flow mapping. - yaml_PARSE_END_STATE // Expect nothing. -) - -func (ps yaml_parser_state_t) String() string { - switch ps { - case yaml_PARSE_STREAM_START_STATE: - return "yaml_PARSE_STREAM_START_STATE" - case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE: - return "yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE" - case yaml_PARSE_DOCUMENT_START_STATE: - return "yaml_PARSE_DOCUMENT_START_STATE" - case yaml_PARSE_DOCUMENT_CONTENT_STATE: - return "yaml_PARSE_DOCUMENT_CONTENT_STATE" - case yaml_PARSE_DOCUMENT_END_STATE: - return "yaml_PARSE_DOCUMENT_END_STATE" - case yaml_PARSE_BLOCK_NODE_STATE: - return "yaml_PARSE_BLOCK_NODE_STATE" - case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE: - return "yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE" - case yaml_PARSE_FLOW_NODE_STATE: - return "yaml_PARSE_FLOW_NODE_STATE" - case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE: - return "yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE" - case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE: - return "yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE" - case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE: - return "yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE" - case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE: - return "yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE" - case yaml_PARSE_BLOCK_MAPPING_KEY_STATE: - return "yaml_PARSE_BLOCK_MAPPING_KEY_STATE" - case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE: - return "yaml_PARSE_BLOCK_MAPPING_VALUE_STATE" - case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE: - return "yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE" - case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE: - return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE" - case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE: - return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE" - case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE: - return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE" - case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE: - return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE" - case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE: - return "yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE" - case yaml_PARSE_FLOW_MAPPING_KEY_STATE: - return "yaml_PARSE_FLOW_MAPPING_KEY_STATE" - case yaml_PARSE_FLOW_MAPPING_VALUE_STATE: - return "yaml_PARSE_FLOW_MAPPING_VALUE_STATE" - case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE: - return "yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE" - case yaml_PARSE_END_STATE: - return "yaml_PARSE_END_STATE" - } - return "" -} - -// This structure holds aliases data. -type yaml_alias_data_t struct { - anchor []byte // The anchor. - index int // The node id. - mark yaml_mark_t // The anchor mark. -} - -// The parser structure. -// -// All members are internal. Manage the structure using the -// yaml_parser_ family of functions. -type yaml_parser_t struct { - - // Error handling - - error yaml_error_type_t // Error type. - - problem string // Error description. - - // The byte about which the problem occurred. - problem_offset int - problem_value int - problem_mark yaml_mark_t - - // The error context. - context string - context_mark yaml_mark_t - - // Reader stuff - - read_handler yaml_read_handler_t // Read handler. - - input_reader io.Reader // File input data. - input []byte // String input data. - input_pos int - - eof bool // EOF flag - - buffer []byte // The working buffer. - buffer_pos int // The current position of the buffer. - - unread int // The number of unread characters in the buffer. - - raw_buffer []byte // The raw buffer. - raw_buffer_pos int // The current position of the buffer. - - encoding yaml_encoding_t // The input encoding. - - offset int // The offset of the current position (in bytes). - mark yaml_mark_t // The mark of the current position. - - // Scanner stuff - - stream_start_produced bool // Have we started to scan the input stream? - stream_end_produced bool // Have we reached the end of the input stream? - - flow_level int // The number of unclosed '[' and '{' indicators. - - tokens []yaml_token_t // The tokens queue. - tokens_head int // The head of the tokens queue. - tokens_parsed int // The number of tokens fetched from the queue. - token_available bool // Does the tokens queue contain a token ready for dequeueing. - - indent int // The current indentation level. - indents []int // The indentation levels stack. - - simple_key_allowed bool // May a simple key occur at the current position? - simple_keys []yaml_simple_key_t // The stack of simple keys. - - // Parser stuff - - state yaml_parser_state_t // The current parser state. - states []yaml_parser_state_t // The parser states stack. - marks []yaml_mark_t // The stack of marks. - tag_directives []yaml_tag_directive_t // The list of TAG directives. - - // Dumper stuff - - aliases []yaml_alias_data_t // The alias data. - - document *yaml_document_t // The currently parsed document. -} - -// Emitter Definitions - -// The prototype of a write handler. -// -// The write handler is called when the emitter needs to flush the accumulated -// characters to the output. The handler should write @a size bytes of the -// @a buffer to the output. -// -// @param[in,out] data A pointer to an application data specified by -// yaml_emitter_set_output(). -// @param[in] buffer The buffer with bytes to be written. -// @param[in] size The size of the buffer. -// -// @returns On success, the handler should return @c 1. If the handler failed, -// the returned value should be @c 0. -// -type yaml_write_handler_t func(emitter *yaml_emitter_t, buffer []byte) error - -type yaml_emitter_state_t int - -// The emitter states. -const ( - // Expect STREAM-START. - yaml_EMIT_STREAM_START_STATE yaml_emitter_state_t = iota - - yaml_EMIT_FIRST_DOCUMENT_START_STATE // Expect the first DOCUMENT-START or STREAM-END. - yaml_EMIT_DOCUMENT_START_STATE // Expect DOCUMENT-START or STREAM-END. - yaml_EMIT_DOCUMENT_CONTENT_STATE // Expect the content of a document. - yaml_EMIT_DOCUMENT_END_STATE // Expect DOCUMENT-END. - yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a flow sequence. - yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE // Expect an item of a flow sequence. - yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping. - yaml_EMIT_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping. - yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a flow mapping. - yaml_EMIT_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping. - yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a block sequence. - yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE // Expect an item of a block sequence. - yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping. - yaml_EMIT_BLOCK_MAPPING_KEY_STATE // Expect the key of a block mapping. - yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a block mapping. - yaml_EMIT_BLOCK_MAPPING_VALUE_STATE // Expect a value of a block mapping. - yaml_EMIT_END_STATE // Expect nothing. -) - -// The emitter structure. -// -// All members are internal. Manage the structure using the @c yaml_emitter_ -// family of functions. -type yaml_emitter_t struct { - - // Error handling - - error yaml_error_type_t // Error type. - problem string // Error description. - - // Writer stuff - - write_handler yaml_write_handler_t // Write handler. - - output_buffer *[]byte // String output data. - output_writer io.Writer // File output data. - - buffer []byte // The working buffer. - buffer_pos int // The current position of the buffer. - - raw_buffer []byte // The raw buffer. - raw_buffer_pos int // The current position of the buffer. - - encoding yaml_encoding_t // The stream encoding. - - // Emitter stuff - - canonical bool // If the output is in the canonical style? - best_indent int // The number of indentation spaces. - best_width int // The preferred width of the output lines. - unicode bool // Allow unescaped non-ASCII characters? - line_break yaml_break_t // The preferred line break. - - state yaml_emitter_state_t // The current emitter state. - states []yaml_emitter_state_t // The stack of states. - - events []yaml_event_t // The event queue. - events_head int // The head of the event queue. - - indents []int // The stack of indentation levels. - - tag_directives []yaml_tag_directive_t // The list of tag directives. - - indent int // The current indentation level. - - flow_level int // The current flow level. - - root_context bool // Is it the document root context? - sequence_context bool // Is it a sequence context? - mapping_context bool // Is it a mapping context? - simple_key_context bool // Is it a simple mapping key context? - - line int // The current line. - column int // The current column. - whitespace bool // If the last character was a whitespace? - indention bool // If the last character was an indentation character (' ', '-', '?', ':')? - open_ended bool // If an explicit document end is required? - - // Anchor analysis. - anchor_data struct { - anchor []byte // The anchor value. - alias bool // Is it an alias? - } - - // Tag analysis. - tag_data struct { - handle []byte // The tag handle. - suffix []byte // The tag suffix. - } - - // Scalar analysis. - scalar_data struct { - value []byte // The scalar value. - multiline bool // Does the scalar contain line breaks? - flow_plain_allowed bool // Can the scalar be expessed in the flow plain style? - block_plain_allowed bool // Can the scalar be expressed in the block plain style? - single_quoted_allowed bool // Can the scalar be expressed in the single quoted style? - block_allowed bool // Can the scalar be expressed in the literal or folded styles? - style yaml_scalar_style_t // The output style. - } - - // Dumper stuff - - opened bool // If the stream was already opened? - closed bool // If the stream was already closed? - - // The information associated with the document nodes. - anchors *struct { - references int // The number of references. - anchor int // The anchor id. - serialized bool // If the node has been emitted? - } - - last_anchor_id int // The last assigned anchor id. - - document *yaml_document_t // The currently emitted document. -} diff --git a/vendor/gopkg.in/yaml.v2/yamlprivateh.go b/vendor/gopkg.in/yaml.v2/yamlprivateh.go deleted file mode 100644 index 8110ce3..0000000 --- a/vendor/gopkg.in/yaml.v2/yamlprivateh.go +++ /dev/null @@ -1,173 +0,0 @@ -package yaml - -const ( - // The size of the input raw buffer. - input_raw_buffer_size = 512 - - // The size of the input buffer. - // It should be possible to decode the whole raw buffer. - input_buffer_size = input_raw_buffer_size * 3 - - // The size of the output buffer. - output_buffer_size = 128 - - // The size of the output raw buffer. - // It should be possible to encode the whole output buffer. - output_raw_buffer_size = (output_buffer_size*2 + 2) - - // The size of other stacks and queues. - initial_stack_size = 16 - initial_queue_size = 16 - initial_string_size = 16 -) - -// Check if the character at the specified position is an alphabetical -// character, a digit, '_', or '-'. -func is_alpha(b []byte, i int) bool { - return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'Z' || b[i] >= 'a' && b[i] <= 'z' || b[i] == '_' || b[i] == '-' -} - -// Check if the character at the specified position is a digit. -func is_digit(b []byte, i int) bool { - return b[i] >= '0' && b[i] <= '9' -} - -// Get the value of a digit. -func as_digit(b []byte, i int) int { - return int(b[i]) - '0' -} - -// Check if the character at the specified position is a hex-digit. -func is_hex(b []byte, i int) bool { - return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'F' || b[i] >= 'a' && b[i] <= 'f' -} - -// Get the value of a hex-digit. -func as_hex(b []byte, i int) int { - bi := b[i] - if bi >= 'A' && bi <= 'F' { - return int(bi) - 'A' + 10 - } - if bi >= 'a' && bi <= 'f' { - return int(bi) - 'a' + 10 - } - return int(bi) - '0' -} - -// Check if the character is ASCII. -func is_ascii(b []byte, i int) bool { - return b[i] <= 0x7F -} - -// Check if the character at the start of the buffer can be printed unescaped. -func is_printable(b []byte, i int) bool { - return ((b[i] == 0x0A) || // . == #x0A - (b[i] >= 0x20 && b[i] <= 0x7E) || // #x20 <= . <= #x7E - (b[i] == 0xC2 && b[i+1] >= 0xA0) || // #0xA0 <= . <= #xD7FF - (b[i] > 0xC2 && b[i] < 0xED) || - (b[i] == 0xED && b[i+1] < 0xA0) || - (b[i] == 0xEE) || - (b[i] == 0xEF && // #xE000 <= . <= #xFFFD - !(b[i+1] == 0xBB && b[i+2] == 0xBF) && // && . != #xFEFF - !(b[i+1] == 0xBF && (b[i+2] == 0xBE || b[i+2] == 0xBF)))) -} - -// Check if the character at the specified position is NUL. -func is_z(b []byte, i int) bool { - return b[i] == 0x00 -} - -// Check if the beginning of the buffer is a BOM. -func is_bom(b []byte, i int) bool { - return b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF -} - -// Check if the character at the specified position is space. -func is_space(b []byte, i int) bool { - return b[i] == ' ' -} - -// Check if the character at the specified position is tab. -func is_tab(b []byte, i int) bool { - return b[i] == '\t' -} - -// Check if the character at the specified position is blank (space or tab). -func is_blank(b []byte, i int) bool { - //return is_space(b, i) || is_tab(b, i) - return b[i] == ' ' || b[i] == '\t' -} - -// Check if the character at the specified position is a line break. -func is_break(b []byte, i int) bool { - return (b[i] == '\r' || // CR (#xD) - b[i] == '\n' || // LF (#xA) - b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85) - b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028) - b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9) // PS (#x2029) -} - -func is_crlf(b []byte, i int) bool { - return b[i] == '\r' && b[i+1] == '\n' -} - -// Check if the character is a line break or NUL. -func is_breakz(b []byte, i int) bool { - //return is_break(b, i) || is_z(b, i) - return ( // is_break: - b[i] == '\r' || // CR (#xD) - b[i] == '\n' || // LF (#xA) - b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85) - b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028) - b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029) - // is_z: - b[i] == 0) -} - -// Check if the character is a line break, space, or NUL. -func is_spacez(b []byte, i int) bool { - //return is_space(b, i) || is_breakz(b, i) - return ( // is_space: - b[i] == ' ' || - // is_breakz: - b[i] == '\r' || // CR (#xD) - b[i] == '\n' || // LF (#xA) - b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85) - b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028) - b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029) - b[i] == 0) -} - -// Check if the character is a line break, space, tab, or NUL. -func is_blankz(b []byte, i int) bool { - //return is_blank(b, i) || is_breakz(b, i) - return ( // is_blank: - b[i] == ' ' || b[i] == '\t' || - // is_breakz: - b[i] == '\r' || // CR (#xD) - b[i] == '\n' || // LF (#xA) - b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85) - b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028) - b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029) - b[i] == 0) -} - -// Determine the width of the character. -func width(b byte) int { - // Don't replace these by a switch without first - // confirming that it is being inlined. - if b&0x80 == 0x00 { - return 1 - } - if b&0xE0 == 0xC0 { - return 2 - } - if b&0xF0 == 0xE0 { - return 3 - } - if b&0xF8 == 0xF0 { - return 4 - } - return 0 - -}