pax_global_header 0000666 0000000 0000000 00000000064 14576632421 0014524 g ustar 00root root 0000000 0000000 52 comment=3b9ba3376fca75f127d4e7212467fc3c2c179100
ocaml-linenoise-1.5.1/ 0000775 0000000 0000000 00000000000 14576632421 0014606 5 ustar 00root root 0000000 0000000 ocaml-linenoise-1.5.1/.github/ 0000775 0000000 0000000 00000000000 14576632421 0016146 5 ustar 00root root 0000000 0000000 ocaml-linenoise-1.5.1/.github/CODEOWNERS 0000664 0000000 0000000 00000000012 14576632421 0017532 0 ustar 00root root 0000000 0000000 * @c-cube
ocaml-linenoise-1.5.1/.github/workflows/ 0000775 0000000 0000000 00000000000 14576632421 0020203 5 ustar 00root root 0000000 0000000 ocaml-linenoise-1.5.1/.github/workflows/main.yml 0000664 0000000 0000000 00000001363 14576632421 0021655 0 ustar 00root root 0000000 0000000 name: build
on:
push:
branches:
- main
pull_request:
jobs:
run:
name: build
strategy:
matrix:
os:
- ubuntu-latest
ocaml-compiler:
- 4.03.x
- 4.14.x
- 5.1.x
runs-on: ${{ matrix.os }}
steps:
- uses: actions/checkout@v2
- uses: ocaml/setup-ocaml@v2
with:
ocaml-compiler: ${{ matrix.ocaml-compiler }}
allow-prerelease-opam: true
- run: opam pin -n .
- run: opam depext -yt linenoise
- run: opam install -t . --deps-only
- run: opam exec -- dune build --ignore-promoted-rules
- run: opam exec -- dune runtest --ignore-promoted-rules
if: ${{ matrix.os == 'ubuntu-latest' && matrix.ocaml-compiler == '4.14.x' }}
ocaml-linenoise-1.5.1/.gitignore 0000664 0000000 0000000 00000000150 14576632421 0016572 0 ustar 00root root 0000000 0000000 _build
*.docdir
history.txt
*.cmi
*.cmt
*.cmo
*.cma
*.cmx
*.o
T
setup.data
setup.log
*.install
.merlin
ocaml-linenoise-1.5.1/CHANGES.md 0000664 0000000 0000000 00000000303 14576632421 0016174 0 ustar 00root root 0000000 0000000 # 1.5.1
- fix a deadlock from 1.5
# 1.5
- release runtime lock when calling `lnoise`
- fix potential memleaks and use of deprecate parts of
the OCaml C API
- remove dependency on `result`
ocaml-linenoise-1.5.1/Makefile 0000664 0000000 0000000 00000000334 14576632421 0016246 0 ustar 00root root 0000000 0000000
all: build test
build:
@dune build @install
test:
@dune runtest --no-buffer --force
example:
@dune exec examples/show_off.exe
clean:
@dune clean
doc:
@dune build @doc
.PHONY: all build test example clean doc
ocaml-linenoise-1.5.1/README.md 0000664 0000000 0000000 00000004146 14576632421 0016072 0 ustar 00root root 0000000 0000000 Linenoise in OCaml
--------------------
[](https://github.com/ocaml-community/ocaml-linenoise/actions/workflows/main.yml)
# Benefits
1. BSD licensed.
2. No system dependencies, no need for `readline` on your machine.
3. Related to 2, these bindings are self-contained, the source for
`linenoise` is in this repo and compiled all together with the
`OCaml`.
4. Written in OCaml + C.
5. Pretty cool hints feature, see the gif.
6. Additional features compared to linenoise, such as history search
# Installation
It is easy with `opam`
```shell
$ opam install linenoise
```
See the pretty
documentation [here](https://ocaml-community.github.io/ocaml-linenoise/)
# Example code
This example is also included in the repo under examples:
```ocaml
let rec user_input prompt cb =
match LNoise.linenoise prompt with
| None -> ()
| Some v ->
cb v;
user_input prompt cb
let () =
(* LNoise.set_multiline true; *)
LNoise.set_hints_callback (fun line ->
if line <> "git remote add " then None
else Some (" ",
LNoise.Yellow,
true)
);
LNoise.history_load ~filename:"history.txt" |> ignore;
LNoise.history_set ~max_length:100 |> ignore;
LNoise.set_completion_callback begin fun line_so_far ln_completions ->
if line_so_far <> "" && line_so_far.[0] = 'h' then
["Hey"; "Howard"; "Hughes";"Hocus"]
|> List.iter (LNoise.add_completion ln_completions);
end;
["These are OCaml bindings to linenoise";
"get tab completion with , type h then hit ";
"type quit to exit gracefully";
"By Edgar Aroutiounian\n"]
|> List.iter print_endline;
(fun from_user ->
if from_user = "quit" then exit 0;
LNoise.history_add from_user |> ignore;
LNoise.history_save ~filename:"history.txt" |> ignore;
Printf.sprintf "Got: %s" from_user |> print_endline
)
|> user_input "test_program> "
```
ocaml-linenoise-1.5.1/dune-project 0000664 0000000 0000000 00000000041 14576632421 0017123 0 ustar 00root root 0000000 0000000 (lang dune 1.1)
(name linenoise)
ocaml-linenoise-1.5.1/example.gif 0000664 0000000 0000000 00000101565 14576632421 0016740 0 ustar 00root root 0000000 0000000 GIF89a w ! NETSCAPE2.0 ! < ,
$ + # ,4 9 2
=.5;%)/3: 4
=! $ &* (>* = =3
$$$* #-.,222888 E H C K P
\ELR\\ b k
sz`oclu{ v }(;JB D#E(I&J) @" L*
P-h38Y>c~EBBBYZY@MbMGbbbiii}}} """"" !G:U?ZG5H;]H\BGdMf`a`f',Y_=dI5M)}k'@jJaЄn5
ъd"Fsyn41(HGz"1)JW&Lg
Ei'Nӝj>&P*͡ՙF=2Tc2|*T})թ겪V%V*˭rՕ^**VSr@ei6֛vmWεv+^Wz~+[{RDanuE+ُ0*,h#*6EeS! E-l*%hms{vGxo$ =no#\wn4Br\Rםҽ;}]o ='w{ל=8`]z3j+ך5 ^NwlXI.ؘ~0+aF /g
E,[^ķL0}s.~c
Ƴlpp,K%+ ! ,y *) #(?@2" 5Pwǖ2Xi B3% ! * , &3 ))("(>/022.)51*566 E H C K ZELR\\ b kw`oclu{ v })E-F4K 8Q#)@%-Y&6F&Eh38Y>c~E-GY:CJ5IY8P^)@b3Kg;Qf=SqOC' D+O7J5Q; B*"N.3J;)F=4R;!O7E_=GKC}X xK, G pHC~La; ~F`"ߠa ;M #-Bٯ_HX:Y@ß̯v#]dx
1%C Z@pЃ)7 xG ц
vy pfpTa Ѱ
t\ Z 2uU 6N"E.0#,u G`8=VmB1f0s4 &B) B oxC7j_A
l
0t PLJr(0hd'L~0| qUL ۰"#ur恈i; Uӎ fSNܼ& ĩ@S D%LM `xc'
^]H> !Ox◚8)~r]
.X) HfنL\t<*Wt Apy_f HH9:Py
p)LKT$9Jw̌
8PԣF,RT(T0`@ qCT)Q #;pLDB=@V rECRMK b!ʃ5u
T!'Ѻץ26XP ` ld lh` É EU+Z І3*x gp-l@[L >6 HZqЕn;DWER1n 07R0t@[3Leo| Ӧ? 4oHX@T`Yp D pB ` r@/<h`
A R Y +ֈ1ZP~!0BhS2
BHJ xC<#\'1
)3恨#qSHˆ<Ѝl@yjPq@(fD@yˎH6o!P
!;ъ2jD$-H2n,m g H#&C b a>рҽǮ{B
MHq{ )PZӫ: od@@ ;3 pŁaO
Dh |#_ ͐sBI¥pK] ? 6y߸OA`c x$" h y7r >nd!p9.=!I~ YYviS sf FٙTh%gYTCwbsyVFjjeY#
AQ6 Aqq=;Jam Z rcqoAGP!$@H qhh
Ca
9lVg@[)kj@- 3Ql,jASK)Fp p*e>J=;)<!sx?1,E&9@&qg;x1:te¡ms *D/C3 Pw "4%ğ_Scu!>I}'~7a
㣗Cm0Svb}ǦCz{;TNȋ+mezp &SC R" l$/Ŧ9XNk+a Q5U;ҸDzH 0*V ۿ*z 6 Ĭܵ[z铀D^
Ysy ۅ/C,¾ѱ)cOYckoYR,bKa q}ab|hjlnp rv{nY =FğLDX硣+[ ZCKDFDϰw}wL+ѤL$} kM`4J%gKC~W)R*Sgj`z$x@Lh'UY`tuڇ+ ̬KE,0W+|&!;cV 3Fn+ ʰVbMO,+2sd(?
ԔaFmH- ! ,[ T 5M 8Q#)@N9_Q:`R:LKJhSH^|xh 4 TiYZ
R#C, 0"RM g()Rf,+eB ! ,[ T
%53 -&/) 20--F6?E8?F-GY/IZ5@R8IV9Q^2Ki:OoQ; @*"D=7QD.SA5`R:lP""90<(I
?,1@)):0J ; =C 3B% 64 H DF 'G8E$Ah `J e2ƿBxШ@ ! # ,a T $
& + # ( 9 %4/ ' .'/( 4& ;!9) !*/.*$&B'.D%-X#?T32E-FY=DL1J[8GY)@b1Jd?SqD& C) R< G/(Q;!ND>YH-XF>[M7_Q:`R:pT?v[=DDEKROLX^QYWRZ]GXqK]Vepq_R~`McccvmmM^P_VmY|^}wyhuzsy^OnWqVs[^|owv^h{t{|þĺ q >*q?, @M 2% 0 399 16U 3:^+ l' l\#Ebe[L/_+ mk7X,YN/ٝ=IB)chP TZm. f?G;O5WJ~XIw$X"HH0K!2b .Cw&`Hŀ8
@0CXT )(A3aDBF8D )Q(AS ! ,a W
#
"&-(1' 3 -&4)/+&)-/"(>2.)20-:3)57:-F3I5M 8Q#)@&.[#?T8?F-GY1K[8P^N9@*"R;!PC-_Q:`R:EDEFHHHHGJJI@LWPOH^GAQY]GXqIY{_``Qj}hUJweMaaamdddluN^^|uxxyhh^yn^v^{| Ӏ M!_,3 6==!N"C;?O*BO(KV+TJ/S.!m`2f)Z<%kl5 4 (I+$aAo F.&o01X.gH@GE-.(c9
?l\ 'N #p+7#n A4
,e6d\YL.Dl 4PаFJ1\D,+90@P
E ! ,a T $
($&- 9 %4' # )#/) 4& 4);!!*/.*$)-/"(>/022.)57::67 #C3I7O'/^*9\=DL1K[8P_?SqR3!R;!ND>PB-ZM7pT?BLTPOH^GALVdhWLdmwspjO_Vm^uxwqzy^OqVyn^ww^{{{ö Ā ]] 9A1H4
+. 8G2W*$W :B .&CK)X0 /6> \&@)V?7=5C![ 3XO
'E<- Z(%F DtIa NR$`&D
X@a%I̳uB6DT 8#in ! ,[ T $ 5M 8Q#)@N9_Q:`R:LKJhSH^|xh M Tihyp,lB- 8G
$Dl qZS@;,
k*.,7 ! ,[ T
%53 -&/) 20--F6?E8?F-GY/IZ5@R8IV9Q^2Ki:OoQ; @*"D=7QD.SA5`R:lP""90<(I
?,1@)):0J ; =C 3B% 64 H DF 'G8E$Ah `J e2ƿBxШ@ ! ,g T l܃PoRwx!R ! ,a T l܃PoRwx!R ! G ,[ T l܃PoRwx!R ! ,[ T & +/ &B'.D32E-FY1J[D& C) G/(YH-XF>KROQYWK]~`M]}iss[hÿĺ =@p(*Dc)T.N #YT6Nxh$c`$QG !ࣈNPNNA ! ,a T & +/ &B'.D32E-FY1J[D& C) G/(YH-XF>KROQYWK]~`M]}iss[hÿĺ =@p(*Dc)T.N #YT6Nxh$c`$QG !ࣈNPNNA ! ,g T
3 -&20--F8?F-GY9Q^@*"QD.`R:FHHHHG_``Qj}weM```elt @@p(*Dc)T.N.)TCH4hcLQg $T)LQ[JS}HQA ! l , T l *
& + #
( ) *! &- 9 #4(1/ $) 4 ' $"-&/( 4& 4);!9) >3 #*/.*$),+"(>2.)40*:3)27357:;83&B+F-F2I7P 8Q'.D'/V%-X$3B#?T32E8?E-FY=DL1IZ8GY8P^)@b1Jd9Q`=Xi?SqD& C) G3 Q< @*"G/(M-%@2"O?-I?3Q;!Z9$X:+ND>QD.YH-SF2VJ4XF>_R:cM=hN6iS.`R:pT?v[=DDEFHHHHGHII@LXKROLX^POH^GAQQRQYWRZ]DPnGXqJ[}_``UcpQj}hWLh\HqWDq_RweM~`MtfSaaamdddluktvhu}}upN^P_QnVmZp]}l}vxv~_nwx{`huzzszyz^O`OnWqVs[~^yn|o}fowvs^ch{t{}·þ¼¿ĺ H*\ȰÇ#JHŋ3.qcƏ qdȓ(XFB YP`$ 5P @6"*$S& @=ԩDb!; X5X .a <ԍ 6lN D\h[\3 5f,Cġƈ36kb_xIQDͪ$ 2 X-݃9^
_c pub`F= 2 @I *H 3m@V oq
4Ri 2N1w4 s J! @
d'tAt"-Sـ@7 ( c 6"ؐ-@1n=!9LF
G!t ABj9AL/] p7tb4yg.!`3° `$A*`sL%c&'+ebfB50꫱ɧ @@@BA[ob*+ p dIP @J ,%
Dt(. )+D k(!0H6ΨpGL%8pd8@F!uK)BeEX RL749d~@\lZ͵եd
r`uUwC'{Jw<+D5 ~$B/袊^Q+7WPA0BnEp(Мe'ă8lܤ6 x
D
>nkZA
T@`n騧 ;z>zLdCλ2EL5]N=PE U=T5EUYmՕBG2\9ۅ^|rvXb5XdUvYgViAH"r4 8
8!qs 09䀎td tS5^<,IO 2Lld Ѐ
5 HA "0 UBȆ:"aD&2H R$io>f$ II )JWR!ԥ/ic*әHX*q{ E *0jԣ$)JY
SԒ*QT@2T5F!"떯%,bXRuEkZ A%mEd̅.urWD5r! ! < ,[ p
& +
/ 3 -&20-&B-F'.D32E8?F-FY1J[9Q^D& C) @*"G/(QD.YH-XF>`R:FHHHHGKROQYWK]_``Qj}weM~`M```elt]}iss[hÿĺ BB! (/ 3+574%= * 69-@ 2 "0,).&8''# ?<A
> $;1:
<$) ! ) ,[ p zzFZ@Õy1`Pdx ! ,[ p
& +
/ 3 -&20-&B-F'.D32E8?F-FY1J[9Q^D& C) @*"G/(QD.YH-XF>`R:FHHHHGKROQYWK]_``Qj}weM~`M```elt]}iss[hÿĺ BB! (/ 3+574%= * 69-@ 2 "0,).&8''# ?<A
> $;1:
<$) ! N ,[ p zzFZ@Õy1`Pdx ! ,[ p
# ! ($((1' .'/+&:3)%-X#?TQ:Q;![L4_R:`R:EDEHIIQRQQY]GXqIY{bcbmddN^_|yh^vr{| k@pHҎȢL.51F d8 "T9`X~*BU!y{Q4& 3 *r410- x2$|M
+{PQ. )%ZE
OA ! ,g p $%*/71(+F7P 8QG3 VJ4Qn¿ 4 ViY
EH$tTI80v `,C1 *K ! ,m p l܃2@PoRwx!R ! ,s p ' /( 9) 8GYR< Q;!`R:v[=LX^Vepq_R . PiY.1
#ԏ4 @
)aHsb! ! ,y p
3 -&20--F8?F-GY9Q^@*"QD.`R:FHHHHG_``Qj}weM```elt @@p(*Dc)T.N.)TCH4hcLQg $T)LQ[JS}HQA ! , p ' 273 8QR< M-%Q;!hN6@LXktvN_wxv~_O`O}ft 3 ViY1"0ARU x &pT?O_Vm^wzy^OqVw^{{ 9 \iY.1@@UAö$CAca)0" #h2A
p@\-* ! , p $%*/71(+F7P 8QG3 VJ4Qn¿ 4 ViY
EH$tTI80v `,C1 *K ! , p
3 -&20--F8?F-GY9Q^@*"QD.`R:FHHHHG_``Qj}weM```elt @@p(*Dc)T.N.)TCH4hcLQg $T)LQ[JS}HQA ! , p l܃2@PoRwx!R ! , p
(.'/+&)@b1Jd_R:`S>DDET[^cccL]P_unW|ot} : \iY.104c51E,QY.ĈT=( i*l4ȢF85k ! , p
#/+&%-X#?T[M7_Q:`R:EDEQY]GXqvmmN^Y|_|yh^v|< _iY~h̀8Y2rs 6"AM|`@UG#f! ! , p
#/+&%-X#?T[M7_Q:`R:EDEQY]GXqvmmN^Y|_|yh^v|< _iY~h̀8Y2rs 6"AM|`@UG#f! ! k , p 9
#7'9' + #" < 3 ; .. %, "0-9 2) :# 9. 81 3< +3" D*7B ;@ #D+'H-.L17B Z> `>n<KCHJ VCTR HD#OH-CQ,KP$HZ0SR XU#\Y%B`2Hf3Ra/Rf;_e3[p=cEbE hIiK hJmS yL~UZrc yfcd+me$bo2ns2mq9m|=sa$pm-yg%yn%pe3qr.zp&qr0}3bvFdxGfyHtxFj=iCjLuOwVxVw y k%f v,v'z(~4&~*0>=-(01$$5:<3:?9=XP˗0cʜ9e8BQ :1N =4JN>
HT"SQ>#S HФ ɡhsanNv'Ε Wަ wb} ~ءn1 [ -P-˄&,v'ء2#WB(Ln-} =$X˖M||~#:{%U+>U]~ek"Tdu H@zP[1\ 4#(1W( K ڄ6C7tQ
A1m t-h :+зb[:O9nBm p`ɞ}&T뭹fW/l;,&Lo^f/梫.
za7t $0 60[f 5LPC[< B_D)4RS
0T @MU+gL I ^+5 H7t79lAF/J+TvOM] ؐmy) NGD7O17~iTtS_q, 0ޒB'$
)
Dl9'T3 <}aetS Mw7y [Tc n;<h b
p{ x=y
|#_)>P %5'L*\1- 5OHc؋
n,%І1jэ7 ͇@"0}j#J( 4p0 [،PŜf1?'QpCdHC3BQzBbX#pK\qC_3F1q@#FJ ILC`7ZG*D Ab%."KZBD)̅xGH/BL@;1 CeFDCjFě
9f2`Mp&W@H`v:a)zI@ ! , p 3 9 %44& ;!!*/.*"=DL?SqND>pT?O_Vm^wzy^OqVw^{{ \ihlp,tmx_Q:`R:LKJhTG^|xh 2 SiY`BC$Bl CHyͬ0 ! ) , p l܃2@PoRwx!R ! 0 , p l܃PoRwx!R ! , p l܃PoRwx!R ! , p l܃PoRwx!R ! , p l܃PoRwx!R ! , p l܃PoRwx!R ! , p l܃PoRwx!R ! , p 3
#7'9' + #" < 3 ; .. %, "0-9 2) :# 9. 81 3< +3" D*7B ;@ #D+'H-.L17B Z> `>n<KCHJ VCTR HD#OH-CQ,KP$HZ0SR XU#\Y%B`2Hf3Ra/Rf;_e3[p=cEbE hIiK hJmS yL~UZrc yfcd+me$bo2ns2mq9m|=sa$pm-yg%yn%pe3qr.zp&qr0}3bvFdxGfyHtxFj=iCjLuOwVxVw y k%f v,v'z(~4&~*0>=-(01$$5:<3:?9=aI4Ξ?J qQJB) $zhti 40E7'=ĺ}S/S~+0` TL Hӭm\Sv%BwЇvP1HA!V5춈ݒ6
N|(e&>?=pxĈ0"? 0%Ρ'}E>zu֯cw_;?]pw܀ \tUw`cIF\Ģgg
4hӍ6լV7~ # aBKA\
c2h#:"((P`
1VPsBt ((ɤtL7tE6Xa*CM>ЊH@316]ްdlp{
H")"3P9cPE
NB)%hb%^)&Qd4B7RlhP{ĖqWB{@#$Js
0kA[B6
"]kB0CAxHK0F7]ts4 m 䖮J(rKn7L / X'j+{ $K
0 B-;n离qBZ
7 t34 @! \-5k` (rҲu@}vA,
+d3:W66t
mx ʹvO]Afg-7^-cdWAJt3C$0 wlF5,A7UϾR)4B
2ALЍ l0yAS֘sҍO8@O_iC_F75Msw E5찐ێM['<
0xSz p`5O| Rn@ @ӜnB3hWDvXB >!]C/( @ƨE7`4 B$bBfXwjF.! ( Q0'LAhhC d{b3"@
nHCrEpFaT Dʈ? @&Q!L!{UG+ \Ĝ(DÌRD#B hxQ! $1
\ceh '+)d9CN Hd,eyA<%0 ,0#b Y&F \
fB n& 5 \q_vt%uy2>4
my ! k , p 9
#7'9' + #" < 3 ; .. %, "0-9 2) :# 9. 81 3< +3" D*7B ;@ #D+'H-.L17B Z> `>n<KCHJ VCTR HD#OH-CQ,KP$HZ0SR XU#\Y%B`2Hf3Ra/Rf;_e3[p=cEbE hIiK hJmS yL~UZrc yfcd+me$bo2ns2mq9m|=sa$pm-yg%yn%pe3qr.zp&qr0}3bvFdxGfyHtxFj=iCjLuOwVxVw y k%f v,v'z(~4&~*0>=-(01$$5:<3:?9=XP˗0cʜ9e8BQ :1N =4JN>
HT"SQ>#S HФ ɡhsanNv'Ε Wަ wb} ~ءn1 [ -P-˄&,v'ء2#WB(Ln-} =$X˖M||~#:{%U+>U]~ek"Tdu H@zP[1\ 4#(1W( K ڄ6C7tQ
A1m t-h :+зb[:O9nBm p`ɞ}&T뭹fW/l;,&Lo^f/梫.
za7t $0 60[f 5LPC[< B_D)4RS
0T @MU+gL I ^+5 H7t79lAF/J+TvOM] ؐmy) NGD7O17~iTtS_q, 0ޒB'$
)
Dl9'T3 <}aetS Mw7y [Tc n;<h b
p{ x=y
|#_)>P %5'L*\1- 5OHc؋
n,%І1jэ7 ͇@"0}j#J( 4p0 [،PŜf1?'QpCdHC3BQzBbX#pK\qC_3F1q@#FJ ILC`7ZG*D Ab%."KZBD)̅xGH/BL@;1 CeFDCjFě
9f2`Mp&W@H`v:a)zI@ ! ,' D
&<'7 "4$ > 9' $$$),(223866888/I 8Q/HZ8AF>SoI0M7 I?3Q $)#5*
&
$5 ' -&7%=3
>3 )*) *0/021')51*566 E H C K ZHR\\ ew`oclu{ v }
)D,F3J 8Q$+B%-Y%5E%=U7c~E-GY;CJ4IY8P^)@b2Kf;Re=SqOC' D+O7I4Q; D+#N.3I9(F=4R;!O7E_=GLC dɐH!,
I/%(HGC @G2i 9zH`A P A!A@$*^kДTAv@<ª0ZQ ;C%z,Nx; ˮJ2*t}|?zH90 h
3%GIL4N#e Px"ta?xCwL
6$ DD'Ipp ό0@BN4rC pwT2 M۠P Z EGA5X1!(3Gx1І;pylcTX :|EĹթ"$ 7a9%#`W*" G
y!XA pg`;JrUڧnl0+g ԫ k4 RӦ6!
`A. f0`7 v@^"0. ѵ !,XAXp܉ODPDp{THKވuxަJ+>C6ohS 2ط齚Dpv "Z )6s B$q DGD Om!}k[@|X h,\ycN;ow =` U/erAn(t#e.!zX@\g,dc ts,# hCP ``%RbC8nZ A-^0{W,#u@AxΰaJ'B
:dԲ'!, t ޢ%xu/Bǀ:r,r _fl0 M"4,nDrv&7y=eg6Ab S `:FrҒnw][/b}` r+F3Y nF 9ݩEѠ2 WRD $*AZR\ ,`R0w<); T kR `=n T2Ga z7qt <_+ ZsElUX\+V,կ
a<юn OW ֍ju1{aս@`aEܶ`$ )A+e.Al[2=.mK܄ u72Ӎ?B/̠ -]][`o
K1^٥ EQ caE_E _6`U q*XXc F3HbBb8c:p !N 3OWp\P&e9f;}>ULFffeFq e
QeIq(878;8?8Evdc 0cueF9K:bXcka, i=i]w+GgXOjxEEFg $s0 h[tVB A th/ i(&pZdn{HH$=G"bJHmdnql$ vo7nK_]YM 4~HжG|tcӆ ngc;!߳Of"ecm_v4,k Ћtx^
RrgBA xkr0iv&ä4k3kG-wp g :(g:F`g0pǦK5Ns uo&njʧDz3Z*TtF=y[@9DkF{љт J3P<(;>|Qe;#q!eӡk?; ʆTd3ia6f `uKfQ8<"{h@HEkC:i8P>:VHj0$C4
Fl jjj ЉIan$Ggƍ4n}G)gں{mD?"pk6oֻ (гHxOO-Mm"gv,tMs2Gss3Wsط Tov=P~uqC
jZvyg pwywwkQ5UU uD{gI `9Vg} Qg| \|p|^L[~G~΅2EZ i j\%Q X#qw]@C QABlD핳Liض Іp[=s-ThlZe:f|b^+ TAA!]AulhB
B6f TVt ~-@+m-Fti
4Vl n]8ψրdng
8l\jz;\ LôMr zڨSw(87!+| D3ټ vZTs 7D$u&,+iS?YHyPePʥTQ:Q*|]ϣ-Wy LYC<
q PFl^:jHٌN4N0)4+N,G446~D:.4<>@~3B>2SF0H䏲Ln NpR2^2sX3P^Z 2dP gnf'Anm $1t.v~ z.j~$.|^hA> ~ 暞 N>Q^ϖP.^ !릮~븮iޯOþP
p ; ocaml-linenoise-1.5.1/examples/ 0000775 0000000 0000000 00000000000 14576632421 0016424 5 ustar 00root root 0000000 0000000 ocaml-linenoise-1.5.1/examples/dune 0000664 0000000 0000000 00000000070 14576632421 0017277 0 ustar 00root root 0000000 0000000 (executable
(name show_off)
(libraries linenoise)
)
ocaml-linenoise-1.5.1/examples/show_off.ml 0000664 0000000 0000000 00000002253 14576632421 0020572 0 ustar 00root root 0000000 0000000 let rec user_input prompt cb =
match LNoise.linenoise prompt with
| None -> ()
| Some v ->
cb v;
user_input prompt cb
let () =
(* LNoise.set_multiline true; *)
LNoise.set_hints_callback (fun line ->
if line <> "git remote add " then None
else Some (" ",
LNoise.Yellow,
true)
);
LNoise.history_load ~filename:"history.txt" |> ignore;
LNoise.history_set ~max_length:100 |> ignore;
LNoise.set_completion_callback begin fun line_so_far ln_completions ->
if line_so_far <> "" && line_so_far.[0] = 'h' then
["Hey"; "Howard"; "Hughes";"Hocus"]
|> List.iter (LNoise.add_completion ln_completions);
end;
["These are OCaml bindings to linenoise";
"get tab completion with , type h then hit ";
"type quit to exit gracefully";
"By Edgar Aroutiounian\n"]
|> List.iter print_endline;
(fun from_user ->
if from_user = "quit" then exit 0;
LNoise.history_add from_user |> ignore;
LNoise.history_save ~filename:"history.txt" |> ignore;
Printf.sprintf "Got: %s" from_user |> print_endline
)
|> user_input "test_program> "
ocaml-linenoise-1.5.1/linenoise.opam 0000664 0000000 0000000 00000001235 14576632421 0017452 0 ustar 00root root 0000000 0000000 opam-version: "2.0"
name: "linenoise"
version: "1.5.1"
synopsis: "Lightweight readline alternative"
maintainer: "Simon Cruanes"
authors: [ "Edgar Aroutiounian " "Simon Cruanes" ]
license: "BSD-3-clause"
homepage: "https://github.com/ocaml-community/ocaml-linenoise"
dev-repo: "git+https://github.com/ocaml-community/ocaml-linenoise.git"
bug-reports: "https://github.com/ocaml-community/ocaml-linenoise/issues"
build: [
["dune" "build" "@install" "-p" name "-j" jobs]
["dune" "runtest" "-p" name] {with-test}
["dune" "build" "@doc" "-p" name] {with-doc}
]
depends: [
"dune" { >= "1.1" }
"ocaml" { >= "4.03.0" }
"odoc" {with-doc}
]
ocaml-linenoise-1.5.1/src/ 0000775 0000000 0000000 00000000000 14576632421 0015375 5 ustar 00root root 0000000 0000000 ocaml-linenoise-1.5.1/src/dune 0000664 0000000 0000000 00000000252 14576632421 0016252 0 ustar 00root root 0000000 0000000
(library
(name linenoise)
(public_name linenoise)
(modules LNoise)
(wrapped false)
(flags :standard -warn-error -3)
(c_names linenoise_src linenoise_stubs))
ocaml-linenoise-1.5.1/src/lNoise.ml 0000664 0000000 0000000 00000003434 14576632421 0017164 0 ustar 00root root 0000000 0000000
type completions
external add_completion : completions -> string -> unit = "ml_add_completion"
external linenoise : string -> string option = "ml_linenoise"
external history_add_ : string -> int = "ml_history_add"
external history_set_ : max_length:int -> int = "ml_history_set_maxlen"
external history_save_ : filename:string -> int = "ml_history_save"
external history_load_ : filename:string -> int = "ml_history_load"
external catch_break : bool -> unit = "ml_catch_break"
external setup_bridges : unit -> unit = "ml_setup_bridges"
type hint_color = Red | Green | Yellow | Blue | Magenta | Cyan | White
let completion_cb = ref (fun _ _ -> ())
let hints_cb = ref (fun _ -> None)
let set_completion_callback (f:string->completions->unit) : unit =
completion_cb := f;
Callback.register "lnoise_completion_cb" f
let set_hints_callback (f:string -> (string*hint_color*bool) option) : unit =
hints_cb := f;
Callback.register "lnoise_hints_cb" f
(* initialization: register [Sys.Break] and enable catch-break *)
let () =
setup_bridges();
set_completion_callback !completion_cb;
set_hints_callback !hints_cb;
Callback.register_exception "sys_break" Sys.Break;
catch_break true
let history_add h =
if history_add_ h = 0 then Error "Couldn't add to history"
else Ok ()
let history_set ~max_length =
if history_set_ ~max_length = 0
then Error "Couldn't set the max length of history"
else Ok ()
let history_save ~filename =
if history_save_ ~filename = 0 then Ok ()
else Error "Couldn't save"
let history_load ~filename =
if history_load_ ~filename = 0 then Ok ()
else Error "Couldn't load the file"
external clear_screen : unit -> unit = "ml_clearscreen"
external set_multiline : bool -> unit = "ml_set_multiline"
external print_keycodes : unit -> unit = "ml_printkeycodes"
ocaml-linenoise-1.5.1/src/lNoise.mli 0000664 0000000 0000000 00000005336 14576632421 0017340 0 ustar 00root root 0000000 0000000 (** OCaml bindings to linenoise, functions that can fail use result
type *)
(** Abstract type of completions, given to your completion callback *)
type completions
(** This function is used by the callback function registered by the
user in order to add completion options given the input string
when the user typed . *)
val add_completion : completions -> string -> unit
(** Register the callback function that is called for upon
tab-completion, aka when is hit in the terminal *)
val set_completion_callback : (string -> completions -> unit) -> unit
(** The high level function that is the main API of the linenoise
library. This function checks if the terminal has basic
capabilities, just checking for a blacklist of stupid terminals,
and later either calls the line editing function or uses dummy
fgets() so that you will be able to type something even in the
most desperate of the conditions. *)
val linenoise : string -> string option
(** Add a string to the history *)
val history_add : string -> (unit, string) result
(** Set the maximum length for the history. This function can be
called even if there is already some history, the function will
make sure to retain just the latest 'len' elements if the new
history length value is smaller than the amount of items already
inside the history. *)
val history_set : max_length:int -> (unit, string) result
(** Save the history in the specified file *)
val history_save : filename:string -> (unit, string) result
(** Load the history from the specified file. *)
val history_load : filename:string -> (unit, string) result
(** Clear the screen; used to handle CTRL+L *)
val clear_screen : unit -> unit
(** If [true], [ctrl-c] during a call to {!linenoise}
will raise [Sys.Break] instead of returning an empty string.
@since 1.1 *)
val catch_break : bool -> unit
(** Set if to use or not use the multi line mode. *)
val set_multiline : bool -> unit
(** This special mode is used by linenoise in order to print scan
codes on screen for debugging / development purposes. *)
val print_keycodes : unit -> unit
(** What color you want the hints to be. *)
type hint_color = Red | Green | Yellow | Blue | Magenta | Cyan | White
(** Set a hints callback, callback gets a string, aka the line input,
and you get a chance to give a hint to the user. Example, imagine
if user types git remote add, then you can give a hint of , see animated gif in source repo for clear example. Returned
tuple represents the hint message, color, and whether it ought to
be bold. *)
val set_hints_callback : (string -> (string * hint_color * bool) option) -> unit
ocaml-linenoise-1.5.1/src/linenoise_src.c 0000664 0000000 0000000 00000126555 14576632421 0020413 0 ustar 00root root 0000000 0000000 /* linenoise.c -- guerrilla line editing library against the idea that a
* line editing lib needs to be 20,000 lines of C code.
*
* You can find the latest source code at:
*
* http://github.com/antirez/linenoise
*
* Does a number of crazy assumptions that happen to be true in 99.9999% of
* the 2010 UNIX computers around.
*
* ------------------------------------------------------------------------
*
* Copyright (c) 2010-2016, Salvatore Sanfilippo
* Copyright (c) 2010-2013, Pieter Noordhuis
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* ------------------------------------------------------------------------
*
* References:
* - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
* - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html
*
* Todo list:
* - Filter bogus Ctrl+ combinations.
* - Win32 support
*
* List of escape sequences used by this program, we do everything just
* with three sequences. In order to be so cheap we may have some
* flickering effect with some slow terminal, but the lesser sequences
* the more compatible.
*
* EL (Erase Line)
* Sequence: ESC [ n K
* Effect: if n is 0 or missing, clear from cursor to end of line
* Effect: if n is 1, clear from beginning of line to cursor
* Effect: if n is 2, clear entire line
*
* CUF (CUrsor Forward)
* Sequence: ESC [ n C
* Effect: moves cursor forward n chars
*
* CUB (CUrsor Backward)
* Sequence: ESC [ n D
* Effect: moves cursor backward n chars
*
* The following is used to get the terminal width if getting
* the width with the TIOCGWINSZ ioctl fails
*
* DSR (Device Status Report)
* Sequence: ESC [ 6 n
* Effect: reports the current cusor position as ESC [ n ; m R
* where n is the row and m is the column
*
* When multi line mode is enabled, we also use an additional escape
* sequence. However multi line editing is disabled by default.
*
* CUU (Cursor Up)
* Sequence: ESC [ n A
* Effect: moves cursor up of n chars.
*
* CUD (Cursor Down)
* Sequence: ESC [ n B
* Effect: moves cursor down of n chars.
*
* When linenoiseClearScreen() is called, two additional escape sequences
* are used in order to clear the screen and position the cursor at home
* position.
*
* CUP (Cursor position)
* Sequence: ESC [ H
* Effect: moves the cursor to upper left corner
*
* ED (Erase display)
* Sequence: ESC [ 2 J
* Effect: clear the whole screen
*
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "linenoise_src.h"
#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100
#define LINENOISE_MAX_LINE 4096
static char *unsupported_term[] = {"dumb","cons25","emacs",NULL};
static linenoiseCompletionCallback *completionCallback = NULL;
static linenoiseHintsCallback *hintsCallback = NULL;
static linenoiseFreeHintsCallback *freeHintsCallback = NULL;
static struct termios orig_termios; /* In order to restore at exit.*/
static int rawmode = 0; /* For atexit() function to check if restore is needed*/
static int mlmode = 0; /* Multi line mode. Default is single line. */
static int atexit_registered = 0; /* Register atexit just 1 time. */
static int history_max_len = LINENOISE_DEFAULT_HISTORY_MAX_LEN;
static int history_len = 0;
static char **history = NULL;
int linenoiseWasInterrupted = 0;
/* The linenoiseState structure represents the state during line editing.
* We pass this state to functions implementing specific editing
* functionalities. */
struct linenoiseState {
int ifd; /* Terminal stdin file descriptor. */
int ofd; /* Terminal stdout file descriptor. */
char *buf; /* Edited line buffer. */
size_t buflen; /* Edited line buffer size. */
const char *prompt; /* Prompt to display. */
size_t plen; /* Prompt length. */
size_t pos; /* Current cursor position. */
size_t oldpos; /* Previous refresh cursor position. */
size_t len; /* Current edited line length. */
size_t cols; /* Number of columns in terminal. */
size_t maxrows; /* Maximum num of rows used so far (multiline mode) */
int history_index; /* The history index we are currently editing. */
};
enum KEY_ACTION{
KEY_NULL = 0, /* NULL */
CTRL_A = 1, /* Ctrl+a */
CTRL_B = 2, /* Ctrl-b */
CTRL_C = 3, /* Ctrl-c */
CTRL_D = 4, /* Ctrl-d */
CTRL_E = 5, /* Ctrl-e */
CTRL_F = 6, /* Ctrl-f */
CTRL_G = 7, /* Ctrl-g */
CTRL_H = 8, /* Ctrl-h */
TAB = 9, /* Tab */
CTRL_K = 11, /* Ctrl+k */
CTRL_L = 12, /* Ctrl+l */
ENTER = 13, /* Enter */
CTRL_N = 14, /* Ctrl-n */
CTRL_P = 16, /* Ctrl-p */
CTRL_R = 18, /* Ctrl-r */
CTRL_T = 20, /* Ctrl-t */
CTRL_U = 21, /* Ctrl+u */
CTRL_W = 23, /* Ctrl+w */
ESC = 27, /* Escape */
BACKSPACE = 127 /* Backspace */
};
static void linenoiseAtExit(void);
int linenoiseHistoryAdd(const char *line);
static void refreshLine(struct linenoiseState *l);
static void refreshLinePrompt(struct linenoiseState *l, const char *prompt);
/* Debugging macro. */
#if 0
FILE *lndebug_fp = NULL;
#define lndebug(...) \
do { \
if (lndebug_fp == NULL) { \
lndebug_fp = fopen("/tmp/lndebug.txt","a"); \
fprintf(lndebug_fp, \
"[%d %d %d] p: %d, rows: %d, rpos: %d, max: %d, oldmax: %d\n", \
(int)l->len,(int)l->pos,(int)l->oldpos,plen,rows,rpos, \
(int)l->maxrows,old_rows); \
} \
fprintf(lndebug_fp, ", " __VA_ARGS__); \
fflush(lndebug_fp); \
} while (0)
#else
#define lndebug(fmt, ...)
#endif
/* ======================= Low level terminal handling ====================== */
/* Set if to use or not the multi line mode. */
void linenoiseSetMultiLine(int ml) {
mlmode = ml;
}
/* Return true if the terminal name is in the list of terminals we know are
* not able to understand basic escape sequences. */
static int isUnsupportedTerm(void) {
char *term = getenv("TERM");
int j;
if (term == NULL) return 0;
for (j = 0; unsupported_term[j]; j++)
if (!strcasecmp(term,unsupported_term[j])) return 1;
return 0;
}
/* Raw mode: 1960 magic shit. */
static int enableRawMode(int fd) {
struct termios raw;
if (!isatty(STDIN_FILENO)) goto fatal;
if (!atexit_registered) {
atexit(linenoiseAtExit);
atexit_registered = 1;
}
if (tcgetattr(fd,&orig_termios) == -1) goto fatal;
raw = orig_termios; /* modify the original mode */
/* input modes: no break, no CR to NL, no parity check, no strip char,
* no start/stop output control. */
raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
/* output modes - disable post processing */
raw.c_oflag &= ~(OPOST);
/* control modes - set 8 bit chars */
raw.c_cflag |= (CS8);
/* local modes - choing off, canonical off, no extended functions,
* no signal chars (^Z,^C) */
raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
/* control chars - set return condition: min number of bytes and timer.
* We want read to return every single byte, without timeout. */
raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */
/* put terminal in raw mode after flushing */
if (tcsetattr(fd,TCSADRAIN,&raw) < 0) goto fatal;
rawmode = 1;
return 0;
fatal:
errno = ENOTTY;
return -1;
}
static void disableRawMode(int fd) {
/* Don't even check the return value as it's too late. */
if (rawmode && tcsetattr(fd,TCSADRAIN,&orig_termios) != -1)
rawmode = 0;
}
/* Use the ESC [6n escape sequence to query the horizontal cursor position
* and return it. On error -1 is returned, on success the position of the
* cursor. */
static int getCursorPosition(int ifd, int ofd) {
char buf[32];
int cols, rows;
unsigned int i = 0;
/* Report cursor location */
if (write(ofd, "\x1b[6n", 4) != 4) return -1;
/* Read the response: ESC [ rows ; cols R */
while (i < sizeof(buf)-1) {
if (read(ifd,buf+i,1) != 1) break;
if (buf[i] == 'R') break;
i++;
}
buf[i] = '\0';
/* Parse it. */
if (buf[0] != ESC || buf[1] != '[') return -1;
if (sscanf(buf+2,"%d;%d",&rows,&cols) != 2) return -1;
return cols;
}
/* Try to get the number of columns in the current terminal, or assume 80
* if it fails. */
static int getColumns(int ifd, int ofd) {
struct winsize ws;
if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {
/* ioctl() failed. Try to query the terminal itself. */
int start, cols;
/* Get the initial position so we can restore it later. */
start = getCursorPosition(ifd,ofd);
if (start == -1) goto failed;
/* Go to right margin and get position. */
if (write(ofd,"\x1b[999C",6) != 6) goto failed;
cols = getCursorPosition(ifd,ofd);
if (cols == -1) goto failed;
/* Restore position. */
if (cols > start) {
char seq[32];
snprintf(seq,32,"\x1b[%dD",cols-start);
if (write(ofd,seq,strlen(seq)) == -1) {
/* Can't recover... */
}
}
return cols;
} else {
return ws.ws_col;
}
failed:
return 80;
}
/* Clear the screen. Used to handle ctrl+l */
void linenoiseClearScreen(void) {
if (write(STDOUT_FILENO,"\x1b[H\x1b[2J",7) <= 0) {
/* nothing to do, just to avoid warning. */
}
}
/* Beep, used for completion when there is nothing to complete or when all
* the choices were already shown. */
static void linenoiseBeep(void) {
fprintf(stderr, "\x7");
fflush(stderr);
}
/* ============================== Completion ================================ */
/* Free a list of completion option populated by linenoiseAddCompletion(). */
static void freeCompletions(linenoiseCompletions *lc) {
size_t i;
for (i = 0; i < lc->len; i++)
free(lc->cvec[i]);
if (lc->cvec != NULL)
free(lc->cvec);
}
/* This is an helper function for linenoiseEdit() and is called when the
* user types the key in order to complete the string currently in the
* input.
*
* The state of the editing is encapsulated into the pointed linenoiseState
* structure as described in the structure definition. */
static int completeLine(struct linenoiseState *ls) {
linenoiseCompletions lc = { 0, NULL };
int nread, nwritten;
char c = 0;
completionCallback(ls->buf,&lc);
if (lc.len == 0) {
linenoiseBeep();
} else {
size_t stop = 0, i = 0;
while(!stop) {
/* Show completion or original buffer */
if (i < lc.len) {
struct linenoiseState saved = *ls;
ls->len = ls->pos = strlen(lc.cvec[i]);
ls->buf = lc.cvec[i];
refreshLine(ls);
ls->len = saved.len;
ls->pos = saved.pos;
ls->buf = saved.buf;
} else {
refreshLine(ls);
}
nread = read(ls->ifd,&c,1);
if (nread <= 0) {
freeCompletions(&lc);
return -1;
}
switch(c) {
case 9: /* tab */
i = (i+1) % (lc.len+1);
if (i == lc.len) linenoiseBeep();
break;
case 27: /* escape */
/* Re-show original buffer */
if (i < lc.len) refreshLine(ls);
stop = 1;
break;
default:
/* Update buffer and return */
if (i < lc.len) {
nwritten = snprintf(ls->buf,ls->buflen,"%s",lc.cvec[i]);
ls->len = ls->pos = nwritten;
}
stop = 1;
break;
}
}
}
freeCompletions(&lc);
return c; /* Return last read character */
}
/* Register a callback function to be called for tab-completion. */
void linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn) {
completionCallback = fn;
}
/* Register a hits function to be called to show hits to the user at the
* right of the prompt. */
void linenoiseSetHintsCallback(linenoiseHintsCallback *fn) {
hintsCallback = fn;
}
/* Register a function to free the hints returned by the hints callback
* registered with linenoiseSetHintsCallback(). */
void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *fn) {
freeHintsCallback = fn;
}
/* This function is used by the callback function registered by the user
* in order to add completion options given the input string when the
* user typed . See the example.c source code for a very easy to
* understand example. */
void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) {
size_t len = strlen(str);
char *copy, **cvec;
copy = malloc(len+1);
if (copy == NULL) return;
memcpy(copy,str,len+1);
cvec = realloc(lc->cvec,sizeof(char*)*(lc->len+1));
if (cvec == NULL) {
free(copy);
return;
}
lc->cvec = cvec;
lc->cvec[lc->len++] = copy;
}
/* =========================== Line editing ================================= */
/* We define a very simple "append buffer" structure, that is an heap
* allocated string where we can append to. This is useful in order to
* write all the escape sequences in a buffer and flush them to the standard
* output in a single call, to avoid flickering effects. */
struct abuf {
char *b;
int len;
};
static void abInit(struct abuf *ab) {
ab->b = NULL;
ab->len = 0;
}
static void abAppend(struct abuf *ab, const char *s, int len) {
char *new = realloc(ab->b,ab->len+len);
if (new == NULL) return;
memcpy(new+ab->len,s,len);
ab->b = new;
ab->len += len;
}
static void abFree(struct abuf *ab) {
free(ab->b);
}
/* Helper of refreshSingleLine() and refreshMultiLine() to show hints
* to the right of the prompt. */
void refreshShowHints(struct abuf *ab, struct linenoiseState *l, int plen) {
char seq[64];
if (hintsCallback && plen+l->len < l->cols) {
int color = -1, bold = 0;
char *hint = hintsCallback(l->buf,&color,&bold);
if (hint) {
int hintlen = strlen(hint);
int hintmaxlen = l->cols-(plen+l->len);
if (hintlen > hintmaxlen) hintlen = hintmaxlen;
if (bold == 1 && color == -1) color = 37;
if (color != -1 || bold != 0)
snprintf(seq,64,"\033[%d;%d;49m",bold,color);
abAppend(ab,seq,strlen(seq));
abAppend(ab,hint,hintlen);
if (color != -1 || bold != 0)
abAppend(ab,"\033[0m",4);
/* Call the function to free the hint returned. */
if (freeHintsCallback) freeHintsCallback(hint);
}
}
}
/* Single line low level line refresh.
*
* Rewrite the currently edited line accordingly to the buffer content,
* cursor position, and number of columns of the terminal. */
static void refreshSingleLine(struct linenoiseState *l, const char *prompt) {
char seq[64];
size_t plen = strlen(prompt);
int fd = l->ofd;
char *buf = l->buf;
size_t len = l->len;
size_t pos = l->pos;
struct abuf ab;
if (plen >= l->cols) {
len=0; // not enough room
plen = l->cols;
}
while((plen+pos) >= l->cols && len>0) {
buf++;
len--;
pos--;
}
while (plen+len > l->cols && len>0) {
len--;
}
abInit(&ab);
/* Cursor to left edge */
snprintf(seq,64,"\r");
abAppend(&ab,seq,strlen(seq));
/* Write the prompt and the current buffer content */
abAppend(&ab,prompt,plen);
if (len > 0)
abAppend(&ab,buf,len);
/* Show hits if any. */
refreshShowHints(&ab,l,plen);
/* Erase to right */
snprintf(seq,64,"\x1b[0K");
abAppend(&ab,seq,strlen(seq));
/* Move cursor to original position. */
snprintf(seq,64,"\r\x1b[%dC", (int)(pos+plen));
abAppend(&ab,seq,strlen(seq));
if (write(fd,ab.b,ab.len) == -1) {} /* Can't recover from write error. */
abFree(&ab);
}
/* Multi line low level line refresh.
*
* Rewrite the currently edited line accordingly to the buffer content,
* cursor position, and number of columns of the terminal. */
static void refreshMultiLine(struct linenoiseState *l, const char *prompt) {
char seq[64];
int plen = strlen(prompt);
int rows = (plen+l->len+l->cols-1)/l->cols; /* rows used by current buf. */
int rpos = (plen+l->oldpos+l->cols)/l->cols; /* cursor relative row. */
int rpos2; /* rpos after refresh. */
int col; /* colum position, zero-based. */
int old_rows = l->maxrows;
size_t pos = l->pos;
int fd = l->ofd, j;
struct abuf ab;
/* Update maxrows if needed. */
if (rows > (int)l->maxrows) l->maxrows = rows;
/* First step: clear all the lines used before. To do so start by
* going to the last row. */
abInit(&ab);
if (old_rows-rpos > 0) {
lndebug("go down %d", old_rows-rpos);
snprintf(seq,64,"\x1b[%dB", old_rows-rpos);
abAppend(&ab,seq,strlen(seq));
}
/* Now for every row clear it, go up. */
for (j = 0; j < old_rows-1; j++) {
lndebug("clear+up");
snprintf(seq,64,"\r\x1b[0K\x1b[1A");
abAppend(&ab,seq,strlen(seq));
}
/* Clean the top line. */
lndebug("clear");
snprintf(seq,64,"\r\x1b[0K");
abAppend(&ab,seq,strlen(seq));
/* Write the prompt and the current buffer content */
abAppend(&ab,prompt,strlen(prompt));
abAppend(&ab,l->buf,l->len);
/* Show hits if any. */
refreshShowHints(&ab,l,plen);
/* If we are at the very end of the screen with our prompt, we need to
* emit a newline and move the prompt to the first column. */
if (pos &&
pos == l->len &&
(pos+plen) % l->cols == 0)
{
lndebug("");
abAppend(&ab,"\n",1);
snprintf(seq,64,"\r");
abAppend(&ab,seq,strlen(seq));
rows++;
if (rows > (int)l->maxrows) l->maxrows = rows;
}
/* Move cursor to right position. */
rpos2 = (plen+pos+l->cols)/l->cols; /* current cursor relative row. */
lndebug("rpos2 %d", rpos2);
/* Go up till we reach the expected positon. */
if (rows-rpos2 > 0) {
lndebug("go-up %d", rows-rpos2);
snprintf(seq,64,"\x1b[%dA", rows-rpos2);
abAppend(&ab,seq,strlen(seq));
}
/* Set column. */
col = (plen+(int)pos) % (int)l->cols;
lndebug("set col %d", 1+col);
if (col)
snprintf(seq,64,"\r\x1b[%dC", col);
else
snprintf(seq,64,"\r");
abAppend(&ab,seq,strlen(seq));
lndebug("\n");
l->oldpos = pos;
if (write(fd,ab.b,ab.len) == -1) {} /* Can't recover from write error. */
abFree(&ab);
}
/* Calls the two low level functions refreshSingleLine() or
* refreshMultiLine() according to the selected mode. */
static void refreshLinePrompt(struct linenoiseState *l, const char *prompt) {
if (mlmode)
refreshMultiLine(l, prompt);
else
refreshSingleLine(l, prompt);
}
static void refreshLine(struct linenoiseState *l) {
refreshLinePrompt(l, l->prompt);
}
/* Insert the character 'c' at cursor current position.
*
* On error writing to the terminal -1 is returned, otherwise 0. */
int linenoiseEditInsert(struct linenoiseState *l, char c) {
if (l->len < l->buflen) {
if (l->len == l->pos) {
l->buf[l->pos] = c;
l->pos++;
l->len++;
l->buf[l->len] = '\0';
if ((!mlmode && l->plen+l->len < l->cols && !hintsCallback)) {
/* Avoid a full update of the line in the
* trivial case. */
if (write(l->ofd,&c,1) == -1) return -1;
} else {
refreshLine(l);
}
} else {
memmove(l->buf+l->pos+1,l->buf+l->pos,l->len-l->pos);
l->buf[l->pos] = c;
l->len++;
l->pos++;
l->buf[l->len] = '\0';
refreshLine(l);
}
}
return 0;
}
/* Move cursor on the left. */
void linenoiseEditMoveLeft(struct linenoiseState *l) {
if (l->pos > 0) {
l->pos--;
refreshLine(l);
}
}
/* Move cursor on the right. */
void linenoiseEditMoveRight(struct linenoiseState *l) {
if (l->pos != l->len) {
l->pos++;
refreshLine(l);
}
}
/* Move cursor on the left */
void linenoiseEditMovePrevWord(struct linenoiseState *l) {
while (l->pos > 0 && l->buf[l->pos-1] == ' ')
l->pos--;
while (l->pos > 0 && l->buf[l->pos-1] != ' ')
l->pos--;
refreshLine(l);
}
/* Move cursor on the right. */
void linenoiseEditMoveNextWord(struct linenoiseState *l) {
while (l->pos < l->len && l->buf[l->pos-1] == ' ')
l->pos++;
while (l->pos < l->len && l->buf[l->pos-1] != ' ')
l->pos++;
refreshLine(l);
}
/* Move cursor to the start of the line. */
void linenoiseEditMoveHome(struct linenoiseState *l) {
if (l->pos != 0) {
l->pos = 0;
refreshLine(l);
}
}
/* Move cursor to the end of the line. */
void linenoiseEditMoveEnd(struct linenoiseState *l) {
if (l->pos != l->len) {
l->pos = l->len;
refreshLine(l);
}
}
/* Substitute the currently edited line with the next or previous history
* entry as specified by 'dir'. */
#define LINENOISE_HISTORY_NEXT 0
#define LINENOISE_HISTORY_PREV 1
void linenoiseEditHistoryNext(struct linenoiseState *l, int dir) {
if (history_len > 1) {
/* Update the current history entry before to
* overwrite it with the next one. */
free(history[history_len - 1 - l->history_index]);
history[history_len - 1 - l->history_index] = strdup(l->buf);
/* Show the new entry */
l->history_index += (dir == LINENOISE_HISTORY_PREV) ? 1 : -1;
if (l->history_index < 0) {
l->history_index = 0;
return;
} else if (l->history_index >= history_len) {
l->history_index = history_len-1;
return;
}
strncpy(l->buf,history[history_len - 1 - l->history_index],l->buflen);
l->buf[l->buflen-1] = '\0';
l->len = l->pos = strlen(l->buf);
refreshLine(l);
}
}
/* Delete the character at the right of the cursor without altering the cursor
* position. Basically this is what happens with the "Delete" keyboard key. */
void linenoiseEditDelete(struct linenoiseState *l) {
if (l->len > 0 && l->pos < l->len) {
memmove(l->buf+l->pos,l->buf+l->pos+1,l->len-l->pos-1);
l->len--;
l->buf[l->len] = '\0';
refreshLine(l);
}
}
/* Backspace implementation. */
void linenoiseEditBackspace(struct linenoiseState *l) {
if (l->pos > 0 && l->len > 0) {
memmove(l->buf+l->pos-1,l->buf+l->pos,l->len-l->pos);
l->pos--;
l->len--;
l->buf[l->len] = '\0';
refreshLine(l);
}
}
/* Delete the previous word, maintaining the cursor at the start of the
* current word. */
void linenoiseEditDeletePrevWord(struct linenoiseState *l) {
size_t old_pos = l->pos;
size_t diff;
while (l->pos > 0 && l->buf[l->pos-1] == ' ')
l->pos--;
while (l->pos > 0 && l->buf[l->pos-1] != ' ')
l->pos--;
diff = old_pos - l->pos;
memmove(l->buf+l->pos,l->buf+old_pos,l->len-old_pos+1);
l->len -= diff;
refreshLine(l);
}
/* Delete the next word, maintaining the cursor at the same position */
void linenoiseEditDeleteNextWord(struct linenoiseState *l) {
size_t next_pos = l->pos;
size_t diff;
while (next_pos < l->len && l->buf[next_pos] == ' ')
next_pos++;
while (next_pos < l->len && l->buf[next_pos] != ' ')
next_pos++;
diff = next_pos - l->pos;
memmove(l->buf+l->pos,l->buf+next_pos,l->len-next_pos+1);
l->len -= diff;
refreshLine(l);
}
void linenoiseReverseIncrementalSearch(struct linenoiseState *l) {
char search_buf[LINENOISE_MAX_LINE];
char search_prompt[LINENOISE_MAX_LINE];
int search_len = 0;
int search_pos = history_len - 1;
int search_dir = -1;
char* prompt;
int has_match = 1;
// backup of current input
char *buf;
{
size_t len = 1+ strlen(l->buf);
buf = malloc(len);
if (buf == NULL) return;
memcpy(buf, l->buf, len);
}
search_buf[0] = 0;
while (1) {
if (!has_match)
prompt = "(failed-reverse-i-search)`%s': ";
else
prompt = "(reverse-i-search)`%s': ";
if (!snprintf(search_prompt, sizeof(search_prompt), prompt, search_buf)) {
linenoiseBeep();
break;
} else {
search_prompt[sizeof(search_prompt)-1] = 0; // crop
}
l->pos = 0;
refreshLinePrompt(l, search_prompt);
char c;
int new_char = 0;
if (read(l->ifd, &c, 1) <= 0) {
l->pos = l->len = snprintf(l->buf, l->buflen, "%s", buf);
l->buf[l->buflen-1] = 0;
refreshLine(l);
free(buf);
return;
}
switch(c) {
case BACKSPACE:
case CTRL_H:
if (search_len > 0) {
search_buf[--search_len] = 0;
search_pos = history_len - 1;
} else
linenoiseBeep();
break;
case CTRL_N:
case CTRL_R:
search_dir = -1;
if (search_pos >= history_len)
search_pos = history_len - 1;
break;
case CTRL_P:
search_dir = 1;
if (search_pos < 0)
search_pos = 0;
break;
case ESC:
case CTRL_G:
l->pos = l->len = snprintf(l->buf, l->buflen, "%s", buf);
l->buf[l->buflen-1] = 0;
free(buf);
refreshLine(l);
return;
case ENTER:
free(buf);
l->pos = l->len;
refreshLine(l);
return;
default:
new_char = 1;
search_buf[search_len] = c;
search_buf[++search_len] = 0;
search_pos = history_len - 1;
break;
}
has_match = 0;
if (strlen(search_buf) > 0) {
for (; search_pos >= 0 && search_pos < history_len; search_pos += search_dir) {
if (strstr(history[search_pos], search_buf) && (new_char || strcmp(history[search_pos], l->buf))) {
has_match = 1;
l->len = snprintf(l->buf, l->buflen, "%s", history[search_pos]);
break;
}
}
if (!has_match) {
linenoiseBeep();
// forbid writes if the line is too long
if (search_len > 0 && new_char && search_len+1 >= sizeof(search_buf))
search_buf[--search_len] = 0;
}
}
}
}
/* This function is the core of the line editing capability of linenoise.
* It expects 'fd' to be already in "raw mode" so that every key pressed
* will be returned ASAP to read().
*
* The resulting string is put into 'buf' when the user type enter, or
* when ctrl+d is typed.
*
* The function returns the length of the current buffer. */
static int linenoiseEdit(int stdin_fd, int stdout_fd, char *buf, size_t buflen, const char *prompt)
{
struct linenoiseState l;
/* Populate the linenoise state that we pass to functions implementing
* specific editing functionalities. */
l.ifd = stdin_fd;
l.ofd = stdout_fd;
l.buf = buf;
l.buflen = buflen;
l.prompt = prompt;
l.plen = strlen(prompt);
l.oldpos = l.pos = 0;
l.len = 0;
l.cols = getColumns(stdin_fd, stdout_fd);
l.maxrows = 0;
l.history_index = 0;
/* Buffer starts empty. */
l.buf[0] = '\0';
l.buflen--; /* Make sure there is always space for the nulterm */
/* The latest history entry is always our current buffer, that
* initially is just an empty string. */
linenoiseHistoryAdd("");
if (write(l.ofd,prompt,l.plen) == -1) return -1;
while(1) {
char c;
int nread;
char seq[5];
nread = read(l.ifd,&c,1);
if (nread <= 0) return l.len;
/* Only autocomplete when the callback is set. It returns < 0 when
* there was an error reading from fd. Otherwise it will return the
* character that should be handled next. */
if (c == 9 && completionCallback != NULL) {
c = completeLine(&l);
/* Return on errors */
if (c < 0) return l.len;
/* Read next character when 0 */
if (c == 0) continue;
}
switch(c) {
case ENTER: /* enter */
history_len--;
free(history[history_len]);
if (mlmode) linenoiseEditMoveEnd(&l);
if (hintsCallback) {
/* Force a refresh without hints to leave the previous
* line as the user typed it after a newline. */
linenoiseHintsCallback *hc = hintsCallback;
hintsCallback = NULL;
refreshLine(&l);
hintsCallback = hc;
}
return (int)l.len;
case CTRL_C: /* ctrl-c */
errno = EAGAIN;
linenoiseWasInterrupted = 1;
return -1;
case BACKSPACE: /* backspace */
case 8: /* ctrl-h */
linenoiseEditBackspace(&l);
break;
case CTRL_D: /* ctrl-d, remove char at right of cursor, or if the
line is empty, act as end-of-file. */
if (l.len > 0) {
linenoiseEditDelete(&l);
} else {
history_len--;
free(history[history_len]);
return -1;
}
break;
case CTRL_T: /* ctrl-t, swaps current character with previous. */
if (l.pos > 0 && l.pos < l.len) {
int aux = buf[l.pos-1];
buf[l.pos-1] = buf[l.pos];
buf[l.pos] = aux;
if (l.pos != l.len-1) l.pos++;
refreshLine(&l);
}
break;
case CTRL_B: /* ctrl-b */
linenoiseEditMoveLeft(&l);
break;
case CTRL_F: /* ctrl-f */
linenoiseEditMoveRight(&l);
break;
case CTRL_P: /* ctrl-p */
linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_PREV);
break;
case CTRL_R: /* ctrl-r */
linenoiseReverseIncrementalSearch(&l);
break;
case CTRL_N: /* ctrl-n */
linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_NEXT);
break;
case ESC: /* escape sequence */
/* Read the next byte representing the escape sequence */
if (read(l.ifd,seq,1) == -1) break;
/* alt-b, alt-f, alt-d, alt-backspace */
if (seq[0] == 'b') {
linenoiseEditMovePrevWord(&l);
break;
} else if (seq[0] == 'f') {
linenoiseEditMoveNextWord(&l);
break;
} else if (seq[0] == 'd') {
linenoiseEditDeleteNextWord(&l);
break;
} else if (seq[0] == 127) { /* backspace */
linenoiseEditDeletePrevWord(&l);
break;
}
/* Read a second byte */
if (read(l.ifd,seq+1,1) == -1) break;
/* ESC [ sequences. */
if (seq[0] == '[') {
if (seq[1] >= '0' && seq[1] <= '9') {
/* Extended escape, read additional byte. */
if (read(l.ifd,seq+2,1) == -1) break;
if (seq[2] == '~') {
switch(seq[1]) {
case '3': /* Delete key. */
linenoiseEditDelete(&l);
break;
}
} else if (seq[2] == ';') {
/* read additional 2 bytes */
if (read(l.ifd,seq+3,1) == -1) break;
if (read(l.ifd,seq+4,1) == -1) break;
if (seq[3] == '5') {
switch (seq[4]) {
case 'D': /* ctrl-left */
linenoiseEditMovePrevWord(&l);
break;
case 'C': /* ctrl-right */
linenoiseEditMoveNextWord(&l);
break;
}
}
}
} else {
switch(seq[1]) {
case 'A': /* Up */
linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_PREV);
break;
case 'B': /* Down */
linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_NEXT);
break;
case 'C': /* Right */
linenoiseEditMoveRight(&l);
break;
case 'D': /* Left */
linenoiseEditMoveLeft(&l);
break;
case 'H': /* Home */
linenoiseEditMoveHome(&l);
break;
case 'F': /* End*/
linenoiseEditMoveEnd(&l);
break;
}
}
}
/* ESC O sequences. */
else if (seq[0] == 'O') {
switch(seq[1]) {
case 'H': /* Home */
linenoiseEditMoveHome(&l);
break;
case 'F': /* End*/
linenoiseEditMoveEnd(&l);
break;
}
}
break;
default:
if (linenoiseEditInsert(&l,c)) return -1;
break;
case CTRL_U: /* Ctrl+u, delete the whole line. */
buf[0] = '\0';
l.pos = l.len = 0;
refreshLine(&l);
break;
case CTRL_K: /* Ctrl+k, delete from current to end of line. */
buf[l.pos] = '\0';
l.len = l.pos;
refreshLine(&l);
break;
case CTRL_A: /* Ctrl+a, go to the start of the line */
linenoiseEditMoveHome(&l);
break;
case CTRL_E: /* ctrl+e, go to the end of the line */
linenoiseEditMoveEnd(&l);
break;
case CTRL_L: /* ctrl+l, clear screen */
linenoiseClearScreen();
refreshLine(&l);
break;
case CTRL_W: /* ctrl+w, delete previous word */
linenoiseEditDeletePrevWord(&l);
break;
}
}
return l.len;
}
/* This special mode is used by linenoise in order to print scan codes
* on screen for debugging / development purposes. It is implemented
* by the linenoise_example program using the --keycodes option. */
void linenoisePrintKeyCodes(void) {
char quit[4];
printf("Linenoise key codes debugging mode.\n"
"Press keys to see scan codes. Type 'quit' at any time to exit.\n");
if (enableRawMode(STDIN_FILENO) == -1) return;
memset(quit,' ',4);
while(1) {
char c;
int nread;
nread = read(STDIN_FILENO,&c,1);
if (nread <= 0) continue;
memmove(quit,quit+1,sizeof(quit)-1); /* shift string to left. */
quit[sizeof(quit)-1] = c; /* Insert current char on the right. */
if (memcmp(quit,"quit",sizeof(quit)) == 0) break;
printf("'%c' %02x (%d) (type quit to exit)\n",
isprint(c) ? c : '?', (int)c, (int)c);
printf("\r"); /* Go left edge manually, we are in raw mode. */
fflush(stdout);
}
disableRawMode(STDIN_FILENO);
}
/* This function calls the line editing function linenoiseEdit() using
* the STDIN file descriptor set in raw mode. */
static int linenoiseRaw(char *buf, size_t buflen, const char *prompt) {
int count;
if (buflen == 0) {
errno = EINVAL;
return -1;
}
if (enableRawMode(STDIN_FILENO) == -1) return -1;
count = linenoiseEdit(STDIN_FILENO, STDOUT_FILENO, buf, buflen, prompt);
disableRawMode(STDIN_FILENO);
printf("\n");
return count;
}
/* This function is called when linenoise() is called with the standard
* input file descriptor not attached to a TTY. So for example when the
* program using linenoise is called in pipe or with a file redirected
* to its standard input. In this case, we want to be able to return the
* line regardless of its length (by default we are limited to 4k). */
static char *linenoiseNoTTY(void) {
char *line = NULL;
size_t len = 0, maxlen = 0;
while(1) {
if (len == maxlen) {
if (maxlen == 0) maxlen = 16;
maxlen *= 2;
char *oldval = line;
line = realloc(line,maxlen);
if (line == NULL) {
if (oldval) free(oldval);
return NULL;
}
}
int c = fgetc(stdin);
if (c == EOF || c == '\n') {
if (c == EOF && len == 0) {
free(line);
return NULL;
} else {
line[len] = '\0';
return line;
}
} else {
line[len] = c;
len++;
}
}
}
/* The high level function that is the main API of the linenoise library.
* This function checks if the terminal has basic capabilities, just checking
* for a blacklist of stupid terminals, and later either calls the line
* editing function or uses dummy fgets() so that you will be able to type
* something even in the most desperate of the conditions. */
char *linenoise(const char *prompt) {
char buf[LINENOISE_MAX_LINE];
int count;
if (!isatty(STDIN_FILENO)) {
/* Not a tty: read from file / pipe. In this mode we don't want any
* limit to the line size, so we call a function to handle that. */
return linenoiseNoTTY();
} else if (isUnsupportedTerm()) {
size_t len;
printf("%s",prompt);
fflush(stdout);
if (fgets(buf,LINENOISE_MAX_LINE,stdin) == NULL) return NULL;
len = strlen(buf);
while(len && (buf[len-1] == '\n' || buf[len-1] == '\r')) {
len--;
buf[len] = '\0';
}
return strdup(buf);
} else {
count = linenoiseRaw(buf,LINENOISE_MAX_LINE,prompt);
if (count == -1) return NULL;
return strdup(buf);
}
}
/* This is just a wrapper the user may want to call in order to make sure
* the linenoise returned buffer is freed with the same allocator it was
* created with. Useful when the main program is using an alternative
* allocator. */
void linenoiseFree(void *ptr) {
free(ptr);
}
/* ================================ History ================================= */
/* Free the history, but does not reset it. Only used when we have to
* exit() to avoid memory leaks are reported by valgrind & co. */
static void freeHistory(void) {
if (history) {
int j;
for (j = 0; j < history_len; j++)
free(history[j]);
free(history);
}
}
/* At exit we'll try to fix the terminal to the initial conditions. */
static void linenoiseAtExit(void) {
disableRawMode(STDIN_FILENO);
freeHistory();
}
/* This is the API call to add a new entry in the linenoise history.
* It uses a fixed array of char pointers that are shifted (memmoved)
* when the history max length is reached in order to remove the older
* entry and make room for the new one, so it is not exactly suitable for huge
* histories, but will work well for a few hundred of entries.
*
* Using a circular buffer is smarter, but a bit more complex to handle. */
int linenoiseHistoryAdd(const char *line) {
char *linecopy;
if (history_max_len == 0) return 0;
/* Initialization on first call. */
if (history == NULL) {
history = malloc(sizeof(char*)*history_max_len);
if (history == NULL) return 0;
memset(history,0,(sizeof(char*)*history_max_len));
}
/* Don't add duplicated lines. */
if (history_len && !strcmp(history[history_len-1], line)) return 0;
/* Add an heap allocated copy of the line in the history.
* If we reached the max length, remove the older line. */
linecopy = strdup(line);
if (!linecopy) return 0;
if (history_len == history_max_len) {
free(history[0]);
memmove(history,history+1,sizeof(char*)*(history_max_len-1));
history_len--;
}
history[history_len] = linecopy;
history_len++;
return 1;
}
/* Set the maximum length for the history. This function can be called even
* if there is already some history, the function will make sure to retain
* just the latest 'len' elements if the new history length value is smaller
* than the amount of items already inside the history. */
int linenoiseHistorySetMaxLen(int len) {
char **new;
if (len < 1) return 0;
if (history) {
int tocopy = history_len;
new = malloc(sizeof(char*)*len);
if (new == NULL) return 0;
/* If we can't copy everything, free the elements we'll not use. */
if (len < tocopy) {
int j;
for (j = 0; j < tocopy-len; j++) free(history[j]);
tocopy = len;
}
memset(new,0,sizeof(char*)*len);
memcpy(new,history+(history_len-tocopy), sizeof(char*)*tocopy);
free(history);
history = new;
}
history_max_len = len;
if (history_len > history_max_len)
history_len = history_max_len;
return 1;
}
/* Save the history in the specified file. On success 0 is returned
* otherwise -1 is returned. */
int linenoiseHistorySave(const char *filename) {
mode_t old_umask = umask(S_IXUSR|S_IRWXG|S_IRWXO);
FILE *fp;
int j;
fp = fopen(filename,"w");
umask(old_umask);
if (fp == NULL) return -1;
chmod(filename,S_IRUSR|S_IWUSR);
for (j = 0; j < history_len; j++)
fprintf(fp,"%s\n",history[j]);
fclose(fp);
return 0;
}
/* Load the history from the specified file. If the file does not exist
* zero is returned and no operation is performed.
*
* If the file exists and the operation succeeded 0 is returned, otherwise
* on error -1 is returned. */
int linenoiseHistoryLoad(const char *filename) {
FILE *fp = fopen(filename,"r");
char buf[LINENOISE_MAX_LINE];
if (fp == NULL) return -1;
while (fgets(buf,LINENOISE_MAX_LINE,fp) != NULL) {
char *p;
p = strchr(buf,'\r');
if (!p) p = strchr(buf,'\n');
if (p) *p = '\0';
linenoiseHistoryAdd(buf);
}
fclose(fp);
return 0;
}
ocaml-linenoise-1.5.1/src/linenoise_src.h 0000664 0000000 0000000 00000005537 14576632421 0020414 0 ustar 00root root 0000000 0000000 /* linenoise.h -- VERSION 1.0
*
* Guerrilla line editing library against the idea that a line editing lib
* needs to be 20,000 lines of C code.
*
* See linenoise.c for more information.
*
* ------------------------------------------------------------------------
*
* Copyright (c) 2010-2014, Salvatore Sanfilippo
* Copyright (c) 2010-2013, Pieter Noordhuis
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __LINENOISE_H
#define __LINENOISE_H
#ifdef __cplusplus
extern "C" {
#endif
extern int linenoiseWasInterrupted; /* boolean signalling if last call was ctrl-c */
typedef struct linenoiseCompletions {
size_t len;
char **cvec;
} linenoiseCompletions;
typedef void(linenoiseCompletionCallback)(const char *, linenoiseCompletions *);
typedef char*(linenoiseHintsCallback)(const char *, int *color, int *bold);
typedef void(linenoiseFreeHintsCallback)(void *);
void linenoiseSetCompletionCallback(linenoiseCompletionCallback *);
void linenoiseSetHintsCallback(linenoiseHintsCallback *);
void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *);
void linenoiseAddCompletion(linenoiseCompletions *, const char *);
char *linenoise(const char *prompt);
void linenoiseFree(void *ptr);
int linenoiseHistoryAdd(const char *line);
int linenoiseHistorySetMaxLen(int len);
int linenoiseHistorySave(const char *filename);
int linenoiseHistoryLoad(const char *filename);
void linenoiseClearScreen(void);
void linenoiseSetMultiLine(int ml);
void linenoisePrintKeyCodes(void);
#ifdef __cplusplus
}
#endif
#endif /* __LINENOISE_H */
ocaml-linenoise-1.5.1/src/linenoise_stubs.c 0000664 0000000 0000000 00000010715 14576632421 0020752 0 ustar 00root root 0000000 0000000 // OCaml declarations
#include
#include
#include
#include
#include
#include
#include
#include "linenoise_src.h"
// Ripped from ctypes
#define Val_none Val_int(0)
#define Some_val(v) Field(v, 0)
static value Val_some(value v)
{
CAMLparam1(v);
CAMLlocal1(some);
some = caml_alloc(1, 0);
Store_field(some, 0, v);
CAMLreturn(some);
}
/* if true, raise Sys.Break on ctrl-c */
static int raise_sys_break = 0;
CAMLprim value ml_catch_break(value flag)
{
CAMLparam1(flag);
raise_sys_break = Bool_val(flag);
CAMLreturn(Val_unit);
}
CAMLprim value ml_add_completion(value completions, value new_completion)
{
CAMLparam2(completions, new_completion);
char* c_new_completion = caml_stat_strdup(String_val(new_completion));
linenoiseAddCompletion((linenoiseCompletions *)completions, c_new_completion);
caml_stat_free(c_new_completion);
CAMLreturn(Val_unit);
}
// this bridge runs with the runtime lock acquired
static void completion_bridge_inner(const char *buf, linenoiseCompletions *lc)
{
CAMLparam0();
CAMLlocal1(str_copy);
str_copy = caml_copy_string(buf);
caml_callback2(*caml_named_value("lnoise_completion_cb"), str_copy, (value)lc);
CAMLreturn0;
}
static void completion_bridge(const char *buf, linenoiseCompletions *lc)
{
caml_acquire_runtime_system();
completion_bridge_inner(buf, lc);
caml_release_runtime_system();
}
static char *hints_bridge_inner(const char *buf, int *color, int *bold)
{
CAMLparam0();
CAMLlocal2(str_copy, cb_result);
str_copy = caml_copy_string(buf);
cb_result = caml_callback(*caml_named_value("lnoise_hints_cb"), str_copy);
if (cb_result == Val_none) {
CAMLreturnT(char *,NULL);
} else {
char* msg = caml_stat_strdup(String_val(Field(Field(cb_result, 0), 0)));
*color = Int_val(Field(Field(cb_result, 0), 1)) + 31;
*bold = Bool_val(Field(Field(cb_result, 0), 2));
CAMLreturnT(char *,msg);
}
}
static char *hints_bridge(const char *buf, int *color, int *bold)
{
caml_acquire_runtime_system();
char* res = hints_bridge_inner(buf, color, bold);
caml_release_runtime_system();
return res;
}
static void free_hints_bridge(void* data) {
caml_acquire_runtime_system();
caml_stat_free(data);
caml_release_runtime_system();
}
__attribute__((constructor))
void set_free_hints(void) { linenoiseSetFreeHintsCallback(free); }
CAMLprim value ml_setup_bridges(value unit) {
CAMLparam1(unit);
linenoiseSetCompletionCallback(completion_bridge);
linenoiseSetHintsCallback(hints_bridge);
linenoiseSetFreeHintsCallback(free_hints_bridge);
CAMLreturn(Val_unit);
}
CAMLprim value ml_linenoise(value prompt)
{
CAMLparam1(prompt);
CAMLlocal1(lnoise_result);
linenoiseWasInterrupted = 0; // reset
char* c_prompt = caml_stat_strdup(String_val(prompt));
caml_release_runtime_system();
const char *result = linenoise(c_prompt);
caml_acquire_runtime_system();
caml_stat_free(c_prompt);
if (!result) {
if (linenoiseWasInterrupted && raise_sys_break) {
caml_raise_constant(*caml_named_value("sys_break"));
} else {
CAMLreturn(Val_none);
}
}
lnoise_result = caml_copy_string(result);
linenoiseFree((void*)result);
CAMLreturn(Val_some(lnoise_result));
}
CAMLprim value ml_history_add(value line)
{
CAMLparam1(line);
char* c_line = caml_stat_strdup(String_val(line));
int res = linenoiseHistoryAdd(c_line);
caml_stat_free(c_line);
CAMLreturn(Val_int(res));
}
CAMLprim value ml_history_set_maxlen(value max)
{
CAMLparam1(max);
CAMLreturn(Val_int(linenoiseHistorySetMaxLen(Int_val(max))));
}
CAMLprim value ml_history_save(value filename)
{
CAMLparam1(filename);
char* c_filename = caml_stat_strdup(String_val(filename));
int res = linenoiseHistorySave(c_filename);
caml_stat_free(c_filename);
CAMLreturn(Val_int(res));
}
CAMLprim value ml_history_load(value filename)
{
CAMLparam1(filename);
char* c_filename= caml_stat_strdup(String_val(filename));
int res = linenoiseHistoryLoad(c_filename);
caml_stat_free(c_filename);
CAMLreturn(Val_int(res));
}
CAMLprim value ml_clearscreen(__attribute__((unused))value unit)
{
CAMLparam0();
linenoiseClearScreen();
CAMLreturn(Val_unit);
}
CAMLprim value ml_set_multiline(value use_multiline)
{
CAMLparam1(use_multiline);
linenoiseSetMultiLine(Bool_val(use_multiline));
CAMLreturn(Val_unit);
}
CAMLprim value ml_printkeycodes(void)
{
CAMLparam0();
linenoisePrintKeyCodes();
CAMLreturn(Val_unit);
}